diff --git a/Utilities/rFile.cpp b/Utilities/rFile.cpp index 88db8ad28e..657a143f28 100644 --- a/Utilities/rFile.cpp +++ b/Utilities/rFile.cpp @@ -127,7 +127,7 @@ bool rRename(const std::string &from, const std::string &to) #ifdef _WIN32 if (!MoveFile(ConvertUTF8ToWString(from).c_str(), ConvertUTF8ToWString(to).c_str())) #else - if (rename(from.c_str(), to.c_str())) + if (int err = rename(from.c_str(), to.c_str())) #endif { LOG_ERROR(GENERAL, "Error renaming '%s' to '%s': 0x%llx", from.c_str(), to.c_str(), (u64)GET_API_ERROR); diff --git a/rpcs3/Emu/ARMv7/ARMv7Thread.cpp b/rpcs3/Emu/ARMv7/ARMv7Thread.cpp index 876824b9c4..564dd59e02 100644 --- a/rpcs3/Emu/ARMv7/ARMv7Thread.cpp +++ b/rpcs3/Emu/ARMv7/ARMv7Thread.cpp @@ -229,6 +229,7 @@ void ARMv7Thread::FastCall(u32 addr) void ARMv7Thread::FastStop() { m_status = Stopped; + m_events |= CPU_EVENT_STOP; } armv7_thread::armv7_thread(u32 entry, const std::string& name, u32 stack_size, s32 prio) diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp index 9710b85c5d..a490d187d4 100644 --- a/rpcs3/Emu/CPU/CPUThread.cpp +++ b/rpcs3/Emu/CPU/CPUThread.cpp @@ -17,6 +17,7 @@ CPUThread* GetCurrentCPUThread() CPUThread::CPUThread(CPUThreadType type) : ThreadBase("CPUThread") + , m_events(0) , m_type(type) , m_stack_size(0) , m_stack_addr(0) @@ -242,6 +243,7 @@ void CPUThread::Stop() SendDbgCommand(DID_STOP_THREAD, this); m_status = Stopped; + m_events |= CPU_EVENT_STOP; if(static_cast(this) != GetCurrentNamedThread()) { diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h index 13e8e7ebbf..e81d79216e 100644 --- a/rpcs3/Emu/CPU/CPUThread.h +++ b/rpcs3/Emu/CPU/CPUThread.h @@ -20,11 +20,19 @@ enum CPUThreadStatus CPUThread_Step, }; +// CPU Thread Events +enum : u64 +{ + CPU_EVENT_STOP = (1ull << 0), +}; + class CPUDecoder; class CPUThread : public ThreadBase { protected: + std::atomic m_events; // flags + u32 m_status; u32 m_id; u64 m_prio; @@ -45,6 +53,8 @@ protected: virtual void DumpInformation() override; public: + void AddEvent(const u64 event) { m_events |= event; } + virtual void InitRegs() = 0; virtual void InitStack() = 0; diff --git a/rpcs3/Emu/Cell/PPUInterpreter.cpp b/rpcs3/Emu/Cell/PPUInterpreter.cpp new file mode 100644 index 0000000000..3e0a1b7a65 --- /dev/null +++ b/rpcs3/Emu/Cell/PPUInterpreter.cpp @@ -0,0 +1,2001 @@ +#include "stdafx.h" +#include "Utilities/Log.h" +#include "Emu/Memory/Memory.h" +#include "Emu/System.h" +#include "Emu/Cell/PPUThread.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/Modules.h" +#include "Emu/Cell/PPUDecoder.h" +#include "PPUInstrTable.h" +#include "PPUInterpreter.h" +#include "PPUInterpreter2.h" +#include "Emu/CPU/CPUThreadManager.h" + +void ppu_interpreter::NULL_OP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::NOP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + + +void ppu_interpreter::TDI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::TWI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + + +void ppu_interpreter::MFVSCR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTVSCR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDCUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDSBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDSHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDSWS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDUBM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDUBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDUHM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDUHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDUWM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VADDUWS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAND(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VANDC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAVGSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAVGSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAVGSW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAVGUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAVGUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VAVGUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCFSX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCFUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPBFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPBFP_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQFP_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQUB_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQUH_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPEQUW_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGEFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGEFP_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTFP_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTSB_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTSH_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTSW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTSW_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTUB_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTUH_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCMPGTUW_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCTSXS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VCTUXS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VEXPTEFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VLOGEFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMADDFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXSW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMAXUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMHADDSHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMHRADDSHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINSW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMINUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMLADDUHM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMRGHB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMRGHH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMRGHW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMRGLB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMRGLH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMRGLW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMSUMMBM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMSUMSHM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMSUMSHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMSUMUBM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMSUMUHM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMSUMUHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULESB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULESH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULEUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULEUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULOSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULOSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULOUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VMULOUH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VNMSUBFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VNOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPERM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKPX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKSHSS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKSHUS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKSWSS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKSWUS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKUHUM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKUHUS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKUWUM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VPKUWUS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VREFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRFIM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRFIN(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRFIP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRFIZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRLB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRLH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRLW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VRSQRTEFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSEL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSLB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSLDOI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSLH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSLO(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSLW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSPLTB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSPLTH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSPLTISB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSPLTISH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSPLTISW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSPLTW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRAB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRAH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRAW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRO(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSRW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBCUW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBFP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBSBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBSHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBSWS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBUBM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBUBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBUHM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBUHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBUWM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUBUWS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUMSWS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUM2SWS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUM4SBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUM4SHS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VSUM4UBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VUPKHPX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VUPKHSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VUPKHSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VUPKLPX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VUPKLSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VUPKLSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::VXOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULLI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SUBFIC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CMPLI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CMPI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDIC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDIC_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDIS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::BC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::HACK(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::B(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MCRF(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::BCLR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CRNOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CRANDC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ISYNC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CRXOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CRNAND(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CRAND(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CREQV(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CRORC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CROR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::BCCTR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLWIMI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLWINM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLWNM(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ORI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ORIS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::XORI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::XORIS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ANDI_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ANDIS_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLDICL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLDICR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLDIC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLDIMI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::RLDC_LR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CMP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::TW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVSL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVEBX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SUBFC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULHDU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULHWU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MFOCRF(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWARX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LDX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWZX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SLW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CNTLZW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SLD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::AND(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CMPL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVSR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVEHX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SUBF(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LDUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DCBST(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWZUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::CNTLZD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ANDC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::TD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVEWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULHD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULHW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LDARX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DCBF(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LBZX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::NEG(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LBZUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::NOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVEBX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SUBFE(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDE(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTOCRF(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STDX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STWCX_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVEHX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STDUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STWUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVEWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SUBFZE(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDZE(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STDCX_(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STBX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULLD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SUBFME(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADDME(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MULLW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DCBTST(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STBUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ADD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DCBT(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHZX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::EQV(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ECIWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHZUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::XOR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MFSPR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWAX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DST(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHAX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVXL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MFTB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWAUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DSTST(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHAUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STHX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ORC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ECOWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STHUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::OR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DIVDU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DIVWU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTSPR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DCBI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::NAND(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVXL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DIVD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DIVW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVLX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LDBRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LSWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWBRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFSX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LSWI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFSUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SYNC(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFDX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFDUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVLX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STDBRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STSWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STWBRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFSX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFSUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STSWI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFDX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFDUX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVLXL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHBRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRAW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRAD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LVRXL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DSS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRAWI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRADI1(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::SRADI2(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::EIEIO(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVLXL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STHBRX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::EXTSH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STVRXL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::EXTSB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFIWX(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::EXTSW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::ICBI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::DCBZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWZU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LBZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LBZU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STWU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STBU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHZU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHA(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LHAU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STH(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STHU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LMW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STMW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFSU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LFDU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFSU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STFDU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LDU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::LWA(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FDIVS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FSUBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FADDS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FSQRTS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FRES(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMULS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMADDS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMSUBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FNMSUBS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FNMADDS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::STDU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTFSB1(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MCRFS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTFSB0(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTFSFI(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MFFS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::MTFSF(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + + +void ppu_interpreter::FCMPU(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FRSP(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FCTIW(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FCTIWZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FDIV(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FSUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FADD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FSQRT(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FSEL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMUL(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FRSQRTE(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMSUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMADD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FNMSUB(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FNMADD(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FCMPO(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FNEG(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FMR(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FNABS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FABS(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FCTID(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FCTIDZ(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + +void ppu_interpreter::FCFID(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} + + +void ppu_interpreter::UNK(PPUThread& CPU, ppu_opcode_t op) +{ + PPUInterpreter inter(CPU); (*PPU_instr::main_list)(&inter, op.opcode); +} diff --git a/rpcs3/Emu/Cell/PPUInterpreter.h b/rpcs3/Emu/Cell/PPUInterpreter.h index 7e53616f8b..f6dd80453a 100644 --- a/rpcs3/Emu/Cell/PPUInterpreter.h +++ b/rpcs3/Emu/Cell/PPUInterpreter.h @@ -18,6 +18,7 @@ #include extern u64 rotate_mask[64][64]; // defined in PPUThread.cpp, static didn't work correctly in GCC 4.9 for some reason + inline void InitRotateMask() { static bool inited = false; @@ -91,7 +92,6 @@ private: public: PPUInterpreter(PPUThread& cpu) : CPU(cpu) { - InitRotateMask(); } private: diff --git a/rpcs3/Emu/Cell/PPUInterpreter2.h b/rpcs3/Emu/Cell/PPUInterpreter2.h new file mode 100644 index 0000000000..6bd9373790 --- /dev/null +++ b/rpcs3/Emu/Cell/PPUInterpreter2.h @@ -0,0 +1,826 @@ +#pragma once +#include "PPUOpcodes.h" + +class PPUThread; + +union ppu_opcode_t +{ + u32 opcode; +}; + +using ppu_inter_func_t = void(*)(PPUThread& CPU, ppu_opcode_t opcode); + +namespace ppu_interpreter +{ + void NULL_OP(PPUThread& CPU, ppu_opcode_t op); + void NOP(PPUThread& CPU, ppu_opcode_t op); + + void TDI(PPUThread& CPU, ppu_opcode_t op); + void TWI(PPUThread& CPU, ppu_opcode_t op); + + void MFVSCR(PPUThread& CPU, ppu_opcode_t op); + void MTVSCR(PPUThread& CPU, ppu_opcode_t op); + void VADDCUW(PPUThread& CPU, ppu_opcode_t op); + void VADDFP(PPUThread& CPU, ppu_opcode_t op); + void VADDSBS(PPUThread& CPU, ppu_opcode_t op); + void VADDSHS(PPUThread& CPU, ppu_opcode_t op); + void VADDSWS(PPUThread& CPU, ppu_opcode_t op); + void VADDUBM(PPUThread& CPU, ppu_opcode_t op); + void VADDUBS(PPUThread& CPU, ppu_opcode_t op); + void VADDUHM(PPUThread& CPU, ppu_opcode_t op); + void VADDUHS(PPUThread& CPU, ppu_opcode_t op); + void VADDUWM(PPUThread& CPU, ppu_opcode_t op); + void VADDUWS(PPUThread& CPU, ppu_opcode_t op); + void VAND(PPUThread& CPU, ppu_opcode_t op); + void VANDC(PPUThread& CPU, ppu_opcode_t op); + void VAVGSB(PPUThread& CPU, ppu_opcode_t op); + void VAVGSH(PPUThread& CPU, ppu_opcode_t op); + void VAVGSW(PPUThread& CPU, ppu_opcode_t op); + void VAVGUB(PPUThread& CPU, ppu_opcode_t op); + void VAVGUH(PPUThread& CPU, ppu_opcode_t op); + void VAVGUW(PPUThread& CPU, ppu_opcode_t op); + void VCFSX(PPUThread& CPU, ppu_opcode_t op); + void VCFUX(PPUThread& CPU, ppu_opcode_t op); + void VCMPBFP(PPUThread& CPU, ppu_opcode_t op); + void VCMPBFP_(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQFP(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQFP_(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQUB(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQUB_(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQUH(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQUH_(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQUW(PPUThread& CPU, ppu_opcode_t op); + void VCMPEQUW_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGEFP(PPUThread& CPU, ppu_opcode_t op); + void VCMPGEFP_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTFP(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTFP_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTSB(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTSB_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTSH(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTSH_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTSW(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTSW_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTUB(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTUB_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTUH(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTUH_(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTUW(PPUThread& CPU, ppu_opcode_t op); + void VCMPGTUW_(PPUThread& CPU, ppu_opcode_t op); + void VCTSXS(PPUThread& CPU, ppu_opcode_t op); + void VCTUXS(PPUThread& CPU, ppu_opcode_t op); + void VEXPTEFP(PPUThread& CPU, ppu_opcode_t op); + void VLOGEFP(PPUThread& CPU, ppu_opcode_t op); + void VMADDFP(PPUThread& CPU, ppu_opcode_t op); + void VMAXFP(PPUThread& CPU, ppu_opcode_t op); + void VMAXSB(PPUThread& CPU, ppu_opcode_t op); + void VMAXSH(PPUThread& CPU, ppu_opcode_t op); + void VMAXSW(PPUThread& CPU, ppu_opcode_t op); + void VMAXUB(PPUThread& CPU, ppu_opcode_t op); + void VMAXUH(PPUThread& CPU, ppu_opcode_t op); + void VMAXUW(PPUThread& CPU, ppu_opcode_t op); + void VMHADDSHS(PPUThread& CPU, ppu_opcode_t op); + void VMHRADDSHS(PPUThread& CPU, ppu_opcode_t op); + void VMINFP(PPUThread& CPU, ppu_opcode_t op); + void VMINSB(PPUThread& CPU, ppu_opcode_t op); + void VMINSH(PPUThread& CPU, ppu_opcode_t op); + void VMINSW(PPUThread& CPU, ppu_opcode_t op); + void VMINUB(PPUThread& CPU, ppu_opcode_t op); + void VMINUH(PPUThread& CPU, ppu_opcode_t op); + void VMINUW(PPUThread& CPU, ppu_opcode_t op); + void VMLADDUHM(PPUThread& CPU, ppu_opcode_t op); + void VMRGHB(PPUThread& CPU, ppu_opcode_t op); + void VMRGHH(PPUThread& CPU, ppu_opcode_t op); + void VMRGHW(PPUThread& CPU, ppu_opcode_t op); + void VMRGLB(PPUThread& CPU, ppu_opcode_t op); + void VMRGLH(PPUThread& CPU, ppu_opcode_t op); + void VMRGLW(PPUThread& CPU, ppu_opcode_t op); + void VMSUMMBM(PPUThread& CPU, ppu_opcode_t op); + void VMSUMSHM(PPUThread& CPU, ppu_opcode_t op); + void VMSUMSHS(PPUThread& CPU, ppu_opcode_t op); + void VMSUMUBM(PPUThread& CPU, ppu_opcode_t op); + void VMSUMUHM(PPUThread& CPU, ppu_opcode_t op); + void VMSUMUHS(PPUThread& CPU, ppu_opcode_t op); + void VMULESB(PPUThread& CPU, ppu_opcode_t op); + void VMULESH(PPUThread& CPU, ppu_opcode_t op); + void VMULEUB(PPUThread& CPU, ppu_opcode_t op); + void VMULEUH(PPUThread& CPU, ppu_opcode_t op); + void VMULOSB(PPUThread& CPU, ppu_opcode_t op); + void VMULOSH(PPUThread& CPU, ppu_opcode_t op); + void VMULOUB(PPUThread& CPU, ppu_opcode_t op); + void VMULOUH(PPUThread& CPU, ppu_opcode_t op); + void VNMSUBFP(PPUThread& CPU, ppu_opcode_t op); + void VNOR(PPUThread& CPU, ppu_opcode_t op); + void VOR(PPUThread& CPU, ppu_opcode_t op); + void VPERM(PPUThread& CPU, ppu_opcode_t op); + void VPKPX(PPUThread& CPU, ppu_opcode_t op); + void VPKSHSS(PPUThread& CPU, ppu_opcode_t op); + void VPKSHUS(PPUThread& CPU, ppu_opcode_t op); + void VPKSWSS(PPUThread& CPU, ppu_opcode_t op); + void VPKSWUS(PPUThread& CPU, ppu_opcode_t op); + void VPKUHUM(PPUThread& CPU, ppu_opcode_t op); + void VPKUHUS(PPUThread& CPU, ppu_opcode_t op); + void VPKUWUM(PPUThread& CPU, ppu_opcode_t op); + void VPKUWUS(PPUThread& CPU, ppu_opcode_t op); + void VREFP(PPUThread& CPU, ppu_opcode_t op); + void VRFIM(PPUThread& CPU, ppu_opcode_t op); + void VRFIN(PPUThread& CPU, ppu_opcode_t op); + void VRFIP(PPUThread& CPU, ppu_opcode_t op); + void VRFIZ(PPUThread& CPU, ppu_opcode_t op); + void VRLB(PPUThread& CPU, ppu_opcode_t op); + void VRLH(PPUThread& CPU, ppu_opcode_t op); + void VRLW(PPUThread& CPU, ppu_opcode_t op); + void VRSQRTEFP(PPUThread& CPU, ppu_opcode_t op); + void VSEL(PPUThread& CPU, ppu_opcode_t op); + void VSL(PPUThread& CPU, ppu_opcode_t op); + void VSLB(PPUThread& CPU, ppu_opcode_t op); + void VSLDOI(PPUThread& CPU, ppu_opcode_t op); + void VSLH(PPUThread& CPU, ppu_opcode_t op); + void VSLO(PPUThread& CPU, ppu_opcode_t op); + void VSLW(PPUThread& CPU, ppu_opcode_t op); + void VSPLTB(PPUThread& CPU, ppu_opcode_t op); + void VSPLTH(PPUThread& CPU, ppu_opcode_t op); + void VSPLTISB(PPUThread& CPU, ppu_opcode_t op); + void VSPLTISH(PPUThread& CPU, ppu_opcode_t op); + void VSPLTISW(PPUThread& CPU, ppu_opcode_t op); + void VSPLTW(PPUThread& CPU, ppu_opcode_t op); + void VSR(PPUThread& CPU, ppu_opcode_t op); + void VSRAB(PPUThread& CPU, ppu_opcode_t op); + void VSRAH(PPUThread& CPU, ppu_opcode_t op); + void VSRAW(PPUThread& CPU, ppu_opcode_t op); + void VSRB(PPUThread& CPU, ppu_opcode_t op); + void VSRH(PPUThread& CPU, ppu_opcode_t op); + void VSRO(PPUThread& CPU, ppu_opcode_t op); + void VSRW(PPUThread& CPU, ppu_opcode_t op); + void VSUBCUW(PPUThread& CPU, ppu_opcode_t op); + void VSUBFP(PPUThread& CPU, ppu_opcode_t op); + void VSUBSBS(PPUThread& CPU, ppu_opcode_t op); + void VSUBSHS(PPUThread& CPU, ppu_opcode_t op); + void VSUBSWS(PPUThread& CPU, ppu_opcode_t op); + void VSUBUBM(PPUThread& CPU, ppu_opcode_t op); + void VSUBUBS(PPUThread& CPU, ppu_opcode_t op); + void VSUBUHM(PPUThread& CPU, ppu_opcode_t op); + void VSUBUHS(PPUThread& CPU, ppu_opcode_t op); + void VSUBUWM(PPUThread& CPU, ppu_opcode_t op); + void VSUBUWS(PPUThread& CPU, ppu_opcode_t op); + void VSUMSWS(PPUThread& CPU, ppu_opcode_t op); + void VSUM2SWS(PPUThread& CPU, ppu_opcode_t op); + void VSUM4SBS(PPUThread& CPU, ppu_opcode_t op); + void VSUM4SHS(PPUThread& CPU, ppu_opcode_t op); + void VSUM4UBS(PPUThread& CPU, ppu_opcode_t op); + void VUPKHPX(PPUThread& CPU, ppu_opcode_t op); + void VUPKHSB(PPUThread& CPU, ppu_opcode_t op); + void VUPKHSH(PPUThread& CPU, ppu_opcode_t op); + void VUPKLPX(PPUThread& CPU, ppu_opcode_t op); + void VUPKLSB(PPUThread& CPU, ppu_opcode_t op); + void VUPKLSH(PPUThread& CPU, ppu_opcode_t op); + void VXOR(PPUThread& CPU, ppu_opcode_t op); + void MULLI(PPUThread& CPU, ppu_opcode_t op); + void SUBFIC(PPUThread& CPU, ppu_opcode_t op); + void CMPLI(PPUThread& CPU, ppu_opcode_t op); + void CMPI(PPUThread& CPU, ppu_opcode_t op); + void ADDIC(PPUThread& CPU, ppu_opcode_t op); + void ADDIC_(PPUThread& CPU, ppu_opcode_t op); + void ADDI(PPUThread& CPU, ppu_opcode_t op); + void ADDIS(PPUThread& CPU, ppu_opcode_t op); + void BC(PPUThread& CPU, ppu_opcode_t op); + void HACK(PPUThread& CPU, ppu_opcode_t op); + void SC(PPUThread& CPU, ppu_opcode_t op); + void B(PPUThread& CPU, ppu_opcode_t op); + void MCRF(PPUThread& CPU, ppu_opcode_t op); + void BCLR(PPUThread& CPU, ppu_opcode_t op); + void CRNOR(PPUThread& CPU, ppu_opcode_t op); + void CRANDC(PPUThread& CPU, ppu_opcode_t op); + void ISYNC(PPUThread& CPU, ppu_opcode_t op); + void CRXOR(PPUThread& CPU, ppu_opcode_t op); + void CRNAND(PPUThread& CPU, ppu_opcode_t op); + void CRAND(PPUThread& CPU, ppu_opcode_t op); + void CREQV(PPUThread& CPU, ppu_opcode_t op); + void CRORC(PPUThread& CPU, ppu_opcode_t op); + void CROR(PPUThread& CPU, ppu_opcode_t op); + void BCCTR(PPUThread& CPU, ppu_opcode_t op); + void RLWIMI(PPUThread& CPU, ppu_opcode_t op); + void RLWINM(PPUThread& CPU, ppu_opcode_t op); + void RLWNM(PPUThread& CPU, ppu_opcode_t op); + void ORI(PPUThread& CPU, ppu_opcode_t op); + void ORIS(PPUThread& CPU, ppu_opcode_t op); + void XORI(PPUThread& CPU, ppu_opcode_t op); + void XORIS(PPUThread& CPU, ppu_opcode_t op); + void ANDI_(PPUThread& CPU, ppu_opcode_t op); + void ANDIS_(PPUThread& CPU, ppu_opcode_t op); + void RLDICL(PPUThread& CPU, ppu_opcode_t op); + void RLDICR(PPUThread& CPU, ppu_opcode_t op); + void RLDIC(PPUThread& CPU, ppu_opcode_t op); + void RLDIMI(PPUThread& CPU, ppu_opcode_t op); + void RLDC_LR(PPUThread& CPU, ppu_opcode_t op); + void CMP(PPUThread& CPU, ppu_opcode_t op); + void TW(PPUThread& CPU, ppu_opcode_t op); + void LVSL(PPUThread& CPU, ppu_opcode_t op); + void LVEBX(PPUThread& CPU, ppu_opcode_t op); + void SUBFC(PPUThread& CPU, ppu_opcode_t op); + void MULHDU(PPUThread& CPU, ppu_opcode_t op); + void ADDC(PPUThread& CPU, ppu_opcode_t op); + void MULHWU(PPUThread& CPU, ppu_opcode_t op); + void MFOCRF(PPUThread& CPU, ppu_opcode_t op); + void LWARX(PPUThread& CPU, ppu_opcode_t op); + void LDX(PPUThread& CPU, ppu_opcode_t op); + void LWZX(PPUThread& CPU, ppu_opcode_t op); + void SLW(PPUThread& CPU, ppu_opcode_t op); + void CNTLZW(PPUThread& CPU, ppu_opcode_t op); + void SLD(PPUThread& CPU, ppu_opcode_t op); + void AND(PPUThread& CPU, ppu_opcode_t op); + void CMPL(PPUThread& CPU, ppu_opcode_t op); + void LVSR(PPUThread& CPU, ppu_opcode_t op); + void LVEHX(PPUThread& CPU, ppu_opcode_t op); + void SUBF(PPUThread& CPU, ppu_opcode_t op); + void LDUX(PPUThread& CPU, ppu_opcode_t op); + void DCBST(PPUThread& CPU, ppu_opcode_t op); + void LWZUX(PPUThread& CPU, ppu_opcode_t op); + void CNTLZD(PPUThread& CPU, ppu_opcode_t op); + void ANDC(PPUThread& CPU, ppu_opcode_t op); + void TD(PPUThread& CPU, ppu_opcode_t op); + void LVEWX(PPUThread& CPU, ppu_opcode_t op); + void MULHD(PPUThread& CPU, ppu_opcode_t op); + void MULHW(PPUThread& CPU, ppu_opcode_t op); + void LDARX(PPUThread& CPU, ppu_opcode_t op); + void DCBF(PPUThread& CPU, ppu_opcode_t op); + void LBZX(PPUThread& CPU, ppu_opcode_t op); + void LVX(PPUThread& CPU, ppu_opcode_t op); + void NEG(PPUThread& CPU, ppu_opcode_t op); + void LBZUX(PPUThread& CPU, ppu_opcode_t op); + void NOR(PPUThread& CPU, ppu_opcode_t op); + void STVEBX(PPUThread& CPU, ppu_opcode_t op); + void SUBFE(PPUThread& CPU, ppu_opcode_t op); + void ADDE(PPUThread& CPU, ppu_opcode_t op); + void MTOCRF(PPUThread& CPU, ppu_opcode_t op); + void STDX(PPUThread& CPU, ppu_opcode_t op); + void STWCX_(PPUThread& CPU, ppu_opcode_t op); + void STWX(PPUThread& CPU, ppu_opcode_t op); + void STVEHX(PPUThread& CPU, ppu_opcode_t op); + void STDUX(PPUThread& CPU, ppu_opcode_t op); + void STWUX(PPUThread& CPU, ppu_opcode_t op); + void STVEWX(PPUThread& CPU, ppu_opcode_t op); + void SUBFZE(PPUThread& CPU, ppu_opcode_t op); + void ADDZE(PPUThread& CPU, ppu_opcode_t op); + void STDCX_(PPUThread& CPU, ppu_opcode_t op); + void STBX(PPUThread& CPU, ppu_opcode_t op); + void STVX(PPUThread& CPU, ppu_opcode_t op); + void MULLD(PPUThread& CPU, ppu_opcode_t op); + void SUBFME(PPUThread& CPU, ppu_opcode_t op); + void ADDME(PPUThread& CPU, ppu_opcode_t op); + void MULLW(PPUThread& CPU, ppu_opcode_t op); + void DCBTST(PPUThread& CPU, ppu_opcode_t op); + void STBUX(PPUThread& CPU, ppu_opcode_t op); + void ADD(PPUThread& CPU, ppu_opcode_t op); + void DCBT(PPUThread& CPU, ppu_opcode_t op); + void LHZX(PPUThread& CPU, ppu_opcode_t op); + void EQV(PPUThread& CPU, ppu_opcode_t op); + void ECIWX(PPUThread& CPU, ppu_opcode_t op); + void LHZUX(PPUThread& CPU, ppu_opcode_t op); + void XOR(PPUThread& CPU, ppu_opcode_t op); + void MFSPR(PPUThread& CPU, ppu_opcode_t op); + void LWAX(PPUThread& CPU, ppu_opcode_t op); + void DST(PPUThread& CPU, ppu_opcode_t op); + void LHAX(PPUThread& CPU, ppu_opcode_t op); + void LVXL(PPUThread& CPU, ppu_opcode_t op); + void MFTB(PPUThread& CPU, ppu_opcode_t op); + void LWAUX(PPUThread& CPU, ppu_opcode_t op); + void DSTST(PPUThread& CPU, ppu_opcode_t op); + void LHAUX(PPUThread& CPU, ppu_opcode_t op); + void STHX(PPUThread& CPU, ppu_opcode_t op); + void ORC(PPUThread& CPU, ppu_opcode_t op); + void ECOWX(PPUThread& CPU, ppu_opcode_t op); + void STHUX(PPUThread& CPU, ppu_opcode_t op); + void OR(PPUThread& CPU, ppu_opcode_t op); + void DIVDU(PPUThread& CPU, ppu_opcode_t op); + void DIVWU(PPUThread& CPU, ppu_opcode_t op); + void MTSPR(PPUThread& CPU, ppu_opcode_t op); + void DCBI(PPUThread& CPU, ppu_opcode_t op); + void NAND(PPUThread& CPU, ppu_opcode_t op); + void STVXL(PPUThread& CPU, ppu_opcode_t op); + void DIVD(PPUThread& CPU, ppu_opcode_t op); + void DIVW(PPUThread& CPU, ppu_opcode_t op); + void LVLX(PPUThread& CPU, ppu_opcode_t op); + void LDBRX(PPUThread& CPU, ppu_opcode_t op); + void LSWX(PPUThread& CPU, ppu_opcode_t op); + void LWBRX(PPUThread& CPU, ppu_opcode_t op); + void LFSX(PPUThread& CPU, ppu_opcode_t op); + void SRW(PPUThread& CPU, ppu_opcode_t op); + void SRD(PPUThread& CPU, ppu_opcode_t op); + void LVRX(PPUThread& CPU, ppu_opcode_t op); + void LSWI(PPUThread& CPU, ppu_opcode_t op); + void LFSUX(PPUThread& CPU, ppu_opcode_t op); + void SYNC(PPUThread& CPU, ppu_opcode_t op); + void LFDX(PPUThread& CPU, ppu_opcode_t op); + void LFDUX(PPUThread& CPU, ppu_opcode_t op); + void STVLX(PPUThread& CPU, ppu_opcode_t op); + void STDBRX(PPUThread& CPU, ppu_opcode_t op); + void STSWX(PPUThread& CPU, ppu_opcode_t op); + void STWBRX(PPUThread& CPU, ppu_opcode_t op); + void STFSX(PPUThread& CPU, ppu_opcode_t op); + void STVRX(PPUThread& CPU, ppu_opcode_t op); + void STFSUX(PPUThread& CPU, ppu_opcode_t op); + void STSWI(PPUThread& CPU, ppu_opcode_t op); + void STFDX(PPUThread& CPU, ppu_opcode_t op); + void STFDUX(PPUThread& CPU, ppu_opcode_t op); + void LVLXL(PPUThread& CPU, ppu_opcode_t op); + void LHBRX(PPUThread& CPU, ppu_opcode_t op); + void SRAW(PPUThread& CPU, ppu_opcode_t op); + void SRAD(PPUThread& CPU, ppu_opcode_t op); + void LVRXL(PPUThread& CPU, ppu_opcode_t op); + void DSS(PPUThread& CPU, ppu_opcode_t op); + void SRAWI(PPUThread& CPU, ppu_opcode_t op); + void SRADI1(PPUThread& CPU, ppu_opcode_t op); + void SRADI2(PPUThread& CPU, ppu_opcode_t op); + void EIEIO(PPUThread& CPU, ppu_opcode_t op); + void STVLXL(PPUThread& CPU, ppu_opcode_t op); + void STHBRX(PPUThread& CPU, ppu_opcode_t op); + void EXTSH(PPUThread& CPU, ppu_opcode_t op); + void STVRXL(PPUThread& CPU, ppu_opcode_t op); + void EXTSB(PPUThread& CPU, ppu_opcode_t op); + void STFIWX(PPUThread& CPU, ppu_opcode_t op); + void EXTSW(PPUThread& CPU, ppu_opcode_t op); + void ICBI(PPUThread& CPU, ppu_opcode_t op); + void DCBZ(PPUThread& CPU, ppu_opcode_t op); + void LWZ(PPUThread& CPU, ppu_opcode_t op); + void LWZU(PPUThread& CPU, ppu_opcode_t op); + void LBZ(PPUThread& CPU, ppu_opcode_t op); + void LBZU(PPUThread& CPU, ppu_opcode_t op); + void STW(PPUThread& CPU, ppu_opcode_t op); + void STWU(PPUThread& CPU, ppu_opcode_t op); + void STB(PPUThread& CPU, ppu_opcode_t op); + void STBU(PPUThread& CPU, ppu_opcode_t op); + void LHZ(PPUThread& CPU, ppu_opcode_t op); + void LHZU(PPUThread& CPU, ppu_opcode_t op); + void LHA(PPUThread& CPU, ppu_opcode_t op); + void LHAU(PPUThread& CPU, ppu_opcode_t op); + void STH(PPUThread& CPU, ppu_opcode_t op); + void STHU(PPUThread& CPU, ppu_opcode_t op); + void LMW(PPUThread& CPU, ppu_opcode_t op); + void STMW(PPUThread& CPU, ppu_opcode_t op); + void LFS(PPUThread& CPU, ppu_opcode_t op); + void LFSU(PPUThread& CPU, ppu_opcode_t op); + void LFD(PPUThread& CPU, ppu_opcode_t op); + void LFDU(PPUThread& CPU, ppu_opcode_t op); + void STFS(PPUThread& CPU, ppu_opcode_t op); + void STFSU(PPUThread& CPU, ppu_opcode_t op); + void STFD(PPUThread& CPU, ppu_opcode_t op); + void STFDU(PPUThread& CPU, ppu_opcode_t op); + void LD(PPUThread& CPU, ppu_opcode_t op); + void LDU(PPUThread& CPU, ppu_opcode_t op); + void LWA(PPUThread& CPU, ppu_opcode_t op); + void FDIVS(PPUThread& CPU, ppu_opcode_t op); + void FSUBS(PPUThread& CPU, ppu_opcode_t op); + void FADDS(PPUThread& CPU, ppu_opcode_t op); + void FSQRTS(PPUThread& CPU, ppu_opcode_t op); + void FRES(PPUThread& CPU, ppu_opcode_t op); + void FMULS(PPUThread& CPU, ppu_opcode_t op); + void FMADDS(PPUThread& CPU, ppu_opcode_t op); + void FMSUBS(PPUThread& CPU, ppu_opcode_t op); + void FNMSUBS(PPUThread& CPU, ppu_opcode_t op); + void FNMADDS(PPUThread& CPU, ppu_opcode_t op); + void STD(PPUThread& CPU, ppu_opcode_t op); + void STDU(PPUThread& CPU, ppu_opcode_t op); + void MTFSB1(PPUThread& CPU, ppu_opcode_t op); + void MCRFS(PPUThread& CPU, ppu_opcode_t op); + void MTFSB0(PPUThread& CPU, ppu_opcode_t op); + void MTFSFI(PPUThread& CPU, ppu_opcode_t op); + void MFFS(PPUThread& CPU, ppu_opcode_t op); + void MTFSF(PPUThread& CPU, ppu_opcode_t op); + + void FCMPU(PPUThread& CPU, ppu_opcode_t op); + void FRSP(PPUThread& CPU, ppu_opcode_t op); + void FCTIW(PPUThread& CPU, ppu_opcode_t op); + void FCTIWZ(PPUThread& CPU, ppu_opcode_t op); + void FDIV(PPUThread& CPU, ppu_opcode_t op); + void FSUB(PPUThread& CPU, ppu_opcode_t op); + void FADD(PPUThread& CPU, ppu_opcode_t op); + void FSQRT(PPUThread& CPU, ppu_opcode_t op); + void FSEL(PPUThread& CPU, ppu_opcode_t op); + void FMUL(PPUThread& CPU, ppu_opcode_t op); + void FRSQRTE(PPUThread& CPU, ppu_opcode_t op); + void FMSUB(PPUThread& CPU, ppu_opcode_t op); + void FMADD(PPUThread& CPU, ppu_opcode_t op); + void FNMSUB(PPUThread& CPU, ppu_opcode_t op); + void FNMADD(PPUThread& CPU, ppu_opcode_t op); + void FCMPO(PPUThread& CPU, ppu_opcode_t op); + void FNEG(PPUThread& CPU, ppu_opcode_t op); + void FMR(PPUThread& CPU, ppu_opcode_t op); + void FNABS(PPUThread& CPU, ppu_opcode_t op); + void FABS(PPUThread& CPU, ppu_opcode_t op); + void FCTID(PPUThread& CPU, ppu_opcode_t op); + void FCTIDZ(PPUThread& CPU, ppu_opcode_t op); + void FCFID(PPUThread& CPU, ppu_opcode_t op); + + void UNK(PPUThread& CPU, ppu_opcode_t op); +} + +class PPUInterpreter2 : public PPUOpcodes +{ +public: + virtual ~PPUInterpreter2() {} + + ppu_inter_func_t func; + + virtual void NULL_OP() { func = ppu_interpreter::NULL_OP; } + virtual void NOP() { func = ppu_interpreter::NOP; } + + virtual void TDI(u32 to, u32 ra, s32 simm16) { func = ppu_interpreter::TDI; } + virtual void TWI(u32 to, u32 ra, s32 simm16) { func = ppu_interpreter::TWI; } + + virtual void MFVSCR(u32 vd) { func = ppu_interpreter::MFVSCR; } + virtual void MTVSCR(u32 vb) { func = ppu_interpreter::MTVSCR; } + virtual void VADDCUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDCUW; } + virtual void VADDFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDFP; } + virtual void VADDSBS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDSBS; } + virtual void VADDSHS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDSHS; } + virtual void VADDSWS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDSWS; } + virtual void VADDUBM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDUBM; } + virtual void VADDUBS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDUBS; } + virtual void VADDUHM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDUHM; } + virtual void VADDUHS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDUHS; } + virtual void VADDUWM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDUWM; } + virtual void VADDUWS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VADDUWS; } + virtual void VAND(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAND; } + virtual void VANDC(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VANDC; } + virtual void VAVGSB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAVGSB; } + virtual void VAVGSH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAVGSH; } + virtual void VAVGSW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAVGSW; } + virtual void VAVGUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAVGUB; } + virtual void VAVGUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAVGUH; } + virtual void VAVGUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VAVGUW; } + virtual void VCFSX(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VCFSX; } + virtual void VCFUX(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VCFUX; } + virtual void VCMPBFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPBFP; } + virtual void VCMPBFP_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPBFP_; } + virtual void VCMPEQFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQFP; } + virtual void VCMPEQFP_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQFP_; } + virtual void VCMPEQUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQUB; } + virtual void VCMPEQUB_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQUB_; } + virtual void VCMPEQUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQUH; } + virtual void VCMPEQUH_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQUH_; } + virtual void VCMPEQUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQUW; } + virtual void VCMPEQUW_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPEQUW_; } + virtual void VCMPGEFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGEFP; } + virtual void VCMPGEFP_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGEFP_; } + virtual void VCMPGTFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTFP; } + virtual void VCMPGTFP_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTFP_; } + virtual void VCMPGTSB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTSB; } + virtual void VCMPGTSB_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTSB_; } + virtual void VCMPGTSH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTSH; } + virtual void VCMPGTSH_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTSH_; } + virtual void VCMPGTSW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTSW; } + virtual void VCMPGTSW_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTSW_; } + virtual void VCMPGTUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTUB; } + virtual void VCMPGTUB_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTUB_; } + virtual void VCMPGTUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTUH; } + virtual void VCMPGTUH_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTUH_; } + virtual void VCMPGTUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTUW; } + virtual void VCMPGTUW_(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VCMPGTUW_; } + virtual void VCTSXS(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VCTSXS; } + virtual void VCTUXS(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VCTUXS; } + virtual void VEXPTEFP(u32 vd, u32 vb) { func = ppu_interpreter::VEXPTEFP; } + virtual void VLOGEFP(u32 vd, u32 vb) { func = ppu_interpreter::VLOGEFP; } + virtual void VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) { func = ppu_interpreter::VMADDFP; } + virtual void VMAXFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXFP; } + virtual void VMAXSB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXSB; } + virtual void VMAXSH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXSH; } + virtual void VMAXSW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXSW; } + virtual void VMAXUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXUB; } + virtual void VMAXUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXUH; } + virtual void VMAXUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMAXUW; } + virtual void VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMHADDSHS; } + virtual void VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMHRADDSHS; } + virtual void VMINFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINFP; } + virtual void VMINSB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINSB; } + virtual void VMINSH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINSH; } + virtual void VMINSW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINSW; } + virtual void VMINUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINUB; } + virtual void VMINUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINUH; } + virtual void VMINUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMINUW; } + virtual void VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMLADDUHM; } + virtual void VMRGHB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMRGHB; } + virtual void VMRGHH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMRGHH; } + virtual void VMRGHW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMRGHW; } + virtual void VMRGLB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMRGLB; } + virtual void VMRGLH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMRGLH; } + virtual void VMRGLW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMRGLW; } + virtual void VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMSUMMBM; } + virtual void VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMSUMSHM; } + virtual void VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMSUMSHS; } + virtual void VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMSUMUBM; } + virtual void VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMSUMUHM; } + virtual void VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VMSUMUHS; } + virtual void VMULESB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULESB; } + virtual void VMULESH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULESH; } + virtual void VMULEUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULEUB; } + virtual void VMULEUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULEUH; } + virtual void VMULOSB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULOSB; } + virtual void VMULOSH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULOSH; } + virtual void VMULOUB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULOUB; } + virtual void VMULOUH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VMULOUH; } + virtual void VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) { func = ppu_interpreter::VNMSUBFP; } + virtual void VNOR(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VNOR; } + virtual void VOR(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VOR; } + virtual void VPERM(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VPERM; } + virtual void VPKPX(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKPX; } + virtual void VPKSHSS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKSHSS; } + virtual void VPKSHUS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKSHUS; } + virtual void VPKSWSS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKSWSS; } + virtual void VPKSWUS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKSWUS; } + virtual void VPKUHUM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKUHUM; } + virtual void VPKUHUS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKUHUS; } + virtual void VPKUWUM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKUWUM; } + virtual void VPKUWUS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VPKUWUS; } + virtual void VREFP(u32 vd, u32 vb) { func = ppu_interpreter::VREFP; } + virtual void VRFIM(u32 vd, u32 vb) { func = ppu_interpreter::VRFIM; } + virtual void VRFIN(u32 vd, u32 vb) { func = ppu_interpreter::VRFIN; } + virtual void VRFIP(u32 vd, u32 vb) { func = ppu_interpreter::VRFIP; } + virtual void VRFIZ(u32 vd, u32 vb) { func = ppu_interpreter::VRFIZ; } + virtual void VRLB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VRLB; } + virtual void VRLH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VRLH; } + virtual void VRLW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VRLW; } + virtual void VRSQRTEFP(u32 vd, u32 vb) { func = ppu_interpreter::VRSQRTEFP; } + virtual void VSEL(u32 vd, u32 va, u32 vb, u32 vc) { func = ppu_interpreter::VSEL; } + virtual void VSL(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSL; } + virtual void VSLB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSLB; } + virtual void VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) { func = ppu_interpreter::VSLDOI; } + virtual void VSLH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSLH; } + virtual void VSLO(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSLO; } + virtual void VSLW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSLW; } + virtual void VSPLTB(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VSPLTB; } + virtual void VSPLTH(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VSPLTH; } + virtual void VSPLTISB(u32 vd, s32 simm5) { func = ppu_interpreter::VSPLTISB; } + virtual void VSPLTISH(u32 vd, s32 simm5) { func = ppu_interpreter::VSPLTISH; } + virtual void VSPLTISW(u32 vd, s32 simm5) { func = ppu_interpreter::VSPLTISW; } + virtual void VSPLTW(u32 vd, u32 uimm5, u32 vb) { func = ppu_interpreter::VSPLTW; } + virtual void VSR(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSR; } + virtual void VSRAB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRAB; } + virtual void VSRAH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRAH; } + virtual void VSRAW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRAW; } + virtual void VSRB(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRB; } + virtual void VSRH(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRH; } + virtual void VSRO(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRO; } + virtual void VSRW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSRW; } + virtual void VSUBCUW(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBCUW; } + virtual void VSUBFP(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBFP; } + virtual void VSUBSBS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBSBS; } + virtual void VSUBSHS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBSHS; } + virtual void VSUBSWS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBSWS; } + virtual void VSUBUBM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBUBM; } + virtual void VSUBUBS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBUBS; } + virtual void VSUBUHM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBUHM; } + virtual void VSUBUHS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBUHS; } + virtual void VSUBUWM(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBUWM; } + virtual void VSUBUWS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUBUWS; } + virtual void VSUMSWS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUMSWS; } + virtual void VSUM2SWS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUM2SWS; } + virtual void VSUM4SBS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUM4SBS; } + virtual void VSUM4SHS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUM4SHS; } + virtual void VSUM4UBS(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VSUM4UBS; } + virtual void VUPKHPX(u32 vd, u32 vb) { func = ppu_interpreter::VUPKHPX; } + virtual void VUPKHSB(u32 vd, u32 vb) { func = ppu_interpreter::VUPKHSB; } + virtual void VUPKHSH(u32 vd, u32 vb) { func = ppu_interpreter::VUPKHSH; } + virtual void VUPKLPX(u32 vd, u32 vb) { func = ppu_interpreter::VUPKLPX; } + virtual void VUPKLSB(u32 vd, u32 vb) { func = ppu_interpreter::VUPKLSB; } + virtual void VUPKLSH(u32 vd, u32 vb) { func = ppu_interpreter::VUPKLSH; } + virtual void VXOR(u32 vd, u32 va, u32 vb) { func = ppu_interpreter::VXOR; } + virtual void MULLI(u32 rd, u32 ra, s32 simm16) { func = ppu_interpreter::MULLI; } + virtual void SUBFIC(u32 rd, u32 ra, s32 simm16) { func = ppu_interpreter::SUBFIC; } + virtual void CMPLI(u32 bf, u32 l, u32 ra, u32 uimm16) { func = ppu_interpreter::CMPLI; } + virtual void CMPI(u32 bf, u32 l, u32 ra, s32 simm16) { func = ppu_interpreter::CMPI; } + virtual void ADDIC(u32 rd, u32 ra, s32 simm16) { func = ppu_interpreter::ADDIC; } + virtual void ADDIC_(u32 rd, u32 ra, s32 simm16) { func = ppu_interpreter::ADDIC_; } + virtual void ADDI(u32 rd, u32 ra, s32 simm16) { func = ppu_interpreter::ADDI; } + virtual void ADDIS(u32 rd, u32 ra, s32 simm16) { func = ppu_interpreter::ADDIS; } + virtual void BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) { func = ppu_interpreter::BC; } + virtual void HACK(u32 index) { func = ppu_interpreter::HACK; } + virtual void SC(u32 lev) { func = ppu_interpreter::SC; } + virtual void B(s32 ll, u32 aa, u32 lk) { func = ppu_interpreter::B; } + virtual void MCRF(u32 crfd, u32 crfs) { func = ppu_interpreter::MCRF; } + virtual void BCLR(u32 bo, u32 bi, u32 bh, u32 lk) { func = ppu_interpreter::BCLR; } + virtual void CRNOR(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CRNOR; } + virtual void CRANDC(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CRANDC; } + virtual void ISYNC() { func = ppu_interpreter::ISYNC; } + virtual void CRXOR(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CRXOR; } + virtual void CRNAND(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CRNAND; } + virtual void CRAND(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CRAND; } + virtual void CREQV(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CREQV; } + virtual void CRORC(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CRORC; } + virtual void CROR(u32 bt, u32 ba, u32 bb) { func = ppu_interpreter::CROR; } + virtual void BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) { func = ppu_interpreter::BCCTR; } + virtual void RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) { func = ppu_interpreter::RLWIMI; } + virtual void RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) { func = ppu_interpreter::RLWINM; } + virtual void RLWNM(u32 ra, u32 rs, u32 rb, u32 MB, u32 ME, bool rc) { func = ppu_interpreter::RLWNM; } + virtual void ORI(u32 rs, u32 ra, u32 uimm16) { func = ppu_interpreter::ORI; } + virtual void ORIS(u32 rs, u32 ra, u32 uimm16) { func = ppu_interpreter::ORIS; } + virtual void XORI(u32 ra, u32 rs, u32 uimm16) { func = ppu_interpreter::XORI; } + virtual void XORIS(u32 ra, u32 rs, u32 uimm16) { func = ppu_interpreter::XORIS; } + virtual void ANDI_(u32 ra, u32 rs, u32 uimm16) { func = ppu_interpreter::ANDI_; } + virtual void ANDIS_(u32 ra, u32 rs, u32 uimm16) { func = ppu_interpreter::ANDIS_; } + virtual void RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) { func = ppu_interpreter::RLDICL; } + virtual void RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) { func = ppu_interpreter::RLDICR; } + virtual void RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) { func = ppu_interpreter::RLDIC; } + virtual void RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) { func = ppu_interpreter::RLDIMI; } + virtual void RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) { func = ppu_interpreter::RLDC_LR; } + virtual void CMP(u32 crfd, u32 l, u32 ra, u32 rb) { func = ppu_interpreter::CMP; } + virtual void TW(u32 to, u32 ra, u32 rb) { func = ppu_interpreter::TW; } + virtual void LVSL(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVSL; } + virtual void LVEBX(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVEBX; } + virtual void SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::SUBFC; } + virtual void MULHDU(u32 rd, u32 ra, u32 rb, bool rc) { func = ppu_interpreter::MULHDU; } + virtual void ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::ADDC; } + virtual void MULHWU(u32 rd, u32 ra, u32 rb, bool rc) { func = ppu_interpreter::MULHWU; } + virtual void MFOCRF(u32 a, u32 rd, u32 crm) { func = ppu_interpreter::MFOCRF; } + virtual void LWARX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LWARX; } + virtual void LDX(u32 ra, u32 rs, u32 rb) { func = ppu_interpreter::LDX; } + virtual void LWZX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LWZX; } + virtual void SLW(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::SLW; } + virtual void CNTLZW(u32 ra, u32 rs, bool rc) { func = ppu_interpreter::CNTLZW; } + virtual void SLD(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::SLD; } + virtual void AND(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::AND; } + virtual void CMPL(u32 bf, u32 l, u32 ra, u32 rb) { func = ppu_interpreter::CMPL; } + virtual void LVSR(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVSR; } + virtual void LVEHX(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVEHX; } + virtual void SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::SUBF; } + virtual void LDUX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LDUX; } + virtual void DCBST(u32 ra, u32 rb) { func = ppu_interpreter::DCBST; } + virtual void LWZUX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LWZUX; } + virtual void CNTLZD(u32 ra, u32 rs, bool rc) { func = ppu_interpreter::CNTLZD; } + virtual void ANDC(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::ANDC; } + virtual void TD(u32 to, u32 ra, u32 rb) { func = ppu_interpreter::TD; } + virtual void LVEWX(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVEWX; } + virtual void MULHD(u32 rd, u32 ra, u32 rb, bool rc) { func = ppu_interpreter::MULHD; } + virtual void MULHW(u32 rd, u32 ra, u32 rb, bool rc) { func = ppu_interpreter::MULHW; } + virtual void LDARX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LDARX; } + virtual void DCBF(u32 ra, u32 rb) { func = ppu_interpreter::DCBF; } + virtual void LBZX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LBZX; } + virtual void LVX(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVX; } + virtual void NEG(u32 rd, u32 ra, u32 oe, bool rc) { func = ppu_interpreter::NEG; } + virtual void LBZUX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LBZUX; } + virtual void NOR(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::NOR; } + virtual void STVEBX(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVEBX; } + virtual void SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::SUBFE; } + virtual void ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::ADDE; } + virtual void MTOCRF(u32 l, u32 crm, u32 rs) { func = ppu_interpreter::MTOCRF; } + virtual void STDX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STDX; } + virtual void STWCX_(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STWCX_; } + virtual void STWX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STWX; } + virtual void STVEHX(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVEHX; } + virtual void STDUX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STDUX; } + virtual void STWUX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STWUX; } + virtual void STVEWX(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVEWX; } + virtual void SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) { func = ppu_interpreter::SUBFZE; } + virtual void ADDZE(u32 rd, u32 ra, u32 oe, bool rc) { func = ppu_interpreter::ADDZE; } + virtual void STDCX_(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STDCX_; } + virtual void STBX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STBX; } + virtual void STVX(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVX; } + virtual void MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::MULLD; } + virtual void SUBFME(u32 rd, u32 ra, u32 oe, bool rc) { func = ppu_interpreter::SUBFME; } + virtual void ADDME(u32 rd, u32 ra, u32 oe, bool rc) { func = ppu_interpreter::ADDME; } + virtual void MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::MULLW; } + virtual void DCBTST(u32 ra, u32 rb, u32 th) { func = ppu_interpreter::DCBTST; } + virtual void STBUX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STBUX; } + virtual void ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::ADD; } + virtual void DCBT(u32 ra, u32 rb, u32 th) { func = ppu_interpreter::DCBT; } + virtual void LHZX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LHZX; } + virtual void EQV(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::EQV; } + virtual void ECIWX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::ECIWX; } + virtual void LHZUX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LHZUX; } + virtual void XOR(u32 rs, u32 ra, u32 rb, bool rc) { func = ppu_interpreter::XOR; } + virtual void MFSPR(u32 rd, u32 spr) { func = ppu_interpreter::MFSPR; } + virtual void LWAX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LWAX; } + virtual void DST(u32 ra, u32 rb, u32 strm, u32 t) { func = ppu_interpreter::DST; } + virtual void LHAX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LHAX; } + virtual void LVXL(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVXL; } + virtual void MFTB(u32 rd, u32 spr) { func = ppu_interpreter::MFTB; } + virtual void LWAUX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LWAUX; } + virtual void DSTST(u32 ra, u32 rb, u32 strm, u32 t) { func = ppu_interpreter::DSTST; } + virtual void LHAUX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LHAUX; } + virtual void STHX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STHX; } + virtual void ORC(u32 rs, u32 ra, u32 rb, bool rc) { func = ppu_interpreter::ORC; } + virtual void ECOWX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::ECOWX; } + virtual void STHUX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STHUX; } + virtual void OR(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::OR; } + virtual void DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::DIVDU; } + virtual void DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::DIVWU; } + virtual void MTSPR(u32 spr, u32 rs) { func = ppu_interpreter::MTSPR; } + virtual void DCBI(u32 ra, u32 rb) { func = ppu_interpreter::DCBI; } + virtual void NAND(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::NAND; } + virtual void STVXL(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVXL; } + virtual void DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::DIVD; } + virtual void DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) { func = ppu_interpreter::DIVW; } + virtual void LVLX(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVLX; } + virtual void LDBRX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LDBRX; } + virtual void LSWX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LSWX; } + virtual void LWBRX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LWBRX; } + virtual void LFSX(u32 frd, u32 ra, u32 rb) { func = ppu_interpreter::LFSX; } + virtual void SRW(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::SRW; } + virtual void SRD(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::SRD; } + virtual void LVRX(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVRX; } + virtual void LSWI(u32 rd, u32 ra, u32 nb) { func = ppu_interpreter::LSWI; } + virtual void LFSUX(u32 frd, u32 ra, u32 rb) { func = ppu_interpreter::LFSUX; } + virtual void SYNC(u32 l) { func = ppu_interpreter::SYNC; } + virtual void LFDX(u32 frd, u32 ra, u32 rb) { func = ppu_interpreter::LFDX; } + virtual void LFDUX(u32 frd, u32 ra, u32 rb) { func = ppu_interpreter::LFDUX; } + virtual void STVLX(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVLX; } + virtual void STDBRX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STDBRX; } + virtual void STSWX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STSWX; } + virtual void STWBRX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STWBRX; } + virtual void STFSX(u32 frs, u32 ra, u32 rb) { func = ppu_interpreter::STFSX; } + virtual void STVRX(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVRX; } + virtual void STFSUX(u32 frs, u32 ra, u32 rb) { func = ppu_interpreter::STFSUX; } + virtual void STSWI(u32 rd, u32 ra, u32 nb) { func = ppu_interpreter::STSWI; } + virtual void STFDX(u32 frs, u32 ra, u32 rb) { func = ppu_interpreter::STFDX; } + virtual void STFDUX(u32 frs, u32 ra, u32 rb) { func = ppu_interpreter::STFDUX; } + virtual void LVLXL(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVLXL; } + virtual void LHBRX(u32 rd, u32 ra, u32 rb) { func = ppu_interpreter::LHBRX; } + virtual void SRAW(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::SRAW; } + virtual void SRAD(u32 ra, u32 rs, u32 rb, bool rc) { func = ppu_interpreter::SRAD; } + virtual void LVRXL(u32 vd, u32 ra, u32 rb) { func = ppu_interpreter::LVRXL; } + virtual void DSS(u32 strm, u32 a) { func = ppu_interpreter::DSS; } + virtual void SRAWI(u32 ra, u32 rs, u32 sh, bool rc) { func = ppu_interpreter::SRAWI; } + virtual void SRADI1(u32 ra, u32 rs, u32 sh, bool rc) { func = ppu_interpreter::SRADI1; } + virtual void SRADI2(u32 ra, u32 rs, u32 sh, bool rc) { func = ppu_interpreter::SRADI2; } + virtual void EIEIO() { func = ppu_interpreter::EIEIO; } + virtual void STVLXL(u32 vs, u32 ra, u32 rb) { func = ppu_interpreter::STVLXL; } + virtual void STHBRX(u32 rs, u32 ra, u32 rb) { func = ppu_interpreter::STHBRX; } + virtual void EXTSH(u32 ra, u32 rs, bool rc) { func = ppu_interpreter::EXTSH; } + virtual void STVRXL(u32 sd, u32 ra, u32 rb) { func = ppu_interpreter::STVRXL; } + virtual void EXTSB(u32 ra, u32 rs, bool rc) { func = ppu_interpreter::EXTSB; } + virtual void STFIWX(u32 frs, u32 ra, u32 rb) { func = ppu_interpreter::STFIWX; } + virtual void EXTSW(u32 ra, u32 rs, bool rc) { func = ppu_interpreter::EXTSW; } + virtual void ICBI(u32 ra, u32 rb) { func = ppu_interpreter::ICBI; } + virtual void DCBZ(u32 ra, u32 rb) { func = ppu_interpreter::DCBZ; } + virtual void LWZ(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LWZ; } + virtual void LWZU(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LWZU; } + virtual void LBZ(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LBZ; } + virtual void LBZU(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LBZU; } + virtual void STW(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STW; } + virtual void STWU(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STWU; } + virtual void STB(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STB; } + virtual void STBU(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STBU; } + virtual void LHZ(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LHZ; } + virtual void LHZU(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LHZU; } + virtual void LHA(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::LHA; } + virtual void LHAU(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::LHAU; } + virtual void STH(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STH; } + virtual void STHU(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STHU; } + virtual void LMW(u32 rd, u32 ra, s32 d) { func = ppu_interpreter::LMW; } + virtual void STMW(u32 rs, u32 ra, s32 d) { func = ppu_interpreter::STMW; } + virtual void LFS(u32 frd, u32 ra, s32 d) { func = ppu_interpreter::LFS; } + virtual void LFSU(u32 frd, u32 ra, s32 d) { func = ppu_interpreter::LFSU; } + virtual void LFD(u32 frd, u32 ra, s32 d) { func = ppu_interpreter::LFD; } + virtual void LFDU(u32 frd, u32 ra, s32 d) { func = ppu_interpreter::LFDU; } + virtual void STFS(u32 frs, u32 ra, s32 d) { func = ppu_interpreter::STFS; } + virtual void STFSU(u32 frs, u32 ra, s32 d) { func = ppu_interpreter::STFSU; } + virtual void STFD(u32 frs, u32 ra, s32 d) { func = ppu_interpreter::STFD; } + virtual void STFDU(u32 frs, u32 ra, s32 d) { func = ppu_interpreter::STFDU; } + virtual void LD(u32 rd, u32 ra, s32 ds) { func = ppu_interpreter::LD; } + virtual void LDU(u32 rd, u32 ra, s32 ds) { func = ppu_interpreter::LDU; } + virtual void LWA(u32 rd, u32 ra, s32 ds) { func = ppu_interpreter::LWA; } + virtual void FDIVS(u32 frd, u32 fra, u32 frb, bool rc) { func = ppu_interpreter::FDIVS; } + virtual void FSUBS(u32 frd, u32 fra, u32 frb, bool rc) { func = ppu_interpreter::FSUBS; } + virtual void FADDS(u32 frd, u32 fra, u32 frb, bool rc) { func = ppu_interpreter::FADDS; } + virtual void FSQRTS(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FSQRTS; } + virtual void FRES(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FRES; } + virtual void FMULS(u32 frd, u32 fra, u32 frc, bool rc) { func = ppu_interpreter::FMULS; } + virtual void FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FMADDS; } + virtual void FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FMSUBS; } + virtual void FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FNMSUBS; } + virtual void FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FNMADDS; } + virtual void STD(u32 rs, u32 ra, s32 ds) { func = ppu_interpreter::STD; } + virtual void STDU(u32 rs, u32 ra, s32 ds) { func = ppu_interpreter::STDU; } + virtual void MTFSB1(u32 bt, bool rc) { func = ppu_interpreter::MTFSB1; } + virtual void MCRFS(u32 bf, u32 bfa) { func = ppu_interpreter::MCRFS; } + virtual void MTFSB0(u32 bt, bool rc) { func = ppu_interpreter::MTFSB0; } + virtual void MTFSFI(u32 crfd, u32 i, bool rc) { func = ppu_interpreter::MTFSFI; } + virtual void MFFS(u32 frd, bool rc) { func = ppu_interpreter::MFFS; } + virtual void MTFSF(u32 flm, u32 frb, bool rc) { func = ppu_interpreter::MTFSF; } + + virtual void FCMPU(u32 bf, u32 fra, u32 frb) { func = ppu_interpreter::FCMPU; } + virtual void FRSP(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FRSP; } + virtual void FCTIW(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FCTIW; } + virtual void FCTIWZ(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FCTIWZ; } + virtual void FDIV(u32 frd, u32 fra, u32 frb, bool rc) { func = ppu_interpreter::FDIV; } + virtual void FSUB(u32 frd, u32 fra, u32 frb, bool rc) { func = ppu_interpreter::FSUB; } + virtual void FADD(u32 frd, u32 fra, u32 frb, bool rc) { func = ppu_interpreter::FADD; } + virtual void FSQRT(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FSQRT; } + virtual void FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FSEL; } + virtual void FMUL(u32 frd, u32 fra, u32 frc, bool rc) { func = ppu_interpreter::FMUL; } + virtual void FRSQRTE(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FRSQRTE; } + virtual void FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FMSUB; } + virtual void FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FMADD; } + virtual void FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FNMSUB; } + virtual void FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) { func = ppu_interpreter::FNMADD; } + virtual void FCMPO(u32 crfd, u32 fra, u32 frb) { func = ppu_interpreter::FCMPO; } + virtual void FNEG(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FNEG; } + virtual void FMR(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FMR; } + virtual void FNABS(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FNABS; } + virtual void FABS(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FABS; } + virtual void FCTID(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FCTID; } + virtual void FCTIDZ(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FCTIDZ; } + virtual void FCFID(u32 frd, u32 frb, bool rc) { func = ppu_interpreter::FCFID; } + + virtual void UNK(const u32 code, const u32 opcode, const u32 gcode) { func = ppu_interpreter::UNK; } +}; \ No newline at end of file diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp index 5572e65abf..23f0102285 100644 --- a/rpcs3/Emu/Cell/PPUThread.cpp +++ b/rpcs3/Emu/Cell/PPUThread.cpp @@ -8,15 +8,494 @@ #include "Emu/SysCalls/Modules.h" #include "Emu/Cell/PPUDecoder.h" #include "Emu/Cell/PPUInterpreter.h" +#include "Emu/Cell/PPUInterpreter2.h" #include "Emu/Cell/PPULLVMRecompiler.h" //#include "Emu/Cell/PPURecompiler.h" #include "Emu/CPU/CPUThreadManager.h" +#ifdef _WIN32 +#include +#else +#include +#include +#endif + u64 rotate_mask[64][64]; +const ppu_inter_func_t g_ppu_inter_func_list[] = +{ + nullptr, + + ppu_interpreter::NULL_OP, + ppu_interpreter::NOP, + + ppu_interpreter::TDI, + ppu_interpreter::TWI, + + ppu_interpreter::MFVSCR, + ppu_interpreter::MTVSCR, + ppu_interpreter::VADDCUW, + ppu_interpreter::VADDFP, + ppu_interpreter::VADDSBS, + ppu_interpreter::VADDSHS, + ppu_interpreter::VADDSWS, + ppu_interpreter::VADDUBM, + ppu_interpreter::VADDUBS, + ppu_interpreter::VADDUHM, + ppu_interpreter::VADDUHS, + ppu_interpreter::VADDUWM, + ppu_interpreter::VADDUWS, + ppu_interpreter::VAND, + ppu_interpreter::VANDC, + ppu_interpreter::VAVGSB, + ppu_interpreter::VAVGSH, + ppu_interpreter::VAVGSW, + ppu_interpreter::VAVGUB, + ppu_interpreter::VAVGUH, + ppu_interpreter::VAVGUW, + ppu_interpreter::VCFSX, + ppu_interpreter::VCFUX, + ppu_interpreter::VCMPBFP, + ppu_interpreter::VCMPBFP_, + ppu_interpreter::VCMPEQFP, + ppu_interpreter::VCMPEQFP_, + ppu_interpreter::VCMPEQUB, + ppu_interpreter::VCMPEQUB_, + ppu_interpreter::VCMPEQUH, + ppu_interpreter::VCMPEQUH_, + ppu_interpreter::VCMPEQUW, + ppu_interpreter::VCMPEQUW_, + ppu_interpreter::VCMPGEFP, + ppu_interpreter::VCMPGEFP_, + ppu_interpreter::VCMPGTFP, + ppu_interpreter::VCMPGTFP_, + ppu_interpreter::VCMPGTSB, + ppu_interpreter::VCMPGTSB_, + ppu_interpreter::VCMPGTSH, + ppu_interpreter::VCMPGTSH_, + ppu_interpreter::VCMPGTSW, + ppu_interpreter::VCMPGTSW_, + ppu_interpreter::VCMPGTUB, + ppu_interpreter::VCMPGTUB_, + ppu_interpreter::VCMPGTUH, + ppu_interpreter::VCMPGTUH_, + ppu_interpreter::VCMPGTUW, + ppu_interpreter::VCMPGTUW_, + ppu_interpreter::VCTSXS, + ppu_interpreter::VCTUXS, + ppu_interpreter::VEXPTEFP, + ppu_interpreter::VLOGEFP, + ppu_interpreter::VMADDFP, + ppu_interpreter::VMAXFP, + ppu_interpreter::VMAXSB, + ppu_interpreter::VMAXSH, + ppu_interpreter::VMAXSW, + ppu_interpreter::VMAXUB, + ppu_interpreter::VMAXUH, + ppu_interpreter::VMAXUW, + ppu_interpreter::VMHADDSHS, + ppu_interpreter::VMHRADDSHS, + ppu_interpreter::VMINFP, + ppu_interpreter::VMINSB, + ppu_interpreter::VMINSH, + ppu_interpreter::VMINSW, + ppu_interpreter::VMINUB, + ppu_interpreter::VMINUH, + ppu_interpreter::VMINUW, + ppu_interpreter::VMLADDUHM, + ppu_interpreter::VMRGHB, + ppu_interpreter::VMRGHH, + ppu_interpreter::VMRGHW, + ppu_interpreter::VMRGLB, + ppu_interpreter::VMRGLH, + ppu_interpreter::VMRGLW, + ppu_interpreter::VMSUMMBM, + ppu_interpreter::VMSUMSHM, + ppu_interpreter::VMSUMSHS, + ppu_interpreter::VMSUMUBM, + ppu_interpreter::VMSUMUHM, + ppu_interpreter::VMSUMUHS, + ppu_interpreter::VMULESB, + ppu_interpreter::VMULESH, + ppu_interpreter::VMULEUB, + ppu_interpreter::VMULEUH, + ppu_interpreter::VMULOSB, + ppu_interpreter::VMULOSH, + ppu_interpreter::VMULOUB, + ppu_interpreter::VMULOUH, + ppu_interpreter::VNMSUBFP, + ppu_interpreter::VNOR, + ppu_interpreter::VOR, + ppu_interpreter::VPERM, + ppu_interpreter::VPKPX, + ppu_interpreter::VPKSHSS, + ppu_interpreter::VPKSHUS, + ppu_interpreter::VPKSWSS, + ppu_interpreter::VPKSWUS, + ppu_interpreter::VPKUHUM, + ppu_interpreter::VPKUHUS, + ppu_interpreter::VPKUWUM, + ppu_interpreter::VPKUWUS, + ppu_interpreter::VREFP, + ppu_interpreter::VRFIM, + ppu_interpreter::VRFIN, + ppu_interpreter::VRFIP, + ppu_interpreter::VRFIZ, + ppu_interpreter::VRLB, + ppu_interpreter::VRLH, + ppu_interpreter::VRLW, + ppu_interpreter::VRSQRTEFP, + ppu_interpreter::VSEL, + ppu_interpreter::VSL, + ppu_interpreter::VSLB, + ppu_interpreter::VSLDOI, + ppu_interpreter::VSLH, + ppu_interpreter::VSLO, + ppu_interpreter::VSLW, + ppu_interpreter::VSPLTB, + ppu_interpreter::VSPLTH, + ppu_interpreter::VSPLTISB, + ppu_interpreter::VSPLTISH, + ppu_interpreter::VSPLTISW, + ppu_interpreter::VSPLTW, + ppu_interpreter::VSR, + ppu_interpreter::VSRAB, + ppu_interpreter::VSRAH, + ppu_interpreter::VSRAW, + ppu_interpreter::VSRB, + ppu_interpreter::VSRH, + ppu_interpreter::VSRO, + ppu_interpreter::VSRW, + ppu_interpreter::VSUBCUW, + ppu_interpreter::VSUBFP, + ppu_interpreter::VSUBSBS, + ppu_interpreter::VSUBSHS, + ppu_interpreter::VSUBSWS, + ppu_interpreter::VSUBUBM, + ppu_interpreter::VSUBUBS, + ppu_interpreter::VSUBUHM, + ppu_interpreter::VSUBUHS, + ppu_interpreter::VSUBUWM, + ppu_interpreter::VSUBUWS, + ppu_interpreter::VSUMSWS, + ppu_interpreter::VSUM2SWS, + ppu_interpreter::VSUM4SBS, + ppu_interpreter::VSUM4SHS, + ppu_interpreter::VSUM4UBS, + ppu_interpreter::VUPKHPX, + ppu_interpreter::VUPKHSB, + ppu_interpreter::VUPKHSH, + ppu_interpreter::VUPKLPX, + ppu_interpreter::VUPKLSB, + ppu_interpreter::VUPKLSH, + ppu_interpreter::VXOR, + ppu_interpreter::MULLI, + ppu_interpreter::SUBFIC, + ppu_interpreter::CMPLI, + ppu_interpreter::CMPI, + ppu_interpreter::ADDIC, + ppu_interpreter::ADDIC_, + ppu_interpreter::ADDI, + ppu_interpreter::ADDIS, + ppu_interpreter::BC, + ppu_interpreter::HACK, + ppu_interpreter::SC, + ppu_interpreter::B, + ppu_interpreter::MCRF, + ppu_interpreter::BCLR, + ppu_interpreter::CRNOR, + ppu_interpreter::CRANDC, + ppu_interpreter::ISYNC, + ppu_interpreter::CRXOR, + ppu_interpreter::CRNAND, + ppu_interpreter::CRAND, + ppu_interpreter::CREQV, + ppu_interpreter::CRORC, + ppu_interpreter::CROR, + ppu_interpreter::BCCTR, + ppu_interpreter::RLWIMI, + ppu_interpreter::RLWINM, + ppu_interpreter::RLWNM, + ppu_interpreter::ORI, + ppu_interpreter::ORIS, + ppu_interpreter::XORI, + ppu_interpreter::XORIS, + ppu_interpreter::ANDI_, + ppu_interpreter::ANDIS_, + ppu_interpreter::RLDICL, + ppu_interpreter::RLDICR, + ppu_interpreter::RLDIC, + ppu_interpreter::RLDIMI, + ppu_interpreter::RLDC_LR, + ppu_interpreter::CMP, + ppu_interpreter::TW, + ppu_interpreter::LVSL, + ppu_interpreter::LVEBX, + ppu_interpreter::SUBFC, + ppu_interpreter::MULHDU, + ppu_interpreter::ADDC, + ppu_interpreter::MULHWU, + ppu_interpreter::MFOCRF, + ppu_interpreter::LWARX, + ppu_interpreter::LDX, + ppu_interpreter::LWZX, + ppu_interpreter::SLW, + ppu_interpreter::CNTLZW, + ppu_interpreter::SLD, + ppu_interpreter::AND, + ppu_interpreter::CMPL, + ppu_interpreter::LVSR, + ppu_interpreter::LVEHX, + ppu_interpreter::SUBF, + ppu_interpreter::LDUX, + ppu_interpreter::DCBST, + ppu_interpreter::LWZUX, + ppu_interpreter::CNTLZD, + ppu_interpreter::ANDC, + ppu_interpreter::TD, + ppu_interpreter::LVEWX, + ppu_interpreter::MULHD, + ppu_interpreter::MULHW, + ppu_interpreter::LDARX, + ppu_interpreter::DCBF, + ppu_interpreter::LBZX, + ppu_interpreter::LVX, + ppu_interpreter::NEG, + ppu_interpreter::LBZUX, + ppu_interpreter::NOR, + ppu_interpreter::STVEBX, + ppu_interpreter::SUBFE, + ppu_interpreter::ADDE, + ppu_interpreter::MTOCRF, + ppu_interpreter::STDX, + ppu_interpreter::STWCX_, + ppu_interpreter::STWX, + ppu_interpreter::STVEHX, + ppu_interpreter::STDUX, + ppu_interpreter::STWUX, + ppu_interpreter::STVEWX, + ppu_interpreter::SUBFZE, + ppu_interpreter::ADDZE, + ppu_interpreter::STDCX_, + ppu_interpreter::STBX, + ppu_interpreter::STVX, + ppu_interpreter::MULLD, + ppu_interpreter::SUBFME, + ppu_interpreter::ADDME, + ppu_interpreter::MULLW, + ppu_interpreter::DCBTST, + ppu_interpreter::STBUX, + ppu_interpreter::ADD, + ppu_interpreter::DCBT, + ppu_interpreter::LHZX, + ppu_interpreter::EQV, + ppu_interpreter::ECIWX, + ppu_interpreter::LHZUX, + ppu_interpreter::XOR, + ppu_interpreter::MFSPR, + ppu_interpreter::LWAX, + ppu_interpreter::DST, + ppu_interpreter::LHAX, + ppu_interpreter::LVXL, + ppu_interpreter::MFTB, + ppu_interpreter::LWAUX, + ppu_interpreter::DSTST, + ppu_interpreter::LHAUX, + ppu_interpreter::STHX, + ppu_interpreter::ORC, + ppu_interpreter::ECOWX, + ppu_interpreter::STHUX, + ppu_interpreter::OR, + ppu_interpreter::DIVDU, + ppu_interpreter::DIVWU, + ppu_interpreter::MTSPR, + ppu_interpreter::DCBI, + ppu_interpreter::NAND, + ppu_interpreter::STVXL, + ppu_interpreter::DIVD, + ppu_interpreter::DIVW, + ppu_interpreter::LVLX, + ppu_interpreter::LDBRX, + ppu_interpreter::LSWX, + ppu_interpreter::LWBRX, + ppu_interpreter::LFSX, + ppu_interpreter::SRW, + ppu_interpreter::SRD, + ppu_interpreter::LVRX, + ppu_interpreter::LSWI, + ppu_interpreter::LFSUX, + ppu_interpreter::SYNC, + ppu_interpreter::LFDX, + ppu_interpreter::LFDUX, + ppu_interpreter::STVLX, + ppu_interpreter::STDBRX, + ppu_interpreter::STSWX, + ppu_interpreter::STWBRX, + ppu_interpreter::STFSX, + ppu_interpreter::STVRX, + ppu_interpreter::STFSUX, + ppu_interpreter::STSWI, + ppu_interpreter::STFDX, + ppu_interpreter::STFDUX, + ppu_interpreter::LVLXL, + ppu_interpreter::LHBRX, + ppu_interpreter::SRAW, + ppu_interpreter::SRAD, + ppu_interpreter::LVRXL, + ppu_interpreter::DSS, + ppu_interpreter::SRAWI, + ppu_interpreter::SRADI1, + ppu_interpreter::SRADI2, + ppu_interpreter::EIEIO, + ppu_interpreter::STVLXL, + ppu_interpreter::STHBRX, + ppu_interpreter::EXTSH, + ppu_interpreter::STVRXL, + ppu_interpreter::EXTSB, + ppu_interpreter::STFIWX, + ppu_interpreter::EXTSW, + ppu_interpreter::ICBI, + ppu_interpreter::DCBZ, + ppu_interpreter::LWZ, + ppu_interpreter::LWZU, + ppu_interpreter::LBZ, + ppu_interpreter::LBZU, + ppu_interpreter::STW, + ppu_interpreter::STWU, + ppu_interpreter::STB, + ppu_interpreter::STBU, + ppu_interpreter::LHZ, + ppu_interpreter::LHZU, + ppu_interpreter::LHA, + ppu_interpreter::LHAU, + ppu_interpreter::STH, + ppu_interpreter::STHU, + ppu_interpreter::LMW, + ppu_interpreter::STMW, + ppu_interpreter::LFS, + ppu_interpreter::LFSU, + ppu_interpreter::LFD, + ppu_interpreter::LFDU, + ppu_interpreter::STFS, + ppu_interpreter::STFSU, + ppu_interpreter::STFD, + ppu_interpreter::STFDU, + ppu_interpreter::LD, + ppu_interpreter::LDU, + ppu_interpreter::LWA, + ppu_interpreter::FDIVS, + ppu_interpreter::FSUBS, + ppu_interpreter::FADDS, + ppu_interpreter::FSQRTS, + ppu_interpreter::FRES, + ppu_interpreter::FMULS, + ppu_interpreter::FMADDS, + ppu_interpreter::FMSUBS, + ppu_interpreter::FNMSUBS, + ppu_interpreter::FNMADDS, + ppu_interpreter::STD, + ppu_interpreter::STDU, + ppu_interpreter::MTFSB1, + ppu_interpreter::MCRFS, + ppu_interpreter::MTFSB0, + ppu_interpreter::MTFSFI, + ppu_interpreter::MFFS, + ppu_interpreter::MTFSF, + + ppu_interpreter::FCMPU, + ppu_interpreter::FRSP, + ppu_interpreter::FCTIW, + ppu_interpreter::FCTIWZ, + ppu_interpreter::FDIV, + ppu_interpreter::FSUB, + ppu_interpreter::FADD, + ppu_interpreter::FSQRT, + ppu_interpreter::FSEL, + ppu_interpreter::FMUL, + ppu_interpreter::FRSQRTE, + ppu_interpreter::FMSUB, + ppu_interpreter::FMADD, + ppu_interpreter::FNMSUB, + ppu_interpreter::FNMADD, + ppu_interpreter::FCMPO, + ppu_interpreter::FNEG, + ppu_interpreter::FMR, + ppu_interpreter::FNABS, + ppu_interpreter::FABS, + ppu_interpreter::FCTID, + ppu_interpreter::FCTIDZ, + ppu_interpreter::FCFID, + + ppu_interpreter::UNK, +}; + extern u32 ppu_get_tls(u32 thread); extern void ppu_free_tls(u32 thread); +void* g_ppu_exec_map = nullptr; + +void finalize_ppu_exec_map() +{ + if (g_ppu_exec_map) + { +#ifdef _WIN32 + VirtualFree(g_ppu_exec_map, 0, MEM_RELEASE); +#else + munmap(g_ppu_exec_map, 0x100000000); +#endif + g_ppu_exec_map = nullptr; + } +} + +void initialize_ppu_exec_map() +{ + finalize_ppu_exec_map(); + +#ifdef _WIN32 + g_ppu_exec_map = VirtualAlloc(NULL, 0x100000000, MEM_RESERVE, PAGE_NOACCESS); +#else + g_ppu_exec_map = mmap(nullptr, 0x100000000, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0); +#endif +} + +void fill_ppu_exec_map(u32 addr, u32 size) +{ +#ifdef _WIN32 + VirtualAlloc((u8*)g_ppu_exec_map + addr, size, MEM_COMMIT, PAGE_READWRITE); +#else + mprotect((u8*)g_ppu_exec_map + addr, size, PROT_READ | PROT_WRITE); +#endif + + PPUInterpreter2* inter; + PPUDecoder dec(inter = new PPUInterpreter2); + + for (u32 pos = addr; pos < addr + size; pos += 4) + { + inter->func = nullptr; + + // decode PPU opcode + dec.Decode(vm::read32(pos)); + + u32 index = 0; + + // find function index + for (const auto& func : g_ppu_inter_func_list) + { + if (inter->func == func) + { + index = &func - g_ppu_inter_func_list; + break; + } + } + + // zero function is nullptr, it shouldn't happen + assert(index); + + // write index in memory + *(u32*)((u8*)g_ppu_exec_map + pos) = index; + } +} + PPUThread& GetCurrentPPUThread() { CPUThread* thread = GetCurrentCPUThread(); @@ -29,6 +508,7 @@ PPUThread& GetCurrentPPUThread() PPUThread::PPUThread() : CPUThread(CPU_THREAD_PPU) { Reset(); + InitRotateMask(); } PPUThread::~PPUThread() @@ -192,14 +672,16 @@ void PPUThread::FastCall2(u32 addr, u32 rtoc) auto old_rtoc = GPR[2]; auto old_LR = LR; auto old_thread = GetCurrentNamedThread(); + auto old_task = custom_task; m_status = Running; PC = addr; GPR[2] = rtoc; LR = Emu.GetCPUThreadStop(); SetCurrentNamedThread(this); + custom_task = nullptr; - CPUThread::Task(); + Task(); m_status = old_status; PC = old_PC; @@ -207,26 +689,56 @@ void PPUThread::FastCall2(u32 addr, u32 rtoc) GPR[2] = old_rtoc; LR = old_LR; SetCurrentNamedThread(old_thread); + custom_task = old_task; } void PPUThread::FastStop() { m_status = Stopped; + m_events |= CPU_EVENT_STOP; } void PPUThread::Task() { if (custom_task) { - custom_task(*this); + return custom_task(*this); } - else if (m_dec) - { - CPUThread::Task(); - } - else - { + if (m_dec) + { + return CPUThread::Task(); + } + + while (true) + { + //if (Emu.IsStopped()) + //{ + // return; + //} + + if (m_events) + { + // process events + if (m_events & CPU_EVENT_STOP && (Emu.IsStopped() || IsStopped() || IsPaused())) + { + m_events &= ~CPU_EVENT_STOP; + return; + } + } + + // read opcode + const ppu_opcode_t opcode = { vm::read32(PC) }; + + // read interpreter function index + const u32 index = *(u32*)((u8*)g_ppu_exec_map + PC); + + // call interpreter function + g_ppu_inter_func_list[index](*this, opcode); + + // next instruction + //PC += 4; + NextPc(4); } } diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp index 854567c362..ac68abb7f4 100644 --- a/rpcs3/Emu/Cell/SPUThread.cpp +++ b/rpcs3/Emu/Cell/SPUThread.cpp @@ -178,6 +178,7 @@ void SPUThread::FastCall(u32 ls_addr) void SPUThread::FastStop() { m_status = Stopped; + m_events |= CPU_EVENT_STOP; } void SPUThread::FastRun() diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp index 82d200e275..e5d6bf05b3 100644 --- a/rpcs3/Emu/System.cpp +++ b/rpcs3/Emu/System.cpp @@ -39,6 +39,8 @@ static const std::string& BreakPointsDBName = "BreakPoints.dat"; static const u16 bpdb_version = 0x1000; extern std::atomic g_thread_count; +extern void finalize_ppu_exec_map(); + Emulator::Emulator() : m_status(Stopped) , m_mode(DisAsm) @@ -98,40 +100,41 @@ void Emulator::SetTitle(const std::string& title) void Emulator::CheckStatus() { - //auto& threads = GetCPU().GetThreads(); + //auto threads = GetCPU().GetThreads(); + //if (!threads.size()) //{ // Stop(); // return; //} - //bool IsAllPaused = true; - //for (u32 i = 0; i < threads.size(); ++i) + //bool AllPaused = true; + + //for (auto& t : threads) //{ - // if (threads[i]->IsPaused()) continue; - // IsAllPaused = false; + // if (t->IsPaused()) continue; + // AllPaused = false; // break; //} - //if(IsAllPaused) + //if (AllPaused) //{ - // //ConLog.Warning("all paused!"); // Pause(); // return; //} - //bool IsAllStoped = true; - //for (u32 i = 0; i < threads.size(); ++i) + //bool AllStopped = true; + + //for (auto& t : threads) //{ - // if (threads[i]->IsStopped()) continue; - // IsAllStoped = false; + // if (t->IsStopped()) continue; + // AllStopped = false; // break; //} - //if (IsAllStoped) + //if (AllStopped) //{ - // //LOG_WARNING(GENERAL, "all stoped!"); - // Pause(); //Stop(); + // Pause(); //} } @@ -327,8 +330,18 @@ void Emulator::Stop() if(IsStopped()) return; SendDbgCommand(DID_STOP_EMU); + m_status = Stopped; + { + auto threads = GetCPU().GetThreads(); + + for (auto& t : threads) + { + t->AddEvent(CPU_EVENT_STOP); + } + } + while (g_thread_count) { std::this_thread::sleep_for(std::chrono::milliseconds(1)); @@ -370,6 +383,8 @@ void Emulator::Stop() CurGameInfo.Reset(); Memory.Close(); + + finalize_ppu_exec_map(); SendDbgCommand(DID_STOPPED_EMU); } diff --git a/rpcs3/Loader/ELF64.cpp b/rpcs3/Loader/ELF64.cpp index 6c89d7cf04..56999154e1 100644 --- a/rpcs3/Loader/ELF64.cpp +++ b/rpcs3/Loader/ELF64.cpp @@ -16,6 +16,9 @@ using namespace PPU_instr; +extern void initialize_ppu_exec_map(); +extern void fill_ppu_exec_map(u32 addr, u32 size); + namespace loader { namespace handlers @@ -547,6 +550,16 @@ namespace loader main_thread.args({ Emu.GetPath()/*, "-emu"*/ }).run(); main_thread.gpr(11, OPD.addr()).gpr(12, Emu.GetMallocPageSize()); + initialize_ppu_exec_map(); + + for (u32 page = 0; page < 0x20000000; page += 4096) + { + if (vm::check_addr(page, 4096)) + { + fill_ppu_exec_map(page, 4096); + } + } + return ok; } diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj index f7f0b774a9..45870f8502 100644 --- a/rpcs3/emucore.vcxproj +++ b/rpcs3/emucore.vcxproj @@ -37,6 +37,7 @@ + @@ -366,6 +367,7 @@ + diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters index 9d50d29f54..a404d9b903 100644 --- a/rpcs3/emucore.vcxproj.filters +++ b/rpcs3/emucore.vcxproj.filters @@ -860,6 +860,9 @@ Emu\SysCalls\Modules + + Emu\CPU\Cell + @@ -1543,5 +1546,8 @@ Emu\SysCalls\Modules + + Emu\CPU\Cell + \ No newline at end of file