From 840ae2f86b3458123fa3fa1e285e9f55c13e122a Mon Sep 17 00:00:00 2001
From: S Gopal Rajagopal <gopalsr83@users.noreply.github.com>
Date: Mon, 15 Sep 2014 20:05:18 +0530
Subject: [PATCH] Run recompilation in the background

---
 rpcs3/Emu/Cell/PPUInterpreter.h           |    2 +-
 rpcs3/Emu/Cell/PPULLVMRecompiler.cpp      | 1013 +++++++++++----------
 rpcs3/Emu/Cell/PPULLVMRecompiler.h        |   69 +-
 rpcs3/Emu/Cell/PPULLVMRecompilerTests.cpp |    8 +-
 rpcs3/Emu/Cell/PPUThread.cpp              |    2 +-
 5 files changed, 594 insertions(+), 500 deletions(-)

diff --git a/rpcs3/Emu/Cell/PPUInterpreter.h b/rpcs3/Emu/Cell/PPUInterpreter.h
index b8cdda82d5..b5e8adf31a 100644
--- a/rpcs3/Emu/Cell/PPUInterpreter.h
+++ b/rpcs3/Emu/Cell/PPUInterpreter.h
@@ -56,7 +56,7 @@ u64 rotr64(const u64 x, const u8 n) { return (x >> n) | (x << (64 - n)); }
 
 class PPUInterpreter : public PPUOpcodes
 {
-    friend class PPULLVMRecompilerWorker;
+    friend class PPULLVMRecompiler;
 private:
 	PPUThread& CPU;
 
diff --git a/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
index 2f6043ef1b..1b2716f18c 100644
--- a/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
@@ -9,11 +9,14 @@
 #include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/Filesystem.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Analysis/Passes.h"
 
 using namespace llvm;
 
-PPULLVMRecompilerWorker::PPULLVMRecompilerWorker()
-    : m_decoder(this)
+PPULLVMRecompiler::PPULLVMRecompiler()
+    : ThreadBase("PPULLVMRecompiler")
+    , m_decoder(this)
     , m_compilation_time(0.0)
     , m_idling_time(0.0) {
     InitializeNativeTarget();
@@ -31,11 +34,15 @@ PPULLVMRecompilerWorker::PPULLVMRecompilerWorker()
     m_execution_engine = engine_builder.create();
 
     m_disassembler = LLVMCreateDisasm(sys::getProcessTriple().c_str(), nullptr, 0, nullptr, nullptr);
+
+    Start();
 }
 
-PPULLVMRecompilerWorker::~PPULLVMRecompilerWorker() {
+PPULLVMRecompiler::~PPULLVMRecompiler() {
+    Stop();
+
     std::string error;
-    raw_fd_ostream log_file("PPULLVMRecompilerWorker.log", error, sys::fs::F_Text);
+    raw_fd_ostream log_file("PPULLVMRecompiler.log", error, sys::fs::F_Text);
     log_file << "Time spent compiling = " << m_compilation_time.count() << "s\n";
     log_file << "Time spent idling    = " << m_idling_time.count() << "s\n\n";
     log_file << "Interpreter fallback stats:\n";
@@ -52,8 +59,53 @@ PPULLVMRecompilerWorker::~PPULLVMRecompilerWorker() {
     delete m_llvm_context;
 }
 
-void PPULLVMRecompilerWorker::Compile(const u64 address) {
+PPULLVMRecompiler::CompiledBlock PPULLVMRecompiler::GetCompiledBlock(u64 address) {
+    m_address_to_compiled_block_map_mutex.lock();
     auto i = m_address_to_compiled_block_map.find(address);
+    m_address_to_compiled_block_map_mutex.unlock();
+
+    if (i != m_address_to_compiled_block_map.end()) {
+        return i->second;
+    }
+
+    m_pending_blocks_set_mutex.lock();
+    m_pending_blocks_set.insert(address);
+    m_pending_blocks_set_mutex.unlock();
+    Notify();
+    return nullptr;
+}
+
+void PPULLVMRecompiler::Task() {
+    while (!TestDestroy()) {
+        std::chrono::high_resolution_clock::time_point idle_start = std::chrono::high_resolution_clock::now();
+        WaitForAnySignal();
+        std::chrono::high_resolution_clock::time_point idle_end = std::chrono::high_resolution_clock::now();
+        m_idling_time += std::chrono::duration_cast<std::chrono::duration<double>>(idle_end - idle_start);
+
+        while (!TestDestroy()) {
+            u64 address;
+
+            m_pending_blocks_set_mutex.lock();
+            auto i = m_pending_blocks_set.begin();
+            m_pending_blocks_set_mutex.unlock();
+
+            if (i != m_pending_blocks_set.end()) {
+                address = *i;
+                m_pending_blocks_set.erase(i);
+            } else {
+                break;
+            }
+
+            Compile(address);
+        }
+    }
+}
+
+void PPULLVMRecompiler::Compile(const u64 address) {
+    m_address_to_compiled_block_map_mutex.lock();
+    auto i = m_address_to_compiled_block_map.find(address);
+    m_address_to_compiled_block_map_mutex.unlock();
+
     if (i != m_address_to_compiled_block_map.end()) {
         return;
     }
@@ -91,51 +143,44 @@ void PPULLVMRecompilerWorker::Compile(const u64 address) {
         m_execution_engine->runJITOnFunction(m_function);
     }
 
+    m_address_to_compiled_block_map_mutex.lock();
     m_address_to_compiled_block_map[address] = (CompiledBlock)m_execution_engine->getPointerToFunction(m_function);
+    m_address_to_compiled_block_map_mutex.unlock();
 
     std::chrono::high_resolution_clock::time_point compilation_end = std::chrono::high_resolution_clock::now();
     m_compilation_time += std::chrono::duration_cast<std::chrono::duration<double>>(compilation_end - compilation_start);
 }
 
-PPULLVMRecompilerWorker::CompiledBlock PPULLVMRecompilerWorker::GetCompiledBlock(u64 address) {
-    auto i = m_address_to_compiled_block_map.find(address);
-    if (i != m_address_to_compiled_block_map.end()) {
-        return i->second;
-    }
-
-    return nullptr;
-}
-
-void PPULLVMRecompilerWorker::NULL_OP() {
+void PPULLVMRecompiler::NULL_OP() {
     InterpreterCall("NULL_OP", &PPUInterpreter::NULL_OP);
 }
 
-void PPULLVMRecompilerWorker::NOP() {
+void PPULLVMRecompiler::NOP() {
     InterpreterCall("NOP", &PPUInterpreter::NOP);
 }
 
-void PPULLVMRecompilerWorker::TDI(u32 to, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::TDI(u32 to, u32 ra, s32 simm16) {
     InterpreterCall("TDI", &PPUInterpreter::TDI, to, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::TWI(u32 to, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::TWI(u32 to, u32 ra, s32 simm16) {
     InterpreterCall("TWI", &PPUInterpreter::TWI, to, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::MFVSCR(u32 vd) {
+void PPULLVMRecompiler::MFVSCR(u32 vd) {
     auto vscr_i32  = GetVscr();
     auto vscr_i128 = m_ir_builder->CreateZExt(vscr_i32, m_ir_builder->getIntNTy(128));
     SetVr(vd, vscr_i128);
 }
 
-void PPULLVMRecompilerWorker::MTVSCR(u32 vb) {
+void PPULLVMRecompiler::MTVSCR(u32 vb) {
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
     auto vscr_i32 = m_ir_builder->CreateExtractElement(vb_v4i32, m_ir_builder->getInt32(0));
     vscr_i32      = m_ir_builder->CreateAnd(vscr_i32, 0x00010001);
     SetVscr(vscr_i32);
 }
 
-void PPULLVMRecompilerWorker::VADDCUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDCUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
 
@@ -148,14 +193,14 @@ void PPULLVMRecompilerWorker::VADDCUW(u32 vd, u32 va, u32 vb) {
     // TODO: Implement with overflow intrinsics and check if the generated code is better
 }
 
-void PPULLVMRecompilerWorker::VADDFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto sum_v4f32 = m_ir_builder->CreateFAdd(va_v4f32, vb_v4f32);
     SetVr(vd, sum_v4f32);
 }
 
-void PPULLVMRecompilerWorker::VADDSBS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDSBS(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto sum_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_padds_b), va_v16i8, vb_v16i8);
@@ -164,7 +209,7 @@ void PPULLVMRecompilerWorker::VADDSBS(u32 vd, u32 va, u32 vb) {
     // TODO: Set VSCR.SAT
 }
 
-void PPULLVMRecompilerWorker::VADDSHS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDSHS(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto sum_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_padds_w), va_v8i16, vb_v8i16);
@@ -173,7 +218,7 @@ void PPULLVMRecompilerWorker::VADDSHS(u32 vd, u32 va, u32 vb) {
     // TODO: Set VSCR.SAT
 }
 
-void PPULLVMRecompilerWorker::VADDSWS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDSWS(u32 vd, u32 va, u32 vb) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
 
@@ -216,14 +261,14 @@ void PPULLVMRecompilerWorker::VADDSWS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompilerWorker::VADDUBM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDUBM(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto sum_v16i8 = m_ir_builder->CreateAdd(va_v16i8, vb_v16i8);
     SetVr(vd, sum_v16i8);
 }
 
-void PPULLVMRecompilerWorker::VADDUBS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDUBS(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto sum_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_paddus_b), va_v16i8, vb_v16i8);
@@ -232,14 +277,14 @@ void PPULLVMRecompilerWorker::VADDUBS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompilerWorker::VADDUHM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDUHM(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto sum_v8i16 = m_ir_builder->CreateAdd(va_v8i16, vb_v8i16);
     SetVr(vd, sum_v8i16);
 }
 
-void PPULLVMRecompilerWorker::VADDUHS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDUHS(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto sum_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_paddus_w), va_v8i16, vb_v8i16);
@@ -248,14 +293,14 @@ void PPULLVMRecompilerWorker::VADDUHS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompilerWorker::VADDUWM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDUWM(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto sum_v4i32 = m_ir_builder->CreateAdd(va_v4i32, vb_v4i32);
     SetVr(vd, sum_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VADDUWS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VADDUWS(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto sum_v4i32 = m_ir_builder->CreateAdd(va_v4i32, vb_v4i32);
@@ -267,14 +312,14 @@ void PPULLVMRecompilerWorker::VADDUWS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompilerWorker::VAND(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAND(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4i32 = m_ir_builder->CreateAnd(va_v4i32, vb_v4i32);
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VANDC(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VANDC(u32 vd, u32 va, u32 vb) {
     auto va_v4i32          = GetVrAsIntVec(va, 32);
     auto vb_v4i32          = GetVrAsIntVec(vb, 32);
     u32  not_mask_v4i32[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
@@ -283,7 +328,7 @@ void PPULLVMRecompilerWorker::VANDC(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VAVGSB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAVGSB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8       = GetVrAsIntVec(va, 8);
     auto vb_v16i8       = GetVrAsIntVec(vb, 8);
     auto va_v16i16      = m_ir_builder->CreateSExt(va_v16i8, VectorType::get(m_ir_builder->getInt16Ty(), 16));
@@ -296,7 +341,7 @@ void PPULLVMRecompilerWorker::VAVGSB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v16i8);
 }
 
-void PPULLVMRecompilerWorker::VAVGSH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAVGSH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16     = GetVrAsIntVec(va, 16);
     auto vb_v8i16     = GetVrAsIntVec(vb, 16);
     auto va_v8i32     = m_ir_builder->CreateSExt(va_v8i16, VectorType::get(m_ir_builder->getInt32Ty(), 8));
@@ -309,7 +354,7 @@ void PPULLVMRecompilerWorker::VAVGSH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v8i16);
 }
 
-void PPULLVMRecompilerWorker::VAVGSW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAVGSW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32     = GetVrAsIntVec(va, 32);
     auto vb_v4i32     = GetVrAsIntVec(vb, 32);
     auto va_v4i64     = m_ir_builder->CreateSExt(va_v4i32, VectorType::get(m_ir_builder->getInt64Ty(), 4));
@@ -322,21 +367,21 @@ void PPULLVMRecompilerWorker::VAVGSW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VAVGUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAVGUB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto avg_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pavg_b), va_v16i8, vb_v16i8);
     SetVr(vd, avg_v16i8);
 }
 
-void PPULLVMRecompilerWorker::VAVGUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAVGUH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto avg_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pavg_w), va_v8i16, vb_v8i16);
     SetVr(vd, avg_v8i16);
 }
 
-void PPULLVMRecompilerWorker::VAVGUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VAVGUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32     = GetVrAsIntVec(va, 32);
     auto vb_v4i32     = GetVrAsIntVec(vb, 32);
     auto va_v4i64     = m_ir_builder->CreateZExt(va_v4i32, VectorType::get(m_ir_builder->getInt64Ty(), 4));
@@ -349,7 +394,7 @@ void PPULLVMRecompilerWorker::VAVGUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCFSX(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VCFSX(u32 vd, u32 uimm5, u32 vb) {
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4f32 = m_ir_builder->CreateSIToFP(vb_v4i32, VectorType::get(m_ir_builder->getFloatTy(), 4));
 
@@ -362,7 +407,7 @@ void PPULLVMRecompilerWorker::VCFSX(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompilerWorker::VCFUX(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VCFUX(u32 vd, u32 uimm5, u32 vb) {
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4f32 = m_ir_builder->CreateUIToFP(vb_v4i32, VectorType::get(m_ir_builder->getFloatTy(), 4));
 
@@ -375,7 +420,7 @@ void PPULLVMRecompilerWorker::VCFUX(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompilerWorker::VCMPBFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPBFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32     = GetVrAsFloatVec(va);
     auto vb_v4f32     = GetVrAsFloatVec(vb);
     auto cmp_gt_v4i1  = m_ir_builder->CreateFCmpOGT(va_v4f32, vb_v4f32);
@@ -391,7 +436,7 @@ void PPULLVMRecompilerWorker::VCMPBFP(u32 vd, u32 va, u32 vb) {
     // TODO: Implement NJ mode
 }
 
-void PPULLVMRecompilerWorker::VCMPBFP_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPBFP_(u32 vd, u32 va, u32 vb) {
     VCMPBFP(vd, va, vb);
 
     auto vd_v16i8     = GetVrAsIntVec(vd, 8);
@@ -403,7 +448,7 @@ void PPULLVMRecompilerWorker::VCMPBFP_(u32 vd, u32 va, u32 vb) {
     SetCrField(6, nullptr, nullptr, cmp_i1, nullptr);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto cmp_v4i1  = m_ir_builder->CreateFCmpOEQ(va_v4f32, vb_v4f32);
@@ -411,12 +456,12 @@ void PPULLVMRecompilerWorker::VCMPEQFP(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQFP_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQFP_(u32 vd, u32 va, u32 vb) {
     VCMPEQFP(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQUB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto cmp_v16i1 = m_ir_builder->CreateICmpEQ(va_v16i8, vb_v16i8);
@@ -424,12 +469,12 @@ void PPULLVMRecompilerWorker::VCMPEQUB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v16i8);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQUB_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQUB_(u32 vd, u32 va, u32 vb) {
     VCMPEQUB(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQUH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto cmp_v8i1  = m_ir_builder->CreateICmpEQ(va_v8i16, vb_v8i16);
@@ -437,12 +482,12 @@ void PPULLVMRecompilerWorker::VCMPEQUH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v8i16);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQUH_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQUH_(u32 vd, u32 va, u32 vb) {
     VCMPEQUH(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto cmp_v4i1  = m_ir_builder->CreateICmpEQ(va_v4i32, vb_v4i32);
@@ -450,12 +495,12 @@ void PPULLVMRecompilerWorker::VCMPEQUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCMPEQUW_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPEQUW_(u32 vd, u32 va, u32 vb) {
     VCMPEQUW(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGEFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGEFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto cmp_v4i1  = m_ir_builder->CreateFCmpOGE(va_v4f32, vb_v4f32);
@@ -463,12 +508,12 @@ void PPULLVMRecompilerWorker::VCMPGEFP(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCMPGEFP_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGEFP_(u32 vd, u32 va, u32 vb) {
     VCMPGEFP(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto cmp_v4i1  = m_ir_builder->CreateFCmpOGT(va_v4f32, vb_v4f32);
@@ -476,12 +521,12 @@ void PPULLVMRecompilerWorker::VCMPGTFP(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTFP_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTFP_(u32 vd, u32 va, u32 vb) {
     VCMPGTFP(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTSB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTSB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto cmp_v16i1 = m_ir_builder->CreateICmpSGT(va_v16i8, vb_v16i8);
@@ -489,12 +534,12 @@ void PPULLVMRecompilerWorker::VCMPGTSB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v16i8);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTSB_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTSB_(u32 vd, u32 va, u32 vb) {
     VCMPGTSB(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTSH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTSH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto cmp_v8i1  = m_ir_builder->CreateICmpSGT(va_v8i16, vb_v8i16);
@@ -502,12 +547,12 @@ void PPULLVMRecompilerWorker::VCMPGTSH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v8i16);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTSH_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTSH_(u32 vd, u32 va, u32 vb) {
     VCMPGTSH(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTSW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTSW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto cmp_v4i1  = m_ir_builder->CreateICmpSGT(va_v4i32, vb_v4i32);
@@ -515,12 +560,12 @@ void PPULLVMRecompilerWorker::VCMPGTSW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTSW_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTSW_(u32 vd, u32 va, u32 vb) {
     VCMPGTSW(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTUB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto cmp_v16i1 = m_ir_builder->CreateICmpUGT(va_v16i8, vb_v16i8);
@@ -528,12 +573,12 @@ void PPULLVMRecompilerWorker::VCMPGTUB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v16i8);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTUB_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTUB_(u32 vd, u32 va, u32 vb) {
     VCMPGTUB(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTUH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto cmp_v8i1  = m_ir_builder->CreateICmpUGT(va_v8i16, vb_v8i16);
@@ -541,12 +586,12 @@ void PPULLVMRecompilerWorker::VCMPGTUH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v8i16);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTUH_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTUH_(u32 vd, u32 va, u32 vb) {
     VCMPGTUH(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto cmp_v4i1  = m_ir_builder->CreateICmpUGT(va_v4i32, vb_v4i32);
@@ -554,451 +599,451 @@ void PPULLVMRecompilerWorker::VCMPGTUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompilerWorker::VCMPGTUW_(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VCMPGTUW_(u32 vd, u32 va, u32 vb) {
     VCMPGTUW(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompilerWorker::VCTSXS(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VCTSXS(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VCTSXS", &PPUInterpreter::VCTSXS, vd, uimm5, vb);
 }
 
-void PPULLVMRecompilerWorker::VCTUXS(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VCTUXS(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VCTUXS", &PPUInterpreter::VCTUXS, vd, uimm5, vb);
 }
 
-void PPULLVMRecompilerWorker::VEXPTEFP(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VEXPTEFP(u32 vd, u32 vb) {
     InterpreterCall("VEXPTEFP", &PPUInterpreter::VEXPTEFP, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VLOGEFP(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VLOGEFP(u32 vd, u32 vb) {
     InterpreterCall("VLOGEFP", &PPUInterpreter::VLOGEFP, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) {
+void PPULLVMRecompiler::VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) {
     InterpreterCall("VMADDFP", &PPUInterpreter::VMADDFP, vd, va, vc, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXFP(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXFP", &PPUInterpreter::VMAXFP, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXSB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXSB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXSB", &PPUInterpreter::VMAXSB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXSH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXSH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXSH", &PPUInterpreter::VMAXSH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXSW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXSW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXSW", &PPUInterpreter::VMAXSW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXUB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXUB", &PPUInterpreter::VMAXUB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXUH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXUH", &PPUInterpreter::VMAXUH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMAXUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMAXUW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMAXUW", &PPUInterpreter::VMAXUW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMHADDSHS", &PPUInterpreter::VMHADDSHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMHRADDSHS", &PPUInterpreter::VMHRADDSHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMINFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINFP(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINFP", &PPUInterpreter::VMINFP, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMINSB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINSB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINSB", &PPUInterpreter::VMINSB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMINSH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINSH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINSH", &PPUInterpreter::VMINSH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMINSW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINSW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINSW", &PPUInterpreter::VMINSW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMINUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINUB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINUB", &PPUInterpreter::VMINUB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMINUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINUH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINUH", &PPUInterpreter::VMINUH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMINUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMINUW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMINUW", &PPUInterpreter::VMINUW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMLADDUHM", &PPUInterpreter::VMLADDUHM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMRGHB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMRGHB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMRGHB", &PPUInterpreter::VMRGHB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMRGHH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMRGHH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMRGHH", &PPUInterpreter::VMRGHH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMRGHW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMRGHW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMRGHW", &PPUInterpreter::VMRGHW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMRGLB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMRGLB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMRGLB", &PPUInterpreter::VMRGLB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMRGLH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMRGLH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMRGLH", &PPUInterpreter::VMRGLH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMRGLW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMRGLW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMRGLW", &PPUInterpreter::VMRGLW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMMBM", &PPUInterpreter::VMSUMMBM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMSHM", &PPUInterpreter::VMSUMSHM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMSHS", &PPUInterpreter::VMSUMSHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMUBM", &PPUInterpreter::VMSUMUBM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMUHM", &PPUInterpreter::VMSUMUHM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMUHS", &PPUInterpreter::VMSUMUHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VMULESB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULESB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULESB", &PPUInterpreter::VMULESB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULESH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULESH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULESH", &PPUInterpreter::VMULESH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULEUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULEUB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULEUB", &PPUInterpreter::VMULEUB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULEUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULEUH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULEUH", &PPUInterpreter::VMULEUH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULOSB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULOSB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOSB", &PPUInterpreter::VMULOSB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULOSH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULOSH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOSH", &PPUInterpreter::VMULOSH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULOUB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULOUB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOUB", &PPUInterpreter::VMULOUB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VMULOUH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VMULOUH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOUH", &PPUInterpreter::VMULOUH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) {
+void PPULLVMRecompiler::VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) {
     InterpreterCall("VNMSUBFP", &PPUInterpreter::VNMSUBFP, vd, va, vc, vb);
 }
 
-void PPULLVMRecompilerWorker::VNOR(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VNOR(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VNOR", &PPUInterpreter::VNOR, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VOR(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VOR(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VOR", &PPUInterpreter::VOR, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPERM(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VPERM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VPERM", &PPUInterpreter::VPERM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VPKPX(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKPX(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKPX", &PPUInterpreter::VPKPX, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKSHSS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKSHSS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSHSS", &PPUInterpreter::VPKSHSS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKSHUS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKSHUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSHUS", &PPUInterpreter::VPKSHUS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKSWSS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKSWSS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSWSS", &PPUInterpreter::VPKSWSS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKSWUS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKSWUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSWUS", &PPUInterpreter::VPKSWUS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKUHUM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKUHUM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUHUM", &PPUInterpreter::VPKUHUM, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKUHUS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKUHUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUHUS", &PPUInterpreter::VPKUHUS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKUWUM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKUWUM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUWUM", &PPUInterpreter::VPKUWUM, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VPKUWUS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VPKUWUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUWUS", &PPUInterpreter::VPKUWUS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VREFP(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VREFP(u32 vd, u32 vb) {
     InterpreterCall("VREFP", &PPUInterpreter::VREFP, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VRFIM(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VRFIM(u32 vd, u32 vb) {
     InterpreterCall("VRFIM", &PPUInterpreter::VRFIM, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VRFIN(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VRFIN(u32 vd, u32 vb) {
     InterpreterCall("VRFIN", &PPUInterpreter::VRFIN, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VRFIP(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VRFIP(u32 vd, u32 vb) {
     InterpreterCall("VRFIP", &PPUInterpreter::VRFIP, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VRFIZ(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VRFIZ(u32 vd, u32 vb) {
     InterpreterCall("VRFIZ", &PPUInterpreter::VRFIZ, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VRLB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VRLB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VRLB", &PPUInterpreter::VRLB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VRLH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VRLH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VRLH", &PPUInterpreter::VRLH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VRLW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VRLW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VRLW", &PPUInterpreter::VRLW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VRSQRTEFP(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VRSQRTEFP(u32 vd, u32 vb) {
     InterpreterCall("VRSQRTEFP", &PPUInterpreter::VRSQRTEFP, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VSEL(u32 vd, u32 va, u32 vb, u32 vc) {
+void PPULLVMRecompiler::VSEL(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VSEL", &PPUInterpreter::VSEL, vd, va, vb, vc);
 }
 
-void PPULLVMRecompilerWorker::VSL(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSL(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSL", &PPUInterpreter::VSL, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSLB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSLB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSLB", &PPUInterpreter::VSLB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) {
+void PPULLVMRecompiler::VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) {
     InterpreterCall("VSLDOI", &PPUInterpreter::VSLDOI, vd, va, vb, sh);
 }
 
-void PPULLVMRecompilerWorker::VSLH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSLH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSLH", &PPUInterpreter::VSLH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSLO(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSLO(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSLO", &PPUInterpreter::VSLO, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSLW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSLW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSLW", &PPUInterpreter::VSLW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSPLTB(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VSPLTB(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VSPLTB", &PPUInterpreter::VSPLTB, vd, uimm5, vb);
 }
 
-void PPULLVMRecompilerWorker::VSPLTH(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VSPLTH(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VSPLTH", &PPUInterpreter::VSPLTH, vd, uimm5, vb);
 }
 
-void PPULLVMRecompilerWorker::VSPLTISB(u32 vd, s32 simm5) {
+void PPULLVMRecompiler::VSPLTISB(u32 vd, s32 simm5) {
     InterpreterCall("VSPLTISB", &PPUInterpreter::VSPLTISB, vd, simm5);
 }
 
-void PPULLVMRecompilerWorker::VSPLTISH(u32 vd, s32 simm5) {
+void PPULLVMRecompiler::VSPLTISH(u32 vd, s32 simm5) {
     InterpreterCall("VSPLTISH", &PPUInterpreter::VSPLTISH, vd, simm5);
 }
 
-void PPULLVMRecompilerWorker::VSPLTISW(u32 vd, s32 simm5) {
+void PPULLVMRecompiler::VSPLTISW(u32 vd, s32 simm5) {
     InterpreterCall("VSPLTISW", &PPUInterpreter::VSPLTISW, vd, simm5);
 }
 
-void PPULLVMRecompilerWorker::VSPLTW(u32 vd, u32 uimm5, u32 vb) {
+void PPULLVMRecompiler::VSPLTW(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VSPLTW", &PPUInterpreter::VSPLTW, vd, uimm5, vb);
 }
 
-void PPULLVMRecompilerWorker::VSR(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSR(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSR", &PPUInterpreter::VSR, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRAB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRAB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRAB", &PPUInterpreter::VSRAB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRAH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRAH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRAH", &PPUInterpreter::VSRAH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRAW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRAW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRAW", &PPUInterpreter::VSRAW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRB(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRB", &PPUInterpreter::VSRB, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRH(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRH", &PPUInterpreter::VSRH, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRO(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRO(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRO", &PPUInterpreter::VSRO, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSRW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSRW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSRW", &PPUInterpreter::VSRW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBCUW(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBCUW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBCUW", &PPUInterpreter::VSUBCUW, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBFP(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBFP(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBFP", &PPUInterpreter::VSUBFP, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBSBS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBSBS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBSBS", &PPUInterpreter::VSUBSBS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBSHS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBSHS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBSHS", &PPUInterpreter::VSUBSHS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBSWS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBSWS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBSWS", &PPUInterpreter::VSUBSWS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBUBM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBUBM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBUBM", &PPUInterpreter::VSUBUBM, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBUBS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBUBS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBUBS", &PPUInterpreter::VSUBUBS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBUHM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBUHM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBUHM", &PPUInterpreter::VSUBUHM, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBUHS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBUHS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBUHS", &PPUInterpreter::VSUBUHS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBUWM(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBUWM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBUWM", &PPUInterpreter::VSUBUWM, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUBUWS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUBUWS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUBUWS", &PPUInterpreter::VSUBUWS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUMSWS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUMSWS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUMSWS", &PPUInterpreter::VSUMSWS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUM2SWS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUM2SWS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM2SWS", &PPUInterpreter::VSUM2SWS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUM4SBS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUM4SBS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM4SBS", &PPUInterpreter::VSUM4SBS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUM4SHS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUM4SHS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM4SHS", &PPUInterpreter::VSUM4SHS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VSUM4UBS(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VSUM4UBS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM4UBS", &PPUInterpreter::VSUM4UBS, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::VUPKHPX(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VUPKHPX(u32 vd, u32 vb) {
     InterpreterCall("VUPKHPX", &PPUInterpreter::VUPKHPX, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VUPKHSB(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VUPKHSB(u32 vd, u32 vb) {
     InterpreterCall("VUPKHSB", &PPUInterpreter::VUPKHSB, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VUPKHSH(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VUPKHSH(u32 vd, u32 vb) {
     InterpreterCall("VUPKHSH", &PPUInterpreter::VUPKHSH, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VUPKLPX(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VUPKLPX(u32 vd, u32 vb) {
     InterpreterCall("VUPKLPX", &PPUInterpreter::VUPKLPX, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VUPKLSB(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VUPKLSB(u32 vd, u32 vb) {
     InterpreterCall("VUPKLSB", &PPUInterpreter::VUPKLSB, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VUPKLSH(u32 vd, u32 vb) {
+void PPULLVMRecompiler::VUPKLSH(u32 vd, u32 vb) {
     InterpreterCall("VUPKLSH", &PPUInterpreter::VUPKLSH, vd, vb);
 }
 
-void PPULLVMRecompilerWorker::VXOR(u32 vd, u32 va, u32 vb) {
+void PPULLVMRecompiler::VXOR(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VXOR", &PPUInterpreter::VXOR, vd, va, vb);
 }
 
-void PPULLVMRecompilerWorker::MULLI(u32 rd, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::MULLI(u32 rd, u32 ra, s32 simm16) {
     auto ra_i64  = GetGpr(ra);
     auto res_i64 = m_ir_builder->CreateMul(ra_i64, m_ir_builder->getInt64((s64)simm16));
     SetGpr(rd, res_i64);
     //InterpreterCall("MULLI", &PPUInterpreter::MULLI, rd, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::SUBFIC(u32 rd, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::SUBFIC(u32 rd, u32 ra, s32 simm16) {
     auto ra_i64   = GetGpr(ra);
     auto res_s    = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::ssub_with_overflow, {m_ir_builder->getInt64Ty()}), m_ir_builder->getInt64((s64)simm16), ra_i64);
     auto diff_i64 = m_ir_builder->CreateExtractValue(res_s, {0});
@@ -1008,7 +1053,7 @@ void PPULLVMRecompilerWorker::SUBFIC(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("SUBFIC", &PPUInterpreter::SUBFIC, rd, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::CMPLI(u32 crfd, u32 l, u32 ra, u32 uimm16) {
+void PPULLVMRecompiler::CMPLI(u32 crfd, u32 l, u32 ra, u32 uimm16) {
     Value * ra_i64;
     if (l == 0) {
         ra_i64 = m_ir_builder->CreateZExt(GetGpr(ra, 32), m_ir_builder->getInt64Ty());
@@ -1020,7 +1065,7 @@ void PPULLVMRecompilerWorker::CMPLI(u32 crfd, u32 l, u32 ra, u32 uimm16) {
     //InterpreterCall("CMPLI", &PPUInterpreter::CMPLI, crfd, l, ra, uimm16);
 }
 
-void PPULLVMRecompilerWorker::CMPI(u32 crfd, u32 l, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::CMPI(u32 crfd, u32 l, u32 ra, s32 simm16) {
     Value * ra_i64;
     if (l == 0) {
         ra_i64 = m_ir_builder->CreateSExt(GetGpr(ra, 32), m_ir_builder->getInt64Ty());
@@ -1032,7 +1077,7 @@ void PPULLVMRecompilerWorker::CMPI(u32 crfd, u32 l, u32 ra, s32 simm16) {
     //InterpreterCall("CMPI", &PPUInterpreter::CMPI, crfd, l, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::ADDIC(u32 rd, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::ADDIC(u32 rd, u32 ra, s32 simm16) {
     auto ra_i64   = GetGpr(ra);
     auto res_s    = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::sadd_with_overflow, {m_ir_builder->getInt64Ty()}), m_ir_builder->getInt64((s64)simm16), ra_i64);
     auto sum_i64  = m_ir_builder->CreateExtractValue(res_s, {0});
@@ -1042,13 +1087,13 @@ void PPULLVMRecompilerWorker::ADDIC(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("ADDIC", &PPUInterpreter::ADDIC, rd, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::ADDIC_(u32 rd, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::ADDIC_(u32 rd, u32 ra, s32 simm16) {
     ADDIC(rd, ra, simm16);
     SetCrFieldSignedCmp(0, GetGpr(rd), m_ir_builder->getInt64(0));
     //InterpreterCall("ADDIC_", &PPUInterpreter::ADDIC_, rd, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::ADDI(u32 rd, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::ADDI(u32 rd, u32 ra, s32 simm16) {
     if (ra == 0) {
         SetGpr(rd, m_ir_builder->getInt64((s64)simm16));
     } else {
@@ -1059,7 +1104,7 @@ void PPULLVMRecompilerWorker::ADDI(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("ADDI", &PPUInterpreter::ADDI, rd, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::ADDIS(u32 rd, u32 ra, s32 simm16) {
+void PPULLVMRecompiler::ADDIS(u32 rd, u32 ra, s32 simm16) {
     if (ra == 0) {
         SetGpr(rd, m_ir_builder->getInt64((s64)simm16 << 16));
     } else {
@@ -1070,21 +1115,21 @@ void PPULLVMRecompilerWorker::ADDIS(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("ADDIS", &PPUInterpreter::ADDIS, rd, ra, simm16);
 }
 
-void PPULLVMRecompilerWorker::BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) {
+void PPULLVMRecompiler::BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) {
     InterpreterCall("BC", &PPUInterpreter::BC, bo, bi, bd, aa, lk);
     m_hit_branch_instruction = true;
 }
 
-void PPULLVMRecompilerWorker::SC(u32 sc_code) {
+void PPULLVMRecompiler::SC(u32 sc_code) {
     InterpreterCall("SC", &PPUInterpreter::SC, sc_code);
 }
 
-void PPULLVMRecompilerWorker::B(s32 ll, u32 aa, u32 lk) {
+void PPULLVMRecompiler::B(s32 ll, u32 aa, u32 lk) {
     InterpreterCall("B", &PPUInterpreter::B, ll, aa, lk);
     m_hit_branch_instruction = true;
 }
 
-void PPULLVMRecompilerWorker::MCRF(u32 crfd, u32 crfs) {
+void PPULLVMRecompiler::MCRF(u32 crfd, u32 crfs) {
     if (crfd != crfs) {
         auto cr_i32  = GetCr();
         auto crf_i32 = GetNibble(cr_i32, crfs);
@@ -1094,12 +1139,12 @@ void PPULLVMRecompilerWorker::MCRF(u32 crfd, u32 crfs) {
     //InterpreterCall("MCRF", &PPUInterpreter::MCRF, crfd, crfs);
 }
 
-void PPULLVMRecompilerWorker::BCLR(u32 bo, u32 bi, u32 bh, u32 lk) {
+void PPULLVMRecompiler::BCLR(u32 bo, u32 bi, u32 bh, u32 lk) {
     InterpreterCall("BCLR", &PPUInterpreter::BCLR, bo, bi, bh, lk);
     m_hit_branch_instruction = true;
 }
 
-void PPULLVMRecompilerWorker::CRNOR(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CRNOR(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1110,7 +1155,7 @@ void PPULLVMRecompilerWorker::CRNOR(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRNOR", &PPUInterpreter::CRNOR, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::CRANDC(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CRANDC(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1121,11 +1166,11 @@ void PPULLVMRecompilerWorker::CRANDC(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRANDC", &PPUInterpreter::CRANDC, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::ISYNC() {
+void PPULLVMRecompiler::ISYNC() {
     m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_mfence));
 }
 
-void PPULLVMRecompilerWorker::CRXOR(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CRXOR(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1135,7 +1180,7 @@ void PPULLVMRecompilerWorker::CRXOR(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRXOR", &PPUInterpreter::CRXOR, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::CRNAND(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CRNAND(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1146,7 +1191,7 @@ void PPULLVMRecompilerWorker::CRNAND(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRNAND", &PPUInterpreter::CRNAND, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::CRAND(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CRAND(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1156,7 +1201,7 @@ void PPULLVMRecompilerWorker::CRAND(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRAND", &PPUInterpreter::CRAND, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::CREQV(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CREQV(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1167,7 +1212,7 @@ void PPULLVMRecompilerWorker::CREQV(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CREQV", &PPUInterpreter::CREQV, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::CRORC(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CRORC(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1178,7 +1223,7 @@ void PPULLVMRecompilerWorker::CRORC(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRORC", &PPUInterpreter::CRORC, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::CROR(u32 crbd, u32 crba, u32 crbb) {
+void PPULLVMRecompiler::CROR(u32 crbd, u32 crba, u32 crbb) {
     auto cr_i32  = GetCr();
     auto ba_i32  = GetBit(cr_i32, crba);
     auto bb_i32  = GetBit(cr_i32, crbb);
@@ -1188,52 +1233,52 @@ void PPULLVMRecompilerWorker::CROR(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CROR", &PPUInterpreter::CROR, crbd, crba, crbb);
 }
 
-void PPULLVMRecompilerWorker::BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) {
+void PPULLVMRecompiler::BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) {
     InterpreterCall("BCCTR", &PPUInterpreter::BCCTR, bo, bi, bh, lk);
     m_hit_branch_instruction = true;
 }
 
-void PPULLVMRecompilerWorker::RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
+void PPULLVMRecompiler::RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
     InterpreterCall("RLWIMI", &PPUInterpreter::RLWIMI, ra, rs, sh, mb, me, rc);
 }
 
-void PPULLVMRecompilerWorker::RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
+void PPULLVMRecompiler::RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
     InterpreterCall("RLWINM", &PPUInterpreter::RLWINM, ra, rs, sh, mb, me, rc);
 }
 
-void PPULLVMRecompilerWorker::RLWNM(u32 ra, u32 rs, u32 rb, u32 mb, u32 me, bool rc) {
+void PPULLVMRecompiler::RLWNM(u32 ra, u32 rs, u32 rb, u32 mb, u32 me, bool rc) {
     InterpreterCall("RLWNM", &PPUInterpreter::RLWNM, ra, rs, rb, mb, me, rc);
 }
 
-void PPULLVMRecompilerWorker::ORI(u32 ra, u32 rs, u32 uimm16) {
+void PPULLVMRecompiler::ORI(u32 ra, u32 rs, u32 uimm16) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateOr(rs_i64, uimm16);
     SetGpr(ra, res_i64);
     //InterpreterCall("ORI", &PPUInterpreter::ORI, ra, rs, uimm16);
 }
 
-void PPULLVMRecompilerWorker::ORIS(u32 ra, u32 rs, u32 uimm16) {
+void PPULLVMRecompiler::ORIS(u32 ra, u32 rs, u32 uimm16) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateOr(rs_i64, (u64)uimm16 << 16);
     SetGpr(ra, res_i64);
     //InterpreterCall("ORIS", &PPUInterpreter::ORIS, ra, rs, uimm16);
 }
 
-void PPULLVMRecompilerWorker::XORI(u32 ra, u32 rs, u32 uimm16) {
+void PPULLVMRecompiler::XORI(u32 ra, u32 rs, u32 uimm16) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateXor(rs_i64, uimm16);
     SetGpr(ra, res_i64);
     //InterpreterCall("XORI", &PPUInterpreter::XORI, ra, rs, uimm16);
 }
 
-void PPULLVMRecompilerWorker::XORIS(u32 ra, u32 rs, u32 uimm16) {
+void PPULLVMRecompiler::XORIS(u32 ra, u32 rs, u32 uimm16) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateXor(rs_i64, (u64)uimm16 << 16);
     SetGpr(ra, res_i64);
     //InterpreterCall("XORIS", &PPUInterpreter::XORIS, ra, rs, uimm16);
 }
 
-void PPULLVMRecompilerWorker::ANDI_(u32 ra, u32 rs, u32 uimm16) {
+void PPULLVMRecompiler::ANDI_(u32 ra, u32 rs, u32 uimm16) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateAnd(rs_i64, uimm16);
     SetGpr(ra, res_i64);
@@ -1241,7 +1286,7 @@ void PPULLVMRecompilerWorker::ANDI_(u32 ra, u32 rs, u32 uimm16) {
     //InterpreterCall("ANDI_", &PPUInterpreter::ANDI_, ra, rs, uimm16);
 }
 
-void PPULLVMRecompilerWorker::ANDIS_(u32 ra, u32 rs, u32 uimm16) {
+void PPULLVMRecompiler::ANDIS_(u32 ra, u32 rs, u32 uimm16) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateAnd(rs_i64, (u64)uimm16 << 16);
     SetGpr(ra, res_i64);
@@ -1249,27 +1294,27 @@ void PPULLVMRecompilerWorker::ANDIS_(u32 ra, u32 rs, u32 uimm16) {
     //InterpreterCall("ANDIS_", &PPUInterpreter::ANDIS_, ra, rs, uimm16);
 }
 
-void PPULLVMRecompilerWorker::RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
+void PPULLVMRecompiler::RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     InterpreterCall("RLDICL", &PPUInterpreter::RLDICL, ra, rs, sh, mb, rc);
 }
 
-void PPULLVMRecompilerWorker::RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) {
+void PPULLVMRecompiler::RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) {
     InterpreterCall("RLDICR", &PPUInterpreter::RLDICR, ra, rs, sh, me, rc);
 }
 
-void PPULLVMRecompilerWorker::RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
+void PPULLVMRecompiler::RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     InterpreterCall("RLDIC", &PPUInterpreter::RLDIC, ra, rs, sh, mb, rc);
 }
 
-void PPULLVMRecompilerWorker::RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
+void PPULLVMRecompiler::RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     InterpreterCall("RLDIMI", &PPUInterpreter::RLDIMI, ra, rs, sh, mb, rc);
 }
 
-void PPULLVMRecompilerWorker::RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) {
+void PPULLVMRecompiler::RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) {
     InterpreterCall("RLDC_LR", &PPUInterpreter::RLDC_LR, ra, rs, rb, m_eb, is_r, rc);
 }
 
-void PPULLVMRecompilerWorker::CMP(u32 crfd, u32 l, u32 ra, u32 rb) {
+void PPULLVMRecompiler::CMP(u32 crfd, u32 l, u32 ra, u32 rb) {
     Value * ra_i64;
     Value * rb_i64;
     if (l == 0) {
@@ -1284,43 +1329,43 @@ void PPULLVMRecompilerWorker::CMP(u32 crfd, u32 l, u32 ra, u32 rb) {
     //InterpreterCall("CMP", &PPUInterpreter::CMP, crfd, l, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::TW(u32 to, u32 ra, u32 rb) {
+void PPULLVMRecompiler::TW(u32 to, u32 ra, u32 rb) {
     InterpreterCall("TW", &PPUInterpreter::TW, to, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVSL(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVSL(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVSL", &PPUInterpreter::LVSL, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVEBX(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVEBX(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVEBX", &PPUInterpreter::LVEBX, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("SUBFC", &PPUInterpreter::SUBFC, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("ADDC", &PPUInterpreter::ADDC, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::MULHDU(u32 rd, u32 ra, u32 rb, bool rc) {
+void PPULLVMRecompiler::MULHDU(u32 rd, u32 ra, u32 rb, bool rc) {
     InterpreterCall("MULHDU", &PPUInterpreter::MULHDU, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::MULHWU(u32 rd, u32 ra, u32 rb, bool rc) {
+void PPULLVMRecompiler::MULHWU(u32 rd, u32 ra, u32 rb, bool rc) {
     InterpreterCall("MULHWU", &PPUInterpreter::MULHWU, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::MFOCRF(u32 a, u32 rd, u32 crm) {
+void PPULLVMRecompiler::MFOCRF(u32 a, u32 rd, u32 crm) {
     InterpreterCall("MFOCRF", &PPUInterpreter::MFOCRF, a, rd, crm);
 }
 
-void PPULLVMRecompilerWorker::LWARX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LWARX(u32 rd, u32 ra, u32 rb) {
     InterpreterCall("LWARX", &PPUInterpreter::LWARX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LDX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LDX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1332,7 +1377,7 @@ void PPULLVMRecompilerWorker::LDX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDX", &PPUInterpreter::LDX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LWZX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LWZX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1345,19 +1390,19 @@ void PPULLVMRecompilerWorker::LWZX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWZX", &PPUInterpreter::LWZX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SLW(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::SLW(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("SLW", &PPUInterpreter::SLW, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::CNTLZW(u32 ra, u32 rs, bool rc) {
+void PPULLVMRecompiler::CNTLZW(u32 ra, u32 rs, bool rc) {
     InterpreterCall("CNTLZW", &PPUInterpreter::CNTLZW, ra, rs, rc);
 }
 
-void PPULLVMRecompilerWorker::SLD(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::SLD(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("SLD", &PPUInterpreter::SLD, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::AND(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::AND(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto rb_i64  = GetGpr(rb);
     auto res_i64 = m_ir_builder->CreateAnd(rs_i64, rb_i64);
@@ -1369,7 +1414,7 @@ void PPULLVMRecompilerWorker::AND(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("AND", &PPUInterpreter::AND, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::CMPL(u32 crfd, u32 l, u32 ra, u32 rb) {
+void PPULLVMRecompiler::CMPL(u32 crfd, u32 l, u32 ra, u32 rb) {
     Value * ra_i64;
     Value * rb_i64;
     if (l == 0) {
@@ -1384,19 +1429,19 @@ void PPULLVMRecompilerWorker::CMPL(u32 crfd, u32 l, u32 ra, u32 rb) {
     //InterpreterCall("CMPL", &PPUInterpreter::CMPL, crfd, l, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVSR(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVSR(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVSR", &PPUInterpreter::LVSR, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVEHX(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVEHX(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVEHX", &PPUInterpreter::LVEHX, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("SUBF", &PPUInterpreter::SUBF, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::LDUX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LDUX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1407,11 +1452,11 @@ void PPULLVMRecompilerWorker::LDUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDUX", &PPUInterpreter::LDUX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::DCBST(u32 ra, u32 rb) {
+void PPULLVMRecompiler::DCBST(u32 ra, u32 rb) {
     InterpreterCall("DCBST", &PPUInterpreter::DCBST, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LWZUX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LWZUX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1423,39 +1468,39 @@ void PPULLVMRecompilerWorker::LWZUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWZUX", &PPUInterpreter::LWZUX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::CNTLZD(u32 ra, u32 rs, bool rc) {
+void PPULLVMRecompiler::CNTLZD(u32 ra, u32 rs, bool rc) {
     InterpreterCall("CNTLZD", &PPUInterpreter::CNTLZD, ra, rs, rc);
 }
 
-void PPULLVMRecompilerWorker::ANDC(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::ANDC(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("ANDC", &PPUInterpreter::ANDC, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::TD(u32 to, u32 ra, u32 rb) {
+void PPULLVMRecompiler::TD(u32 to, u32 ra, u32 rb) {
     InterpreterCall("TD", &PPUInterpreter::TD, to, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVEWX(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVEWX(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVEWX", &PPUInterpreter::LVEWX, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::MULHD(u32 rd, u32 ra, u32 rb, bool rc) {
+void PPULLVMRecompiler::MULHD(u32 rd, u32 ra, u32 rb, bool rc) {
     InterpreterCall("MULHD", &PPUInterpreter::MULHD, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::MULHW(u32 rd, u32 ra, u32 rb, bool rc) {
+void PPULLVMRecompiler::MULHW(u32 rd, u32 ra, u32 rb, bool rc) {
     InterpreterCall("MULHW", &PPUInterpreter::MULHW, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::LDARX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LDARX(u32 rd, u32 ra, u32 rb) {
     InterpreterCall("LDARX", &PPUInterpreter::LDARX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::DCBF(u32 ra, u32 rb) {
+void PPULLVMRecompiler::DCBF(u32 ra, u32 rb) {
     InterpreterCall("DCBF", &PPUInterpreter::DCBF, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LBZX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LBZX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1468,15 +1513,15 @@ void PPULLVMRecompilerWorker::LBZX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LBZX", &PPUInterpreter::LBZX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVX(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVX(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVX", &PPUInterpreter::LVX, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::NEG(u32 rd, u32 ra, u32 oe, bool rc) {
+void PPULLVMRecompiler::NEG(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("NEG", &PPUInterpreter::NEG, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::LBZUX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LBZUX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1488,27 +1533,27 @@ void PPULLVMRecompilerWorker::LBZUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LBZUX", &PPUInterpreter::LBZUX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::NOR(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::NOR(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("NOR", &PPUInterpreter::NOR, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::STVEBX(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVEBX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVEBX", &PPUInterpreter::STVEBX, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("SUBFE", &PPUInterpreter::SUBFE, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("ADDE", &PPUInterpreter::ADDE, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::MTOCRF(u32 l, u32 crm, u32 rs) {
+void PPULLVMRecompiler::MTOCRF(u32 l, u32 crm, u32 rs) {
     InterpreterCall("MTOCRF", &PPUInterpreter::MTOCRF, l, crm, rs);
 }
 
-void PPULLVMRecompilerWorker::STDX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STDX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1519,11 +1564,11 @@ void PPULLVMRecompilerWorker::STDX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STDX", &PPUInterpreter::STDX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STWCX_(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STWCX_(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STWCX_", &PPUInterpreter::STWCX_, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STWX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STWX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1534,11 +1579,11 @@ void PPULLVMRecompilerWorker::STWX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STWX", &PPUInterpreter::STWX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STVEHX(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVEHX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVEHX", &PPUInterpreter::STVEHX, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STDUX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STDUX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1548,7 +1593,7 @@ void PPULLVMRecompilerWorker::STDUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STDUX", &PPUInterpreter::STDUX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STWUX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STWUX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1558,23 +1603,23 @@ void PPULLVMRecompilerWorker::STWUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STWUX", &PPUInterpreter::STWUX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STVEWX(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVEWX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVEWX", &PPUInterpreter::STVEWX, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::ADDZE(u32 rd, u32 ra, u32 oe, bool rc) {
+void PPULLVMRecompiler::ADDZE(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("ADDZE", &PPUInterpreter::ADDZE, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) {
+void PPULLVMRecompiler::SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("SUBFZE", &PPUInterpreter::SUBFZE, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::STDCX_(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STDCX_(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STDCX_", &PPUInterpreter::STDCX_, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STBX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STBX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1585,31 +1630,31 @@ void PPULLVMRecompilerWorker::STBX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STBX", &PPUInterpreter::STBX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STVX(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVX", &PPUInterpreter::STVX, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SUBFME(u32 rd, u32 ra, u32 oe, bool rc) {
+void PPULLVMRecompiler::SUBFME(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("SUBFME", &PPUInterpreter::SUBFME, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("MULLD", &PPUInterpreter::MULLD, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::ADDME(u32 rd, u32 ra, u32 oe, bool rc) {
+void PPULLVMRecompiler::ADDME(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("ADDME", &PPUInterpreter::ADDME, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("MULLW", &PPUInterpreter::MULLW, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::DCBTST(u32 ra, u32 rb, u32 th) {
+void PPULLVMRecompiler::DCBTST(u32 ra, u32 rb, u32 th) {
     InterpreterCall("DCBTST", &PPUInterpreter::DCBTST, ra, rb, th);
 }
 
-void PPULLVMRecompilerWorker::STBUX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STBUX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1619,7 +1664,7 @@ void PPULLVMRecompilerWorker::STBUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STBUX", &PPUInterpreter::STBUX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64  = GetGpr(ra);
     auto rb_i64  = GetGpr(rb);
     auto sum_i64 = m_ir_builder->CreateAdd(ra_i64, rb_i64);
@@ -1635,11 +1680,11 @@ void PPULLVMRecompilerWorker::ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("ADD", &PPUInterpreter::ADD, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::DCBT(u32 ra, u32 rb, u32 th) {
+void PPULLVMRecompiler::DCBT(u32 ra, u32 rb, u32 th) {
     InterpreterCall("DCBT", &PPUInterpreter::DCBT, ra, rb, th);
 }
 
-void PPULLVMRecompilerWorker::LHZX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LHZX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1652,15 +1697,15 @@ void PPULLVMRecompilerWorker::LHZX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHZX", &PPUInterpreter::LHZX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::EQV(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::EQV(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("EQV", &PPUInterpreter::EQV, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::ECIWX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::ECIWX(u32 rd, u32 ra, u32 rb) {
     InterpreterCall("ECIWX", &PPUInterpreter::ECIWX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LHZUX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LHZUX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1672,7 +1717,7 @@ void PPULLVMRecompilerWorker::LHZUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHZUX", &PPUInterpreter::LHZUX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::XOR(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::XOR(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto rb_i64  = GetGpr(rb);
     auto res_i64 = m_ir_builder->CreateXor(rs_i64, rb_i64);
@@ -1684,11 +1729,11 @@ void PPULLVMRecompilerWorker::XOR(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("XOR", &PPUInterpreter::XOR, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::MFSPR(u32 rd, u32 spr) {
+void PPULLVMRecompiler::MFSPR(u32 rd, u32 spr) {
     InterpreterCall("MFSPR", &PPUInterpreter::MFSPR, rd, spr);
 }
 
-void PPULLVMRecompilerWorker::LWAX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LWAX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1701,11 +1746,11 @@ void PPULLVMRecompilerWorker::LWAX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWAX", &PPUInterpreter::LWAX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::DST(u32 ra, u32 rb, u32 strm, u32 t) {
+void PPULLVMRecompiler::DST(u32 ra, u32 rb, u32 strm, u32 t) {
     InterpreterCall("DST", &PPUInterpreter::DST, ra, rb, strm, t);
 }
 
-void PPULLVMRecompilerWorker::LHAX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LHAX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1718,15 +1763,15 @@ void PPULLVMRecompilerWorker::LHAX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHAX", &PPUInterpreter::LHAX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVXL(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVXL(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVXL", &PPUInterpreter::LVXL, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::MFTB(u32 rd, u32 spr) {
+void PPULLVMRecompiler::MFTB(u32 rd, u32 spr) {
     InterpreterCall("MFTB", &PPUInterpreter::MFTB, rd, spr);
 }
 
-void PPULLVMRecompilerWorker::LWAUX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LWAUX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1738,11 +1783,11 @@ void PPULLVMRecompilerWorker::LWAUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWAUX", &PPUInterpreter::LWAUX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::DSTST(u32 ra, u32 rb, u32 strm, u32 t) {
+void PPULLVMRecompiler::DSTST(u32 ra, u32 rb, u32 strm, u32 t) {
     InterpreterCall("DSTST", &PPUInterpreter::DSTST, ra, rb, strm, t);
 }
 
-void PPULLVMRecompilerWorker::LHAUX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LHAUX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1754,7 +1799,7 @@ void PPULLVMRecompilerWorker::LHAUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHAUX", &PPUInterpreter::LHAUX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STHX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STHX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1765,15 +1810,15 @@ void PPULLVMRecompilerWorker::STHX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STHX", &PPUInterpreter::STHX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::ORC(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::ORC(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("ORC", &PPUInterpreter::ORC, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::ECOWX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::ECOWX(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("ECOWX", &PPUInterpreter::ECOWX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STHUX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STHUX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -1783,7 +1828,7 @@ void PPULLVMRecompilerWorker::STHUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STHUX", &PPUInterpreter::STHUX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::OR(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::OR(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto rb_i64  = GetGpr(rb);
     auto res_i64 = m_ir_builder->CreateOr(rs_i64, rb_i64);
@@ -1795,39 +1840,39 @@ void PPULLVMRecompilerWorker::OR(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("OR", &PPUInterpreter::OR, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("DIVDU", &PPUInterpreter::DIVDU, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("DIVWU", &PPUInterpreter::DIVWU, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::MTSPR(u32 spr, u32 rs) {
+void PPULLVMRecompiler::MTSPR(u32 spr, u32 rs) {
     InterpreterCall("MTSPR", &PPUInterpreter::MTSPR, spr, rs);
 }
 
-void PPULLVMRecompilerWorker::NAND(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::NAND(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("NAND", &PPUInterpreter::NAND, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::STVXL(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVXL(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVXL", &PPUInterpreter::STVXL, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("DIVD", &PPUInterpreter::DIVD, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void PPULLVMRecompiler::DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("DIVW", &PPUInterpreter::DIVW, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompilerWorker::LVLX(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVLX(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVLX", &PPUInterpreter::LVLX, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LDBRX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LDBRX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1839,11 +1884,11 @@ void PPULLVMRecompilerWorker::LDBRX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDBRX", &PPUInterpreter::LDBRX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LSWX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LSWX(u32 rd, u32 ra, u32 rb) {
     InterpreterCall("LSWX", &PPUInterpreter::LSWX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LWBRX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LWBRX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1856,51 +1901,51 @@ void PPULLVMRecompilerWorker::LWBRX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWBRX", &PPUInterpreter::LWBRX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LFSX(u32 frd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LFSX(u32 frd, u32 ra, u32 rb) {
     InterpreterCall("LFSX", &PPUInterpreter::LFSX, frd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SRW(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::SRW(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("SRW", &PPUInterpreter::SRW, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::SRD(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::SRD(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("SRD", &PPUInterpreter::SRD, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::LVRX(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVRX(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVRX", &PPUInterpreter::LVRX, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LSWI(u32 rd, u32 ra, u32 nb) {
+void PPULLVMRecompiler::LSWI(u32 rd, u32 ra, u32 nb) {
     InterpreterCall("LSWI", &PPUInterpreter::LSWI, rd, ra, nb);
 }
 
-void PPULLVMRecompilerWorker::LFSUX(u32 frd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LFSUX(u32 frd, u32 ra, u32 rb) {
     InterpreterCall("LFSUX", &PPUInterpreter::LFSUX, frd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SYNC(u32 l) {
+void PPULLVMRecompiler::SYNC(u32 l) {
     InterpreterCall("SYNC", &PPUInterpreter::SYNC, l);
 }
 
-void PPULLVMRecompilerWorker::LFDX(u32 frd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LFDX(u32 frd, u32 ra, u32 rb) {
     InterpreterCall("LFDX", &PPUInterpreter::LFDX, frd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LFDUX(u32 frd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LFDUX(u32 frd, u32 ra, u32 rb) {
     InterpreterCall("LFDUX", &PPUInterpreter::LFDUX, frd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STVLX(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVLX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVLX", &PPUInterpreter::STVLX, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STSWX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STSWX(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STSWX", &PPUInterpreter::STSWX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STWBRX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STWBRX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1911,35 +1956,35 @@ void PPULLVMRecompilerWorker::STWBRX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STWBRX", &PPUInterpreter::STWBRX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STFSX(u32 frs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STFSX(u32 frs, u32 ra, u32 rb) {
     InterpreterCall("STFSX", &PPUInterpreter::STFSX, frs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STVRX(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVRX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVRX", &PPUInterpreter::STVRX, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STFSUX(u32 frs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STFSUX(u32 frs, u32 ra, u32 rb) {
     InterpreterCall("STFSUX", &PPUInterpreter::STFSUX, frs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STSWI(u32 rd, u32 ra, u32 nb) {
+void PPULLVMRecompiler::STSWI(u32 rd, u32 ra, u32 nb) {
     InterpreterCall("STSWI", &PPUInterpreter::STSWI, rd, ra, nb);
 }
 
-void PPULLVMRecompilerWorker::STFDX(u32 frs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STFDX(u32 frs, u32 ra, u32 rb) {
     InterpreterCall("STFDX", &PPUInterpreter::STFDX, frs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STFDUX(u32 frs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STFDUX(u32 frs, u32 ra, u32 rb) {
     InterpreterCall("STFDUX", &PPUInterpreter::STFDUX, frs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LVLXL(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVLXL(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVLXL", &PPUInterpreter::LVLXL, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LHBRX(u32 rd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LHBRX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1952,47 +1997,47 @@ void PPULLVMRecompilerWorker::LHBRX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHBRX", &PPUInterpreter::LHBRX, rd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::SRAW(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::SRAW(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("SRAW", &PPUInterpreter::SRAW, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::SRAD(u32 ra, u32 rs, u32 rb, bool rc) {
+void PPULLVMRecompiler::SRAD(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("SRAD", &PPUInterpreter::SRAD, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompilerWorker::LVRXL(u32 vd, u32 ra, u32 rb) {
+void PPULLVMRecompiler::LVRXL(u32 vd, u32 ra, u32 rb) {
     InterpreterCall("LVRXL", &PPUInterpreter::LVRXL, vd, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::DSS(u32 strm, u32 a) {
+void PPULLVMRecompiler::DSS(u32 strm, u32 a) {
     InterpreterCall("DSS", &PPUInterpreter::DSS, strm, a);
 }
 
-void PPULLVMRecompilerWorker::SRAWI(u32 ra, u32 rs, u32 sh, bool rc) {
+void PPULLVMRecompiler::SRAWI(u32 ra, u32 rs, u32 sh, bool rc) {
     InterpreterCall("SRAWI", &PPUInterpreter::SRAWI, ra, rs, sh, rc);
 }
 
-void PPULLVMRecompilerWorker::SRADI1(u32 ra, u32 rs, u32 sh, bool rc) {
+void PPULLVMRecompiler::SRADI1(u32 ra, u32 rs, u32 sh, bool rc) {
     InterpreterCall("SRADI1", &PPUInterpreter::SRADI1, ra, rs, sh, rc);
 }
 
-void PPULLVMRecompilerWorker::SRADI2(u32 ra, u32 rs, u32 sh, bool rc) {
+void PPULLVMRecompiler::SRADI2(u32 ra, u32 rs, u32 sh, bool rc) {
     InterpreterCall("SRADI2", &PPUInterpreter::SRADI2, ra, rs, sh, rc);
 }
 
-void PPULLVMRecompilerWorker::EIEIO() {
+void PPULLVMRecompiler::EIEIO() {
     InterpreterCall("EIEIO", &PPUInterpreter::EIEIO);
 }
 
-void PPULLVMRecompilerWorker::STVLXL(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVLXL(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVLXL", &PPUInterpreter::STVLXL, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::STHBRX(u32 rs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STHBRX(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STHBRX", &PPUInterpreter::STHBRX, rs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::EXTSH(u32 ra, u32 rs, bool rc) {
+void PPULLVMRecompiler::EXTSH(u32 ra, u32 rs, bool rc) {
     auto rs_i16 = GetGpr(rs, 16);
     auto rs_i64 = m_ir_builder->CreateSExt(rs_i16, m_ir_builder->getInt64Ty());
     SetGpr(ra, rs_i64);
@@ -2003,11 +2048,11 @@ void PPULLVMRecompilerWorker::EXTSH(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("EXTSH", &PPUInterpreter::EXTSH, ra, rs, rc);
 }
 
-void PPULLVMRecompilerWorker::STVRXL(u32 vs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STVRXL(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVRXL", &PPUInterpreter::STVRXL, vs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::EXTSB(u32 ra, u32 rs, bool rc) {
+void PPULLVMRecompiler::EXTSB(u32 ra, u32 rs, bool rc) {
     auto rs_i8  = GetGpr(rs, 8);
     auto rs_i64 = m_ir_builder->CreateSExt(rs_i8, m_ir_builder->getInt64Ty());
     SetGpr(ra, rs_i64);
@@ -2018,11 +2063,11 @@ void PPULLVMRecompilerWorker::EXTSB(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("EXTSB", &PPUInterpreter::EXTSB, ra, rs, rc);
 }
 
-void PPULLVMRecompilerWorker::STFIWX(u32 frs, u32 ra, u32 rb) {
+void PPULLVMRecompiler::STFIWX(u32 frs, u32 ra, u32 rb) {
     InterpreterCall("STFIWX", &PPUInterpreter::STFIWX, frs, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::EXTSW(u32 ra, u32 rs, bool rc) {
+void PPULLVMRecompiler::EXTSW(u32 ra, u32 rs, bool rc) {
     auto rs_i32 = GetGpr(rs, 32);
     auto rs_i64 = m_ir_builder->CreateSExt(rs_i32, m_ir_builder->getInt64Ty());
     SetGpr(ra, rs_i64);
@@ -2033,15 +2078,15 @@ void PPULLVMRecompilerWorker::EXTSW(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("EXTSW", &PPUInterpreter::EXTSW, ra, rs, rc);
 }
 
-void PPULLVMRecompilerWorker::ICBI(u32 ra, u32 rs) {
+void PPULLVMRecompiler::ICBI(u32 ra, u32 rs) {
     InterpreterCall("ICBI", &PPUInterpreter::ICBI, ra, rs);
 }
 
-void PPULLVMRecompilerWorker::DCBZ(u32 ra, u32 rb) {
+void PPULLVMRecompiler::DCBZ(u32 ra, u32 rb) {
     InterpreterCall("DCBZ", &PPUInterpreter::DCBZ, ra, rb);
 }
 
-void PPULLVMRecompilerWorker::LWZ(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LWZ(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2054,7 +2099,7 @@ void PPULLVMRecompilerWorker::LWZ(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LWZ", &PPUInterpreter::LWZ, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LWZU(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LWZU(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2066,7 +2111,7 @@ void PPULLVMRecompilerWorker::LWZU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LWZU", &PPUInterpreter::LWZU, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LBZ(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LBZ(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2079,7 +2124,7 @@ void PPULLVMRecompilerWorker::LBZ(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LBZ", &PPUInterpreter::LBZ, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LBZU(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LBZU(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2091,7 +2136,7 @@ void PPULLVMRecompilerWorker::LBZU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LBZU", &PPUInterpreter::LBZU, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STW(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STW(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2102,7 +2147,7 @@ void PPULLVMRecompilerWorker::STW(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STW", &PPUInterpreter::STW, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STWU(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STWU(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2112,7 +2157,7 @@ void PPULLVMRecompilerWorker::STWU(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STWU", &PPUInterpreter::STWU, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STB(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STB(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2123,7 +2168,7 @@ void PPULLVMRecompilerWorker::STB(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STB", &PPUInterpreter::STB, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STBU(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STBU(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2133,7 +2178,7 @@ void PPULLVMRecompilerWorker::STBU(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STBU", &PPUInterpreter::STBU, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LHZ(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LHZ(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2146,7 +2191,7 @@ void PPULLVMRecompilerWorker::LHZ(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHZ", &PPUInterpreter::LHZ, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LHZU(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LHZU(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2158,7 +2203,7 @@ void PPULLVMRecompilerWorker::LHZU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHZU", &PPUInterpreter::LHZU, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LHA(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LHA(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2171,7 +2216,7 @@ void PPULLVMRecompilerWorker::LHA(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHA", &PPUInterpreter::LHA, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LHAU(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LHAU(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2183,7 +2228,7 @@ void PPULLVMRecompilerWorker::LHAU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHAU", &PPUInterpreter::LHAU, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STH(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STH(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2194,7 +2239,7 @@ void PPULLVMRecompilerWorker::STH(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STH", &PPUInterpreter::STH, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STHU(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STHU(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2204,47 +2249,47 @@ void PPULLVMRecompilerWorker::STHU(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STHU", &PPUInterpreter::STHU, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LMW(u32 rd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LMW(u32 rd, u32 ra, s32 d) {
     InterpreterCall("LMW", &PPUInterpreter::LMW, rd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STMW(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STMW(u32 rs, u32 ra, s32 d) {
     InterpreterCall("STMW", &PPUInterpreter::STMW, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LFS(u32 frd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LFS(u32 frd, u32 ra, s32 d) {
     InterpreterCall("LFS", &PPUInterpreter::LFS, frd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LFSU(u32 frd, u32 ra, s32 ds) {
+void PPULLVMRecompiler::LFSU(u32 frd, u32 ra, s32 ds) {
     InterpreterCall("LFSU", &PPUInterpreter::LFSU, frd, ra, ds);
 }
 
-void PPULLVMRecompilerWorker::LFD(u32 frd, u32 ra, s32 d) {
+void PPULLVMRecompiler::LFD(u32 frd, u32 ra, s32 d) {
     InterpreterCall("LFD", &PPUInterpreter::LFD, frd, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LFDU(u32 frd, u32 ra, s32 ds) {
+void PPULLVMRecompiler::LFDU(u32 frd, u32 ra, s32 ds) {
     InterpreterCall("LFDU", &PPUInterpreter::LFDU, frd, ra, ds);
 }
 
-void PPULLVMRecompilerWorker::STFS(u32 frs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STFS(u32 frs, u32 ra, s32 d) {
     InterpreterCall("STFS", &PPUInterpreter::STFS, frs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STFSU(u32 frs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STFSU(u32 frs, u32 ra, s32 d) {
     InterpreterCall("STFSU", &PPUInterpreter::STFSU, frs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STFD(u32 frs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STFD(u32 frs, u32 ra, s32 d) {
     InterpreterCall("STFD", &PPUInterpreter::STFD, frs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STFDU(u32 frs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STFDU(u32 frs, u32 ra, s32 d) {
     InterpreterCall("STFDU", &PPUInterpreter::STFDU, frs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::LD(u32 rd, u32 ra, s32 ds) {
+void PPULLVMRecompiler::LD(u32 rd, u32 ra, s32 ds) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)ds);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2256,7 +2301,7 @@ void PPULLVMRecompilerWorker::LD(u32 rd, u32 ra, s32 ds) {
     //InterpreterCall("LD", &PPUInterpreter::LD, rd, ra, ds);
 }
 
-void PPULLVMRecompilerWorker::LDU(u32 rd, u32 ra, s32 ds) {
+void PPULLVMRecompiler::LDU(u32 rd, u32 ra, s32 ds) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)ds);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2267,7 +2312,7 @@ void PPULLVMRecompilerWorker::LDU(u32 rd, u32 ra, s32 ds) {
     //InterpreterCall("LDU", &PPUInterpreter::LDU, rd, ra, ds);
 }
 
-void PPULLVMRecompilerWorker::LWA(u32 rd, u32 ra, s32 ds) {
+void PPULLVMRecompiler::LWA(u32 rd, u32 ra, s32 ds) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)ds);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2280,47 +2325,47 @@ void PPULLVMRecompilerWorker::LWA(u32 rd, u32 ra, s32 ds) {
     //InterpreterCall("LWA", &PPUInterpreter::LWA, rd, ra, ds);
 }
 
-void PPULLVMRecompilerWorker::FDIVS(u32 frd, u32 fra, u32 frb, bool rc) {
+void PPULLVMRecompiler::FDIVS(u32 frd, u32 fra, u32 frb, bool rc) {
     InterpreterCall("FDIVS", &PPUInterpreter::FDIVS, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FSUBS(u32 frd, u32 fra, u32 frb, bool rc) {
+void PPULLVMRecompiler::FSUBS(u32 frd, u32 fra, u32 frb, bool rc) {
     InterpreterCall("FSUBS", &PPUInterpreter::FSUBS, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FADDS(u32 frd, u32 fra, u32 frb, bool rc) {
+void PPULLVMRecompiler::FADDS(u32 frd, u32 fra, u32 frb, bool rc) {
     InterpreterCall("FADDS", &PPUInterpreter::FADDS, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FSQRTS(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FSQRTS(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FSQRTS", &PPUInterpreter::FSQRTS, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FRES(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FRES(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FRES", &PPUInterpreter::FRES, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FMULS(u32 frd, u32 fra, u32 frc, bool rc) {
+void PPULLVMRecompiler::FMULS(u32 frd, u32 fra, u32 frc, bool rc) {
     InterpreterCall("FMULS", &PPUInterpreter::FMULS, frd, fra, frc, rc);
 }
 
-void PPULLVMRecompilerWorker::FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FMADDS", &PPUInterpreter::FMADDS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FMSUBS", &PPUInterpreter::FMSUBS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FNMSUBS", &PPUInterpreter::FNMSUBS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FNMADDS", &PPUInterpreter::FNMADDS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::STD(u32 rs, u32 ra, s32 d) {
+void PPULLVMRecompiler::STD(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2331,7 +2376,7 @@ void PPULLVMRecompilerWorker::STD(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STD", &PPUInterpreter::STD, rs, ra, d);
 }
 
-void PPULLVMRecompilerWorker::STDU(u32 rs, u32 ra, s32 ds) {
+void PPULLVMRecompiler::STDU(u32 rs, u32 ra, s32 ds) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)ds);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -2341,144 +2386,144 @@ void PPULLVMRecompilerWorker::STDU(u32 rs, u32 ra, s32 ds) {
     //InterpreterCall("STDU", &PPUInterpreter::STDU, rs, ra, ds);
 }
 
-void PPULLVMRecompilerWorker::MTFSB1(u32 crbd, bool rc) {
+void PPULLVMRecompiler::MTFSB1(u32 crbd, bool rc) {
     InterpreterCall("MTFSB1", &PPUInterpreter::MTFSB1, crbd, rc);
 }
 
-void PPULLVMRecompilerWorker::MCRFS(u32 crbd, u32 crbs) {
+void PPULLVMRecompiler::MCRFS(u32 crbd, u32 crbs) {
     InterpreterCall("MCRFS", &PPUInterpreter::MCRFS, crbd, crbs);
 }
 
-void PPULLVMRecompilerWorker::MTFSB0(u32 crbd, bool rc) {
+void PPULLVMRecompiler::MTFSB0(u32 crbd, bool rc) {
     InterpreterCall("MTFSB0", &PPUInterpreter::MTFSB0, crbd, rc);
 }
 
-void PPULLVMRecompilerWorker::MTFSFI(u32 crfd, u32 i, bool rc) {
+void PPULLVMRecompiler::MTFSFI(u32 crfd, u32 i, bool rc) {
     InterpreterCall("MTFSFI", &PPUInterpreter::MTFSFI, crfd, i, rc);
 }
 
-void PPULLVMRecompilerWorker::MFFS(u32 frd, bool rc) {
+void PPULLVMRecompiler::MFFS(u32 frd, bool rc) {
     InterpreterCall("MFFS", &PPUInterpreter::MFFS, frd, rc);
 }
 
-void PPULLVMRecompilerWorker::MTFSF(u32 flm, u32 frb, bool rc) {
+void PPULLVMRecompiler::MTFSF(u32 flm, u32 frb, bool rc) {
     InterpreterCall("MTFSF", &PPUInterpreter::MTFSF, flm, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCMPU(u32 crfd, u32 fra, u32 frb) {
+void PPULLVMRecompiler::FCMPU(u32 crfd, u32 fra, u32 frb) {
     InterpreterCall("FCMPU", &PPUInterpreter::FCMPU, crfd, fra, frb);
 }
 
-void PPULLVMRecompilerWorker::FRSP(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FRSP(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FRSP", &PPUInterpreter::FRSP, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCTIW(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FCTIW(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTIW", &PPUInterpreter::FCTIW, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCTIWZ(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FCTIWZ(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTIWZ", &PPUInterpreter::FCTIWZ, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FDIV(u32 frd, u32 fra, u32 frb, bool rc) {
+void PPULLVMRecompiler::FDIV(u32 frd, u32 fra, u32 frb, bool rc) {
     InterpreterCall("FDIV", &PPUInterpreter::FDIV, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FSUB(u32 frd, u32 fra, u32 frb, bool rc) {
+void PPULLVMRecompiler::FSUB(u32 frd, u32 fra, u32 frb, bool rc) {
     InterpreterCall("FSUB", &PPUInterpreter::FSUB, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FADD(u32 frd, u32 fra, u32 frb, bool rc) {
+void PPULLVMRecompiler::FADD(u32 frd, u32 fra, u32 frb, bool rc) {
     InterpreterCall("FADD", &PPUInterpreter::FADD, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FSQRT(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FSQRT(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FSQRT", &PPUInterpreter::FSQRT, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FSEL", &PPUInterpreter::FSEL, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FMUL(u32 frd, u32 fra, u32 frc, bool rc) {
+void PPULLVMRecompiler::FMUL(u32 frd, u32 fra, u32 frc, bool rc) {
     InterpreterCall("FMUL", &PPUInterpreter::FMUL, frd, fra, frc, rc);
 }
 
-void PPULLVMRecompilerWorker::FRSQRTE(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FRSQRTE(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FRSQRTE", &PPUInterpreter::FRSQRTE, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FMSUB", &PPUInterpreter::FMSUB, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FMADD", &PPUInterpreter::FMADD, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FNMSUB", &PPUInterpreter::FNMSUB, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void PPULLVMRecompiler::FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FNMADD", &PPUInterpreter::FNMADD, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCMPO(u32 crfd, u32 fra, u32 frb) {
+void PPULLVMRecompiler::FCMPO(u32 crfd, u32 fra, u32 frb) {
     InterpreterCall("FCMPO", &PPUInterpreter::FCMPO, crfd, fra, frb);
 }
 
-void PPULLVMRecompilerWorker::FNEG(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FNEG(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FNEG", &PPUInterpreter::FNEG, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FMR(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FMR(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FMR", &PPUInterpreter::FMR, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FNABS(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FNABS(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FNABS", &PPUInterpreter::FNABS, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FABS(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FABS(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FABS", &PPUInterpreter::FABS, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCTID(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FCTID(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTID", &PPUInterpreter::FCTID, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCTIDZ(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FCTIDZ(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTIDZ", &PPUInterpreter::FCTIDZ, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::FCFID(u32 frd, u32 frb, bool rc) {
+void PPULLVMRecompiler::FCFID(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCFID", &PPUInterpreter::FCFID, frd, frb, rc);
 }
 
-void PPULLVMRecompilerWorker::UNK(const u32 code, const u32 opcode, const u32 gcode) {
+void PPULLVMRecompiler::UNK(const u32 code, const u32 opcode, const u32 gcode) {
     //InterpreterCall("UNK", &PPUInterpreter::UNK, code, opcode, gcode);
 }
 
-Value * PPULLVMRecompilerWorker::GetPPUState() {
+Value * PPULLVMRecompiler::GetPPUState() {
     return m_function->arg_begin();
 }
 
-Value * PPULLVMRecompilerWorker::GetBaseAddress() {
+Value * PPULLVMRecompiler::GetBaseAddress() {
     auto i = m_function->arg_begin();
     i++;
     return i;
 }
 
-Value * PPULLVMRecompilerWorker::GetInterpreter() {
+Value * PPULLVMRecompiler::GetInterpreter() {
     auto i = m_function->arg_begin();
     i++;
     i++;
     return i;
 }
 
-Value * PPULLVMRecompilerWorker::GetBit(Value * val, u32 n) {
+Value * PPULLVMRecompiler::GetBit(Value * val, u32 n) {
     Value * bit;
 
     if (val->getType()->isIntegerTy(32)) {
@@ -2496,11 +2541,11 @@ Value * PPULLVMRecompilerWorker::GetBit(Value * val, u32 n) {
     return bit;
 }
 
-Value * PPULLVMRecompilerWorker::ClrBit(Value * val, u32 n) {
+Value * PPULLVMRecompiler::ClrBit(Value * val, u32 n) {
     return m_ir_builder->CreateAnd(val, ~((u64)1 << (val->getType()->getIntegerBitWidth() - n - 1)));
 }
 
-Value * PPULLVMRecompilerWorker::SetBit(Value * val, u32 n, Value * bit, bool doClear) {
+Value * PPULLVMRecompiler::SetBit(Value * val, u32 n, Value * bit, bool doClear) {
     if (doClear) {
         val = ClrBit(val, n);
     }
@@ -2518,7 +2563,7 @@ Value * PPULLVMRecompilerWorker::SetBit(Value * val, u32 n, Value * bit, bool do
     return m_ir_builder->CreateOr(val, bit);
 }
 
-Value * PPULLVMRecompilerWorker::GetNibble(Value * val, u32 n) {
+Value * PPULLVMRecompiler::GetNibble(Value * val, u32 n) {
     Value * nibble;
 
     if (val->getType()->isIntegerTy(32)) {
@@ -2536,11 +2581,11 @@ Value * PPULLVMRecompilerWorker::GetNibble(Value * val, u32 n) {
     return nibble;
 }
 
-Value * PPULLVMRecompilerWorker::ClrNibble(Value * val, u32 n) {
+Value * PPULLVMRecompiler::ClrNibble(Value * val, u32 n) {
     return m_ir_builder->CreateAnd(val, ~((u64)0xF << ((((val->getType()->getIntegerBitWidth() >> 2) - 1) - n) * 4)));
 }
 
-Value * PPULLVMRecompilerWorker::SetNibble(Value * val, u32 n, Value * nibble, bool doClear) {
+Value * PPULLVMRecompiler::SetNibble(Value * val, u32 n, Value * nibble, bool doClear) {
     if (doClear) {
         val = ClrNibble(val, n);
     }
@@ -2558,7 +2603,7 @@ Value * PPULLVMRecompilerWorker::SetNibble(Value * val, u32 n, Value * nibble, b
     return m_ir_builder->CreateOr(val, nibble);
 }
 
-Value * PPULLVMRecompilerWorker::SetNibble(Value * val, u32 n, Value * b0, Value * b1, Value * b2, Value * b3, bool doClear) {
+Value * PPULLVMRecompiler::SetNibble(Value * val, u32 n, Value * b0, Value * b1, Value * b2, Value * b3, bool doClear) {
     if (doClear) {
         val = ClrNibble(val, n);
     }
@@ -2582,57 +2627,57 @@ Value * PPULLVMRecompilerWorker::SetNibble(Value * val, u32 n, Value * b0, Value
     return val;
 }
 
-Value * PPULLVMRecompilerWorker::GetPc() {
-    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, PC));
+Value * PPULLVMRecompiler::GetPc() {
+    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, PC));
     auto pc_i64_ptr = m_ir_builder->CreateBitCast(pc_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     return m_ir_builder->CreateLoad(pc_i64_ptr);
 }
 
-void PPULLVMRecompilerWorker::SetPc(Value * val_i64) {
-    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, PC));
+void PPULLVMRecompiler::SetPc(Value * val_i64) {
+    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, PC));
     auto pc_i64_ptr = m_ir_builder->CreateBitCast(pc_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateStore(val_i64, pc_i64_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetGpr(u32 r, u32 num_bits) {
-    auto r_i8_ptr = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, GPR[r]));
+Value * PPULLVMRecompiler::GetGpr(u32 r, u32 num_bits) {
+    auto r_i8_ptr = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, GPR[r]));
     auto r_ix_ptr = m_ir_builder->CreateBitCast(r_i8_ptr, m_ir_builder->getIntNTy(num_bits)->getPointerTo());
     return m_ir_builder->CreateLoad(r_ix_ptr);
 }
 
-void PPULLVMRecompilerWorker::SetGpr(u32 r, Value * val_x64) {
-    auto r_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, GPR[r]));
+void PPULLVMRecompiler::SetGpr(u32 r, Value * val_x64) {
+    auto r_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, GPR[r]));
     auto r_i64_ptr = m_ir_builder->CreateBitCast(r_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     auto val_i64   = m_ir_builder->CreateBitCast(val_x64, m_ir_builder->getInt64Ty());
     m_ir_builder->CreateStore(val_i64, r_i64_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetCr() {
-    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, CR));
+Value * PPULLVMRecompiler::GetCr() {
+    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, CR));
     auto cr_i32_ptr = m_ir_builder->CreateBitCast(cr_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     return m_ir_builder->CreateLoad(cr_i32_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetCrField(u32 n) {
+Value * PPULLVMRecompiler::GetCrField(u32 n) {
     return GetNibble(GetCr(), n);
 }
 
-void PPULLVMRecompilerWorker::SetCr(Value * val_x32) {
+void PPULLVMRecompiler::SetCr(Value * val_x32) {
     auto val_i32    = m_ir_builder->CreateBitCast(val_x32, m_ir_builder->getInt32Ty());
-    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, CR));
+    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, CR));
     auto cr_i32_ptr = m_ir_builder->CreateBitCast(cr_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     m_ir_builder->CreateStore(val_i32, cr_i32_ptr);
 }
 
-void PPULLVMRecompilerWorker::SetCrField(u32 n, Value * field) {
+void PPULLVMRecompiler::SetCrField(u32 n, Value * field) {
     SetCr(SetNibble(GetCr(), n, field));
 }
 
-void PPULLVMRecompilerWorker::SetCrField(u32 n, Value * b0, Value * b1, Value * b2, Value * b3) {
+void PPULLVMRecompiler::SetCrField(u32 n, Value * b0, Value * b1, Value * b2, Value * b3) {
     SetCr(SetNibble(GetCr(), n, b0, b1, b2, b3));
 }
 
-void PPULLVMRecompilerWorker::SetCrFieldSignedCmp(u32 n, Value * a, Value * b) {
+void PPULLVMRecompiler::SetCrFieldSignedCmp(u32 n, Value * a, Value * b) {
     auto lt_i1  = m_ir_builder->CreateICmpSLT(a, b);
     auto gt_i1  = m_ir_builder->CreateICmpSGT(a, b);
     auto eq_i1  = m_ir_builder->CreateICmpEQ(a, b);
@@ -2641,7 +2686,7 @@ void PPULLVMRecompilerWorker::SetCrFieldSignedCmp(u32 n, Value * a, Value * b) {
     SetCr(cr_i32);
 }
 
-void PPULLVMRecompilerWorker::SetCrFieldUnsignedCmp(u32 n, Value * a, Value * b) {
+void PPULLVMRecompiler::SetCrFieldUnsignedCmp(u32 n, Value * a, Value * b) {
     auto lt_i1  = m_ir_builder->CreateICmpULT(a, b);
     auto gt_i1  = m_ir_builder->CreateICmpUGT(a, b);
     auto eq_i1  = m_ir_builder->CreateICmpEQ(a, b);
@@ -2650,7 +2695,7 @@ void PPULLVMRecompilerWorker::SetCrFieldUnsignedCmp(u32 n, Value * a, Value * b)
     SetCr(cr_i32);
 }
 
-void PPULLVMRecompilerWorker::SetCr6AfterVectorCompare(u32 vr) {
+void PPULLVMRecompiler::SetCr6AfterVectorCompare(u32 vr) {
     auto vr_v16i8    = GetVrAsIntVec(vr, 8);
     auto vr_mask_i32 = m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pmovmskb_128), vr_v16i8);
     auto cmp0_i1     = m_ir_builder->CreateICmpEQ(vr_mask_i32, m_ir_builder->getInt32(0));
@@ -2660,81 +2705,81 @@ void PPULLVMRecompilerWorker::SetCr6AfterVectorCompare(u32 vr) {
     SetCr(cr_i32);
 }
 
-Value * PPULLVMRecompilerWorker::GetXer() {
-    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, XER));
+Value * PPULLVMRecompiler::GetXer() {
+    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, XER));
     auto xer_i64_ptr = m_ir_builder->CreateBitCast(xer_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     return m_ir_builder->CreateLoad(xer_i64_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetXerCa() {
+Value * PPULLVMRecompiler::GetXerCa() {
     return GetBit(GetXer(), 34);
 }
 
-Value * PPULLVMRecompilerWorker::GetXerSo() {
+Value * PPULLVMRecompiler::GetXerSo() {
     return GetBit(GetXer(), 32);
 }
 
-void PPULLVMRecompilerWorker::SetXer(Value * val_x64) {
+void PPULLVMRecompiler::SetXer(Value * val_x64) {
     auto val_i64     = m_ir_builder->CreateBitCast(val_x64, m_ir_builder->getInt64Ty());
-    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, XER));
+    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, XER));
     auto xer_i64_ptr = m_ir_builder->CreateBitCast(xer_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateStore(val_i64, xer_i64_ptr);
 }
 
-void PPULLVMRecompilerWorker::SetXerCa(Value * ca) {
+void PPULLVMRecompiler::SetXerCa(Value * ca) {
     auto xer_i64 = GetXer();
     xer_i64      = SetBit(xer_i64, 34, ca);
     SetXer(xer_i64);
 }
 
-void PPULLVMRecompilerWorker::SetXerSo(Value * so) {
+void PPULLVMRecompiler::SetXerSo(Value * so) {
     auto xer_i64 = GetXer();
     xer_i64      = SetBit(xer_i64, 32, so);
     SetXer(xer_i64);
 }
 
-Value * PPULLVMRecompilerWorker::GetVscr() {
-    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, VSCR));
+Value * PPULLVMRecompiler::GetVscr() {
+    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VSCR));
     auto vscr_i32_ptr = m_ir_builder->CreateBitCast(vscr_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     return m_ir_builder->CreateLoad(vscr_i32_ptr);
 }
 
-void PPULLVMRecompilerWorker::SetVscr(Value * val_x32) {
+void PPULLVMRecompiler::SetVscr(Value * val_x32) {
     auto val_i32      = m_ir_builder->CreateBitCast(val_x32, m_ir_builder->getInt32Ty());
-    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, VSCR));
+    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VSCR));
     auto vscr_i32_ptr = m_ir_builder->CreateBitCast(vscr_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     m_ir_builder->CreateStore(val_i32, vscr_i32_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetVrAsIntVec(u32 vr, u32 vec_elt_num_bits) {
-    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, VPR[vr]));
+Value * PPULLVMRecompiler::GetVrAsIntVec(u32 vr, u32 vec_elt_num_bits) {
+    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
     auto vr_i128_ptr = m_ir_builder->CreateBitCast(vr_i8_ptr, m_ir_builder->getIntNTy(128)->getPointerTo());
     auto vr_vec_ptr  = m_ir_builder->CreateBitCast(vr_i128_ptr, VectorType::get(m_ir_builder->getIntNTy(vec_elt_num_bits), 128 / vec_elt_num_bits)->getPointerTo());
     return m_ir_builder->CreateLoad(vr_vec_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetVrAsFloatVec(u32 vr) {
-    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, VPR[vr]));
+Value * PPULLVMRecompiler::GetVrAsFloatVec(u32 vr) {
+    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
     auto vr_i128_ptr  = m_ir_builder->CreateBitCast(vr_i8_ptr, m_ir_builder->getIntNTy(128)->getPointerTo());
     auto vr_v4f32_ptr = m_ir_builder->CreateBitCast(vr_i128_ptr, VectorType::get(m_ir_builder->getFloatTy(), 4)->getPointerTo());
     return m_ir_builder->CreateLoad(vr_v4f32_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::GetVrAsDoubleVec(u32 vr) {
-    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, VPR[vr]));
+Value * PPULLVMRecompiler::GetVrAsDoubleVec(u32 vr) {
+    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
     auto vr_i128_ptr  = m_ir_builder->CreateBitCast(vr_i8_ptr, m_ir_builder->getIntNTy(128)->getPointerTo());
     auto vr_v2f64_ptr = m_ir_builder->CreateBitCast(vr_i128_ptr, VectorType::get(m_ir_builder->getDoubleTy(), 2)->getPointerTo());
     return m_ir_builder->CreateLoad(vr_v2f64_ptr);
 }
 
-void PPULLVMRecompilerWorker::SetVr(u32 vr, Value * val_x128) {
-    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUState(), offsetof(PPUThread, VPR[vr]));
+void PPULLVMRecompiler::SetVr(u32 vr, Value * val_x128) {
+    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
     auto vr_i128_ptr = m_ir_builder->CreateBitCast(vr_i8_ptr, m_ir_builder->getIntNTy(128)->getPointerTo());
     auto val_i128    = m_ir_builder->CreateBitCast(val_x128, m_ir_builder->getIntNTy(128));
     m_ir_builder->CreateStore(val_i128, vr_i128_ptr);
 }
 
-Value * PPULLVMRecompilerWorker::ReadMemory(Value * addr_i64, u32 bits, bool bswap) {
+Value * PPULLVMRecompiler::ReadMemory(Value * addr_i64, u32 bits, bool bswap) {
     if (bits != 32) {
         auto eaddr_i64    = m_ir_builder->CreateAdd(addr_i64, GetBaseAddress());
         auto eaddr_ix_ptr = m_ir_builder->CreateIntToPtr(eaddr_i64, m_ir_builder->getIntNTy(bits)->getPointerTo());
@@ -2780,7 +2825,7 @@ Value * PPULLVMRecompilerWorker::ReadMemory(Value * addr_i64, u32 bits, bool bsw
     }
 }
 
-void PPULLVMRecompilerWorker::WriteMemory(Value * addr_i64, Value * val_ix, bool bswap) {
+void PPULLVMRecompiler::WriteMemory(Value * addr_i64, Value * val_ix, bool bswap) {
     if (val_ix->getType()->getIntegerBitWidth() != 32) {
         if (val_ix->getType()->getIntegerBitWidth() > 8 && bswap) {
             val_ix = m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::bswap, {val_ix->getType()}), val_ix);
@@ -2825,7 +2870,7 @@ void PPULLVMRecompilerWorker::WriteMemory(Value * addr_i64, Value * val_ix, bool
 }
 
 template<class Func, class... Args>
-Value * PPULLVMRecompilerWorker::InterpreterCall(const char * name, Func function, Args... args) {
+Value * PPULLVMRecompiler::InterpreterCall(const char * name, Func function, Args... args) {
     auto i = m_interpreter_fallback_stats.find(name);
     if (i == m_interpreter_fallback_stats.end()) {
         i = m_interpreter_fallback_stats.insert(m_interpreter_fallback_stats.end(), std::make_pair<std::string, u64>(name, 0));
@@ -2837,7 +2882,7 @@ Value * PPULLVMRecompilerWorker::InterpreterCall(const char * name, Func functio
 }
 
 template<class T>
-Type * PPULLVMRecompilerWorker::CppToLlvmType() {
+Type * PPULLVMRecompiler::CppToLlvmType() {
     if (std::is_void<T>::value) {
         return m_ir_builder->getVoidTy();
     } else if (std::is_same<T, long long>::value || std::is_same<T, unsigned long long>::value) {
@@ -2862,7 +2907,7 @@ Type * PPULLVMRecompilerWorker::CppToLlvmType() {
 }
 
 template<class Func, class... Args>
-Value * PPULLVMRecompilerWorker::Call(const char * name, Func function, Args... args) {
+Value * PPULLVMRecompiler::Call(const char * name, Func function, Args... args) {
     typedef std::result_of<Func(Args...)>::type ReturnType;
 
     auto fn = m_module->getFunction(name);
@@ -2878,19 +2923,47 @@ Value * PPULLVMRecompilerWorker::Call(const char * name, Func function, Args...
     return m_ir_builder->CreateCall(fn, fn_args);
 }
 
-PPULLVMRecompiler::PPULLVMRecompiler(PPUThread & ppu)
+u32                 PPULLVMEmulator::s_num_instances    = 0;
+std::mutex          PPULLVMEmulator::s_recompiler_mutex;
+PPULLVMRecompiler * PPULLVMEmulator::s_recompiler       = nullptr;
+
+PPULLVMEmulator::PPULLVMEmulator(PPUThread & ppu)
     : m_ppu(ppu)
-    , m_interpreter(ppu) {
-    //m_worker.RunAllTests(&m_ppu, (u64)Memory.GetBaseAddr(), &m_interpreter);
+    , m_interpreter(new PPUInterpreter(ppu))
+    , m_decoder(m_interpreter) {
+    std::lock_guard<std::mutex> lock(s_recompiler_mutex);
+
+    s_num_instances++;
+    if (!s_recompiler) {
+        s_recompiler = new PPULLVMRecompiler();
+        //s_recompiler->RunAllTests(&m_ppu, (u64)Memory.GetBaseAddr(), m_interpreter);
+    }
 }
 
-PPULLVMRecompiler::~PPULLVMRecompiler() {
+PPULLVMEmulator::~PPULLVMEmulator() {
+    std::lock_guard<std::mutex> lock(s_recompiler_mutex);
 
+    s_num_instances--;
+    if (s_recompiler && s_num_instances == 0) {
+        delete s_recompiler;
+        s_recompiler = nullptr;
+    }
 }
 
-u8 PPULLVMRecompiler::DecodeMemory(const u64 address) {
-    m_worker.Compile(address);
-    auto fn = m_worker.GetCompiledBlock(address);
-    fn(&m_ppu, (u64)Memory.GetBaseAddr(), &m_interpreter);
-    return 0;
+u8 PPULLVMEmulator::DecodeMemory(const u64 address) {
+    static u64 last_instr_address = 0;
+
+    PPULLVMRecompiler::CompiledBlock compiled_block = nullptr;
+    if (address != (last_instr_address + 4)) {
+        compiled_block = s_recompiler->GetCompiledBlock(address);
+    }
+
+    last_instr_address = address;
+
+    if (compiled_block) {
+        compiled_block(&m_ppu, (u64)Memory.GetBaseAddr(), m_interpreter);
+        return 0;
+    } else {
+        return m_decoder.DecodeMemory(address);
+    }
 }
diff --git a/rpcs3/Emu/Cell/PPULLVMRecompiler.h b/rpcs3/Emu/Cell/PPULLVMRecompiler.h
index f02e84cb0c..371a663a20 100644
--- a/rpcs3/Emu/Cell/PPULLVMRecompiler.h
+++ b/rpcs3/Emu/Cell/PPULLVMRecompiler.h
@@ -13,31 +13,33 @@
 
 struct PPURegState;
 
-/// PPU recompiler
-class PPULLVMRecompilerWorker : protected PPUOpcodes {
+/// PPU to LLVM recompiler
+class PPULLVMRecompiler : public ThreadBase, protected PPUOpcodes {
 public:
     typedef void(*CompiledBlock)(PPUThread * ppu_state, u64 base_address, PPUInterpreter * interpreter);
 
-    PPULLVMRecompilerWorker();
+    PPULLVMRecompiler();
 
-    PPULLVMRecompilerWorker(const PPULLVMRecompilerWorker & other) = delete;
-    PPULLVMRecompilerWorker(PPULLVMRecompilerWorker && other) = delete;
+    PPULLVMRecompiler(const PPULLVMRecompiler & other) = delete;
+    PPULLVMRecompiler(PPULLVMRecompiler && other) = delete;
 
-    virtual ~PPULLVMRecompilerWorker();
+    virtual ~PPULLVMRecompiler();
 
-    PPULLVMRecompilerWorker & operator = (const PPULLVMRecompilerWorker & other) = delete;
-    PPULLVMRecompilerWorker & operator = (PPULLVMRecompilerWorker && other) = delete;
+    PPULLVMRecompiler & operator = (const PPULLVMRecompiler & other) = delete;
+    PPULLVMRecompiler & operator = (PPULLVMRecompiler && other) = delete;
 
-    /// Compile a block of code
-    void Compile(u64 address);
-
-    /// Get a function pointer to a compiled block
+    /// Get a pointer to a compiled block
     CompiledBlock GetCompiledBlock(u64 address);
 
     /// Execute all tests
     void RunAllTests(PPUThread * ppu_state, u64 base_address, PPUInterpreter * interpreter);
 
+    void Task() override;
+
 protected:
+    /// Compile a block of code
+    void Compile(u64 address);
+
     void NULL_OP() override;
     void NOP() override;
 
@@ -442,9 +444,19 @@ private:
     /// PPU instruction decoder
     PPUDecoder m_decoder;
 
+    /// Mutex for accessing m_address_to_compiled_block_map
+    /// TODO: Use a RW lock instead of mutex
+    std::mutex m_address_to_compiled_block_map_mutex;
+
     /// Map from address to compiled block
     std::map<u64, CompiledBlock> m_address_to_compiled_block_map;
 
+    /// Mutex for accessing m_pending_blocks_set;
+    std::mutex m_pending_blocks_set_mutex;
+
+    /// Set of blocks pending compilation
+    std::set<u64> m_pending_blocks_set;
+
     /// LLVM context
     llvm::LLVMContext * m_llvm_context;
 
@@ -605,19 +617,19 @@ private:
     void RunTest(const char * name, std::function<void()> test_case, std::function<void()> input, std::function<bool(std::string & msg)> check_result);
 };
 
-/// A dynarec PPU emulator that uses LLVM as the backend
-class PPULLVMRecompiler : public CPUDecoder {
+/// PPU emulator that uses LLVM to convert PPU instructions to host CPU instructions
+class PPULLVMEmulator : public CPUDecoder {
 public:
-    PPULLVMRecompiler(PPUThread & ppu);
-    PPULLVMRecompiler() = delete;
+    PPULLVMEmulator(PPUThread & ppu);
+    PPULLVMEmulator() = delete;
 
-    PPULLVMRecompiler(const PPULLVMRecompilerWorker & other) = delete;
-    PPULLVMRecompiler(PPULLVMRecompilerWorker && other) = delete;
+    PPULLVMEmulator(const PPULLVMEmulator & other) = delete;
+    PPULLVMEmulator(PPULLVMEmulator && other) = delete;
 
-    virtual ~PPULLVMRecompiler();
+    virtual ~PPULLVMEmulator();
 
-    PPULLVMRecompiler & operator = (const PPULLVMRecompiler & other) = delete;
-    PPULLVMRecompiler & operator = (PPULLVMRecompiler && other) = delete;
+    PPULLVMEmulator & operator = (const PPULLVMEmulator & other) = delete;
+    PPULLVMEmulator & operator = (PPULLVMEmulator && other) = delete;
 
     u8 DecodeMemory(const u64 address);
 
@@ -626,10 +638,19 @@ private:
     PPUThread & m_ppu;
 
     /// PPU Interpreter
-    PPUInterpreter m_interpreter;
+    PPUInterpreter * m_interpreter;
 
-    /// The actual compiler
-    PPULLVMRecompilerWorker m_worker;
+    /// PPU instruction Decoder
+    PPUDecoder m_decoder;
+
+    /// Number of instances of this class
+    static u32 s_num_instances;
+
+    /// Mutex used prevent multiple instances of the recompiler from being created
+    static std::mutex s_recompiler_mutex;
+
+    /// PPU to LLVM recompiler
+    static PPULLVMRecompiler * s_recompiler;
 };
 
 #endif // PPU_LLVM_RECOMPILER_H
diff --git a/rpcs3/Emu/Cell/PPULLVMRecompilerTests.cpp b/rpcs3/Emu/Cell/PPULLVMRecompilerTests.cpp
index fc87753734..25cde6e660 100644
--- a/rpcs3/Emu/Cell/PPULLVMRecompilerTests.cpp
+++ b/rpcs3/Emu/Cell/PPULLVMRecompilerTests.cpp
@@ -9,7 +9,7 @@
 using namespace llvm;
 
 #define VERIFY_INSTRUCTION_AGAINST_INTERPRETER(fn, tc, input, ...) \
-VerifyInstructionAgainstInterpreter(fmt::Format("%s.%d", #fn, tc).c_str(), &PPULLVMRecompilerWorker::fn, &PPUInterpreter::fn, input, __VA_ARGS__)
+VerifyInstructionAgainstInterpreter(fmt::Format("%s.%d", #fn, tc).c_str(), &PPULLVMRecompiler::fn, &PPUInterpreter::fn, input, __VA_ARGS__)
 
 #define VERIFY_INSTRUCTION_AGAINST_INTERPRETER_USING_RANDOM_INPUT(fn, s, n, ...) {  \
     PPURegState input;                                                              \
@@ -160,7 +160,7 @@ static u64              s_base_address = 0;
 static PPUInterpreter * s_interpreter  = nullptr;
 
 template <class PPULLVMRecompilerFn, class PPUInterpreterFn, class... Args>
-void PPULLVMRecompilerWorker::VerifyInstructionAgainstInterpreter(const char * name, PPULLVMRecompilerFn recomp_fn, PPUInterpreterFn interp_fn, PPURegState & input_reg_state, Args... args) {
+void PPULLVMRecompiler::VerifyInstructionAgainstInterpreter(const char * name, PPULLVMRecompilerFn recomp_fn, PPUInterpreterFn interp_fn, PPURegState & input_reg_state, Args... args) {
     auto test_case = [&]() {
         (this->*recomp_fn)(args...);
     };
@@ -188,7 +188,7 @@ void PPULLVMRecompilerWorker::VerifyInstructionAgainstInterpreter(const char * n
     RunTest(name, test_case, input, check_result);
 }
 
-void PPULLVMRecompilerWorker::RunTest(const char * name, std::function<void()> test_case, std::function<void()> input, std::function<bool(std::string & msg)> check_result) {
+void PPULLVMRecompiler::RunTest(const char * name, std::function<void()> test_case, std::function<void()> input, std::function<bool(std::string & msg)> check_result) {
     // Create the unit test function
     m_function = (Function *)m_module->getOrInsertFunction(name, m_ir_builder->getVoidTy(),
                                                            m_ir_builder->getInt8PtrTy() /*ppu_state*/,
@@ -256,7 +256,7 @@ void PPULLVMRecompilerWorker::RunTest(const char * name, std::function<void()> t
     m_execution_engine->freeMachineCodeForFunction(m_function);
 }
 
-void PPULLVMRecompilerWorker::RunAllTests(PPUThread * ppu_state, u64 base_address, PPUInterpreter * interpreter) {
+void PPULLVMRecompiler::RunAllTests(PPUThread * ppu_state, u64 base_address, PPUInterpreter * interpreter) {
     s_ppu_state    = ppu_state;
     s_base_address = base_address;
     s_interpreter  = interpreter;
diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp
index 3250c18ef9..2b75364d43 100644
--- a/rpcs3/Emu/Cell/PPUThread.cpp
+++ b/rpcs3/Emu/Cell/PPUThread.cpp
@@ -112,7 +112,7 @@ void PPUThread::DoRun()
 	break;
 
 	case 3:
-		m_dec = new PPULLVMRecompiler(*this);
+		m_dec = new PPULLVMEmulator(*this);
 	break;
 
 	default: