diff --git a/rpcs3/Emu/Cell/PPUInterpreter.h b/rpcs3/Emu/Cell/PPUInterpreter.h
index cdb7a2d2ce..da61d3f1b7 100644
--- a/rpcs3/Emu/Cell/PPUInterpreter.h
+++ b/rpcs3/Emu/Cell/PPUInterpreter.h
@@ -55,9 +55,13 @@ u64 rotr64(const u64 x, const u8 n) { return (x >> n) | (x << (64 - n)); }
 #define rotl64 _rotl64
 #define rotr64 _rotr64
 
+namespace ppu_recompiler_llvm {
+	class Compiler;
+}
+
 class PPUInterpreter : public PPUOpcodes
 {
-    friend class PPULLVMRecompiler;
+    friend class ppu_recompiler_llvm::Compiler;
 private:
 	PPUThread& CPU;
 
diff --git a/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
index 5d66f575a9..4dda28cb55 100644
--- a/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
@@ -21,13 +21,12 @@
 #include "llvm/MC/MCDisassembler.h"
 
 using namespace llvm;
+using namespace ppu_recompiler_llvm;
 
-u64  PPULLVMRecompiler::s_rotate_mask[64][64];
-bool PPULLVMRecompiler::s_rotate_mask_inited = false;
+u64  Compiler::s_rotate_mask[64][64];
+bool Compiler::s_rotate_mask_inited = false;
 
-PPULLVMRecompiler::PPULLVMRecompiler()
-    : ThreadBase("PPULLVMRecompiler")
-    , m_revision(0) {
+Compiler::Compiler() {
     InitializeNativeTarget();
     InitializeNativeTargetAsmPrinter();
     InitializeNativeTargetDisassembler();
@@ -70,181 +69,164 @@ PPULLVMRecompiler::PPULLVMRecompiler()
     }
 }
 
-PPULLVMRecompiler::~PPULLVMRecompiler() {
-    Stop();
-
+Compiler::~Compiler() {
     delete m_execution_engine;
     delete m_fpm;
     delete m_ir_builder;
     delete m_llvm_context;
 }
 
-std::pair<PPULLVMRecompiler::Executable, u32> PPULLVMRecompiler::GetExecutable(u32 address) {
-    std::lock_guard<std::mutex> lock(m_compiled_shared_lock);
+CompiledCodeFragment Compiler::Compile(const std::string & name, const CodeFragment & code_fragment) {
+    assert(!name.empty());
+    assert(!code_fragment.empty());
 
-    auto compiled = m_compiled_shared.lower_bound(std::make_pair(address, 0));
-    if (compiled != m_compiled_shared.end() && compiled->first.first == address) {
-        compiled->second.second++;
-        return std::make_pair(compiled->second.first, compiled->first.second);
-    }
+    auto compilation_start = std::chrono::high_resolution_clock::now();
 
-    return std::make_pair(nullptr, 0);
-}
+    // Create the function
+    m_current_function = (Function *)m_module->getOrInsertFunction(name, m_ir_builder->getVoidTy(),
+                                                                   m_ir_builder->getInt8PtrTy() /*ppu_state*/,
+                                                                   m_ir_builder->getInt8PtrTy() /*interpreter*/,
+                                                                   m_ir_builder->getInt8PtrTy() /*tracer*/, nullptr);
+    m_current_function->setCallingConv(CallingConv::X86_64_Win64);
+    auto arg_i = m_current_function->arg_begin();
+    arg_i->setName("ppu_state");
+    (++arg_i)->setName("interpreter");
+    (++arg_i)->setName("tracer");
 
-void PPULLVMRecompiler::ReleaseExecutable(u32 address, u32 revision) {
-    std::lock_guard<std::mutex> lock(m_compiled_shared_lock);
+    // Create the entry block
+    GetBasicBlockFromAddress(0, m_current_function, true);
 
-    auto compiled = m_compiled_shared.find(std::make_pair(address, revision));
-    if (compiled != m_compiled_shared.end()) {
-        compiled->second.second--;
-    }
-}
+    // Create basic blocks for each instruction
+    for (auto i = code_fragment.begin(); i != code_fragment.end(); i++) {
+        u32 address = i->first.address;
+        while (1) {
+            GetBasicBlockFromAddress(address, m_current_function, true);
 
-void PPULLVMRecompiler::RequestCompilation(u32 address) {
-    {
-        std::lock_guard<std::mutex> lock(m_uncompiled_shared_lock);
-        m_uncompiled_shared.push_back(address);
-    }
-
-    if (!IsAlive()) {
-        Start();
-    }
-
-    Notify();
-}
-
-u32 PPULLVMRecompiler::GetCurrentRevision() {
-    return m_revision.load(std::memory_order_relaxed);
-}
-
-void PPULLVMRecompiler::Task() {
-    auto start = std::chrono::high_resolution_clock::now();
-
-    while (!TestDestroy() && !Emu.IsStopped()) {
-        // Wait a few ms for something to happen
-        auto idling_start = std::chrono::high_resolution_clock::now();
-        WaitForAnySignal(250);
-        auto idling_end = std::chrono::high_resolution_clock::now();
-        m_idling_time += std::chrono::duration_cast<std::chrono::nanoseconds>(idling_end - idling_start);
-
-        // Update the set of blocks that have been hit with the set of blocks that have been requested for compilation.
-        {
-            std::lock_guard<std::mutex> lock(m_uncompiled_shared_lock);
-            for (auto i = m_uncompiled_shared.begin(); i != m_uncompiled_shared.end(); i++) {
-                m_hit_blocks.insert(*i);
+            u32 instr = vm::read32(address);
+            if (IsBranchInstruction(instr)) {
+                break;
             }
+
+            address += 4;
         }
+    }
 
-        u32 num_compiled = 0;
-        while (!TestDestroy() && !Emu.IsStopped()) {
-            u32 address;
+    // Add code to notify the tracer about this function and branch to the first instruction
+    m_ir_builder->SetInsertPoint(GetBasicBlockFromAddress(0, m_current_function));
+    //Call<void>("Tracer.Trace", &Tracer::Trace, *arg_i,
+    //           m_ir_builder->getIntN(sizeof(Tracer::BranchType) * 8, code_fragment[0].first.type == FunctionStart ? Tracer::BranchType::CompiledFunctionCall : Tracer::BranchType::CompiledBlock),
+    //           m_ir_builder->getInt32(code_fragment[0].first.address));
+    m_ir_builder->CreateBr(GetBasicBlockFromAddress(code_fragment[0].first.address, m_current_function));
 
-            {
-                std::lock_guard<std::mutex> lock(m_uncompiled_shared_lock);
+    // Convert each block in this code fragment to LLVM IR
+    for (auto i = code_fragment.begin(); i != code_fragment.end(); i++) {
+        m_current_instruction_address = i->first.address;
+        m_current_block_next_blocks   = &(i->second);
+        auto block                    = GetBasicBlockFromAddress(m_current_instruction_address, m_current_function);
+        m_hit_branch_instruction      = false;
+        m_ir_builder->SetInsertPoint(block);
 
-                auto i = m_uncompiled_shared.begin();
-                if (i != m_uncompiled_shared.end()) {
-                    address = *i;
-                    m_uncompiled_shared.erase(i);
-                } else {
-                    break;
-                }
+        while (!m_hit_branch_instruction) {
+            if (!block->getInstList().empty()) {
+                break;
             }
 
-            m_hit_blocks.insert(address);
-            if (NeedsCompiling(address)) {
-                Compile(address);
-                num_compiled++;
-            }
-        }
+            u32 instr = vm::read32(m_current_instruction_address);
+            Decode(instr);
 
-        if (num_compiled == 0) {
-            // If we get here, it means the recompilation thread is idling.
-            // We use this oppurtunity to optimize the code.
-            RemoveUnusedOldVersions();
-            for (auto i = m_compiled.begin(); i != m_compiled.end(); i++) {
-                if (NeedsCompiling(i->first.first)) {
-                    Compile(i->first.first);
-                    num_compiled++;
-                }
+            m_current_instruction_address += 4;
+            if (!m_hit_branch_instruction) {
+                block = GetBasicBlockFromAddress(m_current_instruction_address, m_current_function);
+                m_ir_builder->CreateBr(block);
+                m_ir_builder->SetInsertPoint(block);
             }
         }
     }
 
-    std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
-    m_total_time = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
+    // If the function has an unknown block then notify the tracer
+    auto unknown_bb = GetBasicBlockFromAddress(0xFFFFFFFF, m_current_function);
+    if (!unknown_bb) {
+        m_ir_builder->SetInsertPoint(unknown_bb);
+        auto branch_type_i32 = m_ir_builder->CreatePHI(m_ir_builder->getInt32Ty(), 1);
+        for (auto i = pred_begin(unknown_bb); i != pred_end(unknown_bb); i++) {
+            // We assume that the last but one instruction of the predecessor sets the branch type
+            auto j = (*i)->rbegin();
+            j--;
+            branch_type_i32->addIncoming(&(*j), *i);
+        }
 
-    std::string error;
-    raw_fd_ostream log_file("PPULLVMRecompiler.log", error, sys::fs::F_Text);
-    log_file << "Total time                      = " << m_total_time.count() / 1000000 << "ms\n";
-    log_file << "    Time spent compiling        = " << m_compilation_time.count() / 1000000 << "ms\n";
-    log_file << "        Time spent building IR  = " << m_ir_build_time.count() / 1000000 << "ms\n";
-    log_file << "        Time spent optimizing   = " << m_optimizing_time.count() / 1000000 << "ms\n";
-    log_file << "        Time spent translating  = " << m_translation_time.count() / 1000000 << "ms\n";
-    log_file << "    Time spent idling           = " << m_idling_time.count() / 1000000 << "ms\n";
-    log_file << "    Time spent doing misc tasks = " << (m_total_time.count() - m_idling_time.count() - m_compilation_time.count()) / 1000000 << "ms\n";
-    log_file << "Revision                        = " << m_revision << "\n";
-    log_file << "\nInterpreter fallback stats:\n";
-    for (auto i = m_interpreter_fallback_stats.begin(); i != m_interpreter_fallback_stats.end(); i++) {
-        log_file << i->first << " = " << i->second << "\n";
+        //Call<void>("NotifyBranch", &Tracer::NotifyBranch, *arg_i,
+        //           m_ir_builder->CreateZExtOrTrunc(branch_type_i32, m_ir_builder->getIntNTy(sizeof(Tracer::BranchType) * 8)), GetPc());
+        m_ir_builder->CreateRetVoid();
     }
 
-    log_file << "\nDisassembly:\n";
-    //auto disassembler = LLVMCreateDisasm(sys::getProcessTriple().c_str(), nullptr, 0, nullptr, nullptr);
-    for (auto i = m_compiled.begin(); i != m_compiled.end(); i++) {
-        log_file << fmt::Format("%s: Size = %u bytes, Number of instructions = %u\n", i->second.llvm_function->getName().str().c_str(), i->second.size, i->second.num_instructions);
+    auto ir_build_end      = std::chrono::high_resolution_clock::now();
+    m_stats.ir_build_time += std::chrono::duration_cast<std::chrono::nanoseconds>(ir_build_end - compilation_start);
 
-        //uint8_t * fn_ptr = (uint8_t *)i->second.executable;
-        //for (size_t pc = 0; pc < i->second.size;) {
-        //    char str[1024];
+    // Optimize this function
+    m_fpm->run(*m_current_function);
+    auto optimize_end          = std::chrono::high_resolution_clock::now();
+    m_stats.optimization_time += std::chrono::duration_cast<std::chrono::nanoseconds>(optimize_end - ir_build_end);
 
-        //    auto size = LLVMDisasmInstruction(disassembler, fn_ptr + pc, i->second.size - pc, (uint64_t)(fn_ptr + pc), str, sizeof(str));
-        //    log_file << str << '\n';
-        //    pc += size;
-        //}
-    }
+    // Translate to machine code
+    MachineCodeInfo mci;
+    m_execution_engine->runJITOnFunction(m_current_function, &mci);
+    auto translate_end        = std::chrono::high_resolution_clock::now();
+    m_stats.translation_time += std::chrono::duration_cast<std::chrono::nanoseconds>(translate_end - optimize_end);
 
-    //LLVMDisasmDispose(disassembler);
+    auto compilation_end  = std::chrono::high_resolution_clock::now();
+    m_stats.total_time   += std::chrono::duration_cast<std::chrono::nanoseconds>(compilation_end - compilation_start);
 
-    //log_file << "\nLLVM IR:\n" << *m_module;
-
-    LOG_NOTICE(PPU, "PPU LLVM compiler thread exiting.");
+    m_compiled[(CompiledCodeFragment)mci.address()] = m_current_function;
+    return (CompiledCodeFragment)mci.address();
 }
 
-void PPULLVMRecompiler::Decode(const u32 code) {
+void Compiler::FreeCompiledCodeFragment(CompiledCodeFragment compiled_code_fragment) {
+    auto i = m_compiled.find(compiled_code_fragment);
+    if (i != m_compiled.end()) {
+        m_execution_engine->freeMachineCodeForFunction(i->second);
+        i->second->eraseFromParent();
+    }
+}
+
+Compiler::Stats Compiler::GetStats() {
+    return m_stats;
+}
+
+void Compiler::Decode(const u32 code) {
     (*PPU_instr::main_list)(this, code);
 }
 
-void PPULLVMRecompiler::NULL_OP() {
+void Compiler::NULL_OP() {
     InterpreterCall("NULL_OP", &PPUInterpreter::NULL_OP);
 }
 
-void PPULLVMRecompiler::NOP() {
+void Compiler::NOP() {
     InterpreterCall("NOP", &PPUInterpreter::NOP);
 }
 
-void PPULLVMRecompiler::TDI(u32 to, u32 ra, s32 simm16) {
+void Compiler::TDI(u32 to, u32 ra, s32 simm16) {
     InterpreterCall("TDI", &PPUInterpreter::TDI, to, ra, simm16);
 }
 
-void PPULLVMRecompiler::TWI(u32 to, u32 ra, s32 simm16) {
+void Compiler::TWI(u32 to, u32 ra, s32 simm16) {
     InterpreterCall("TWI", &PPUInterpreter::TWI, to, ra, simm16);
 }
 
-void PPULLVMRecompiler::MFVSCR(u32 vd) {
+void Compiler::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 PPULLVMRecompiler::MTVSCR(u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VADDCUW(u32 vd, u32 va, u32 vb) {
+void Compiler::VADDCUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
 
@@ -254,14 +236,14 @@ void PPULLVMRecompiler::VADDCUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmpv4i32);
 }
 
-void PPULLVMRecompiler::VADDFP(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VADDSBS(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -270,7 +252,7 @@ void PPULLVMRecompiler::VADDSBS(u32 vd, u32 va, u32 vb) {
     // TODO: Set VSCR.SAT
 }
 
-void PPULLVMRecompiler::VADDSHS(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -279,7 +261,7 @@ void PPULLVMRecompiler::VADDSHS(u32 vd, u32 va, u32 vb) {
     // TODO: Set VSCR.SAT
 }
 
-void PPULLVMRecompiler::VADDSWS(u32 vd, u32 va, u32 vb) {
+void Compiler::VADDSWS(u32 vd, u32 va, u32 vb) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
 
@@ -320,14 +302,14 @@ void PPULLVMRecompiler::VADDSWS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VADDUBM(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VADDUBS(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -336,14 +318,14 @@ void PPULLVMRecompiler::VADDUBS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VADDUHM(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VADDUHS(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -352,14 +334,14 @@ void PPULLVMRecompiler::VADDUHS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VADDUWM(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VADDUWS(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -371,14 +353,14 @@ void PPULLVMRecompiler::VADDUWS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VAND(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VANDC(u32 vd, u32 va, u32 vb) {
+void Compiler::VANDC(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     vb_v4i32       = m_ir_builder->CreateNot(vb_v4i32);
@@ -386,7 +368,7 @@ void PPULLVMRecompiler::VANDC(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VAVGSB(u32 vd, u32 va, u32 vb) {
+void Compiler::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));
@@ -398,7 +380,7 @@ void PPULLVMRecompiler::VAVGSB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v16i8);
 }
 
-void PPULLVMRecompiler::VAVGSH(u32 vd, u32 va, u32 vb) {
+void Compiler::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));
@@ -410,7 +392,7 @@ void PPULLVMRecompiler::VAVGSH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v8i16);
 }
 
-void PPULLVMRecompiler::VAVGSW(u32 vd, u32 va, u32 vb) {
+void Compiler::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));
@@ -422,21 +404,21 @@ void PPULLVMRecompiler::VAVGSW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v4i32);
 }
 
-void PPULLVMRecompiler::VAVGUB(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VAVGUH(u32 vd, u32 va, u32 vb) {
+void Compiler::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 PPULLVMRecompiler::VAVGUW(u32 vd, u32 va, u32 vb) {
+void Compiler::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));
@@ -448,7 +430,7 @@ void PPULLVMRecompiler::VAVGUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, avg_v4i32);
 }
 
-void PPULLVMRecompiler::VCFSX(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::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));
 
@@ -460,7 +442,7 @@ void PPULLVMRecompiler::VCFSX(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VCFUX(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::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));
 
@@ -472,7 +454,7 @@ void PPULLVMRecompiler::VCFUX(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VCMPBFP(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -488,7 +470,7 @@ void PPULLVMRecompiler::VCMPBFP(u32 vd, u32 va, u32 vb) {
     // TODO: Implement NJ mode
 }
 
-void PPULLVMRecompiler::VCMPBFP_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPBFP_(u32 vd, u32 va, u32 vb) {
     VCMPBFP(vd, va, vb);
 
     auto vd_v16i8       = GetVrAsIntVec(vd, 8);
@@ -500,7 +482,7 @@ void PPULLVMRecompiler::VCMPBFP_(u32 vd, u32 va, u32 vb) {
     SetCrField(6, nullptr, nullptr, cmp_i1, nullptr);
 }
 
-void PPULLVMRecompiler::VCMPEQFP(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -508,12 +490,12 @@ void PPULLVMRecompiler::VCMPEQFP(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompiler::VCMPEQFP_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPEQFP_(u32 vd, u32 va, u32 vb) {
     VCMPEQFP(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPEQUB(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -521,12 +503,12 @@ void PPULLVMRecompiler::VCMPEQUB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v16i8);
 }
 
-void PPULLVMRecompiler::VCMPEQUB_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPEQUB_(u32 vd, u32 va, u32 vb) {
     VCMPEQUB(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPEQUH(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -534,12 +516,12 @@ void PPULLVMRecompiler::VCMPEQUH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v8i16);
 }
 
-void PPULLVMRecompiler::VCMPEQUH_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPEQUH_(u32 vd, u32 va, u32 vb) {
     VCMPEQUH(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPEQUW(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -547,12 +529,12 @@ void PPULLVMRecompiler::VCMPEQUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompiler::VCMPEQUW_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPEQUW_(u32 vd, u32 va, u32 vb) {
     VCMPEQUW(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGEFP(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -560,12 +542,12 @@ void PPULLVMRecompiler::VCMPGEFP(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompiler::VCMPGEFP_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGEFP_(u32 vd, u32 va, u32 vb) {
     VCMPGEFP(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTFP(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -573,12 +555,12 @@ void PPULLVMRecompiler::VCMPGTFP(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompiler::VCMPGTFP_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTFP_(u32 vd, u32 va, u32 vb) {
     VCMPGTFP(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTSB(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -586,12 +568,12 @@ void PPULLVMRecompiler::VCMPGTSB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v16i8);
 }
 
-void PPULLVMRecompiler::VCMPGTSB_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTSB_(u32 vd, u32 va, u32 vb) {
     VCMPGTSB(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTSH(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -599,12 +581,12 @@ void PPULLVMRecompiler::VCMPGTSH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v8i16);
 }
 
-void PPULLVMRecompiler::VCMPGTSH_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTSH_(u32 vd, u32 va, u32 vb) {
     VCMPGTSH(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTSW(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -612,12 +594,12 @@ void PPULLVMRecompiler::VCMPGTSW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompiler::VCMPGTSW_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTSW_(u32 vd, u32 va, u32 vb) {
     VCMPGTSW(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTUB(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -625,12 +607,12 @@ void PPULLVMRecompiler::VCMPGTUB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v16i8);
 }
 
-void PPULLVMRecompiler::VCMPGTUB_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTUB_(u32 vd, u32 va, u32 vb) {
     VCMPGTUB(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTUH(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -638,12 +620,12 @@ void PPULLVMRecompiler::VCMPGTUH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v8i16);
 }
 
-void PPULLVMRecompiler::VCMPGTUH_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTUH_(u32 vd, u32 va, u32 vb) {
     VCMPGTUH(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCMPGTUW(u32 vd, u32 va, u32 vb) {
+void Compiler::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);
@@ -651,28 +633,28 @@ void PPULLVMRecompiler::VCMPGTUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmp_v4i32);
 }
 
-void PPULLVMRecompiler::VCMPGTUW_(u32 vd, u32 va, u32 vb) {
+void Compiler::VCMPGTUW_(u32 vd, u32 va, u32 vb) {
     VCMPGTUW(vd, va, vb);
     SetCr6AfterVectorCompare(vd);
 }
 
-void PPULLVMRecompiler::VCTSXS(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::VCTSXS(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VCTSXS", &PPUInterpreter::VCTSXS, vd, uimm5, vb);
 }
 
-void PPULLVMRecompiler::VCTUXS(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::VCTUXS(u32 vd, u32 uimm5, u32 vb) {
     InterpreterCall("VCTUXS", &PPUInterpreter::VCTUXS, vd, uimm5, vb);
 }
 
-void PPULLVMRecompiler::VEXPTEFP(u32 vd, u32 vb) {
+void Compiler::VEXPTEFP(u32 vd, u32 vb) {
     InterpreterCall("VEXPTEFP", &PPUInterpreter::VEXPTEFP, vd, vb);
 }
 
-void PPULLVMRecompiler::VLOGEFP(u32 vd, u32 vb) {
+void Compiler::VLOGEFP(u32 vd, u32 vb) {
     InterpreterCall("VLOGEFP", &PPUInterpreter::VLOGEFP, vd, vb);
 }
 
-void PPULLVMRecompiler::VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) {
+void Compiler::VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto vc_v4f32  = GetVrAsFloatVec(vc);
@@ -680,117 +662,117 @@ void PPULLVMRecompiler::VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) {
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VMAXFP(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto res_v4f32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse_max_ps), va_v4f32, vb_v4f32);
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VMAXSB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXSB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto res_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pmaxsb), va_v16i8, vb_v16i8);
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VMAXSH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXSH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pmaxs_w), va_v8i16, vb_v8i16);
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VMAXSW(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXSW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4i32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pmaxsd), va_v4i32, vb_v4i32);
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VMAXUB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXUB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto res_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pmaxu_b), va_v16i8, vb_v16i8);
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VMAXUH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXUH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pmaxuw), va_v8i16, vb_v8i16);
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VMAXUW(u32 vd, u32 va, u32 vb) {
+void Compiler::VMAXUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4i32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pmaxud), va_v4i32, vb_v4i32);
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMHADDSHS", &PPUInterpreter::VMHADDSHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompiler::VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMHRADDSHS", &PPUInterpreter::VMHRADDSHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompiler::VMINFP(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto res_v4f32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse_min_ps), va_v4f32, vb_v4f32);
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VMINSB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINSB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto res_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pminsb), va_v16i8, vb_v16i8);
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VMINSH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINSH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pmins_w), va_v8i16, vb_v8i16);
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VMINSW(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINSW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4i32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pminsd), va_v4i32, vb_v4i32);
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VMINUB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINUB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     auto res_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_pminu_b), va_v16i8, vb_v16i8);
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VMINUH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINUH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pminuw), va_v8i16, vb_v8i16);
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VMINUW(u32 vd, u32 va, u32 vb) {
+void Compiler::VMINUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     auto res_v4i32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse41_pminud), va_v4i32, vb_v4i32);
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMLADDUHM", &PPUInterpreter::VMLADDUHM, vd, va, vb, vc);
 }
 
-void PPULLVMRecompiler::VMRGHB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMRGHB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8        = GetVrAsIntVec(va, 8);
     auto vb_v16i8        = GetVrAsIntVec(vb, 8);
     u32  mask_v16i32[16] = {24, 8, 25, 9, 26, 10, 27, 11, 28, 12, 29, 13, 30, 14, 31, 15};
@@ -798,7 +780,7 @@ void PPULLVMRecompiler::VMRGHB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, vd_v16i8);
 }
 
-void PPULLVMRecompiler::VMRGHH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMRGHH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16      = GetVrAsIntVec(va, 16);
     auto vb_v8i16      = GetVrAsIntVec(vb, 16);
     u32  mask_v8i32[8] = {12, 4, 13, 5, 14, 6, 15, 7};
@@ -806,7 +788,7 @@ void PPULLVMRecompiler::VMRGHH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, vd_v8i16);
 }
 
-void PPULLVMRecompiler::VMRGHW(u32 vd, u32 va, u32 vb) {
+void Compiler::VMRGHW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32      = GetVrAsIntVec(va, 32);
     auto vb_v4i32      = GetVrAsIntVec(vb, 32);
     u32  mask_v4i32[4] = {6, 2, 7, 3};
@@ -814,7 +796,7 @@ void PPULLVMRecompiler::VMRGHW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, vd_v4i32);
 }
 
-void PPULLVMRecompiler::VMRGLB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMRGLB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8        = GetVrAsIntVec(va, 8);
     auto vb_v16i8        = GetVrAsIntVec(vb, 8);
     u32  mask_v16i32[16] = {16, 0, 17, 1, 18, 2, 19, 3, 20, 4, 21, 5, 22, 6, 23, 7};
@@ -822,7 +804,7 @@ void PPULLVMRecompiler::VMRGLB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, vd_v16i8);
 }
 
-void PPULLVMRecompiler::VMRGLH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMRGLH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16      = GetVrAsIntVec(va, 16);
     auto vb_v8i16      = GetVrAsIntVec(vb, 16);
     u32  mask_v8i32[8] = {8, 0, 9, 1, 10, 2, 11, 3};
@@ -830,7 +812,7 @@ void PPULLVMRecompiler::VMRGLH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, vd_v8i16);
 }
 
-void PPULLVMRecompiler::VMRGLW(u32 vd, u32 va, u32 vb) {
+void Compiler::VMRGLW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32      = GetVrAsIntVec(va, 32);
     auto vb_v4i32      = GetVrAsIntVec(vb, 32);
     u32  mask_v4i32[4] = {4, 0, 5, 1};
@@ -838,7 +820,7 @@ void PPULLVMRecompiler::VMRGLW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, vd_v4i32);
 }
 
-void PPULLVMRecompiler::VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) {
     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));
@@ -870,7 +852,7 @@ void PPULLVMRecompiler::VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) {
     // TODO: Try to optimize with horizontal add
 }
 
-void PPULLVMRecompiler::VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto vc_v4i32  = GetVrAsIntVec(vc, 32);
@@ -879,11 +861,11 @@ void PPULLVMRecompiler::VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMSHS", &PPUInterpreter::VMSUMSHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompiler::VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) {
     auto va_v16i8   = GetVrAsIntVec(va, 8);
     auto vb_v16i8   = GetVrAsIntVec(vb, 8);
     auto va_v16i16  = m_ir_builder->CreateZExt(va_v16i8, VectorType::get(m_ir_builder->getInt16Ty(), 16));
@@ -915,7 +897,7 @@ void PPULLVMRecompiler::VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) {
     // TODO: Try to optimize with horizontal add
 }
 
-void PPULLVMRecompiler::VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto va_v8i32  = m_ir_builder->CreateZExt(va_v8i16, VectorType::get(m_ir_builder->getInt32Ty(), 8));
@@ -937,43 +919,43 @@ void PPULLVMRecompiler::VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) {
     // TODO: Try to optimize with horizontal add
 }
 
-void PPULLVMRecompiler::VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) {
     InterpreterCall("VMSUMUHS", &PPUInterpreter::VMSUMUHS, vd, va, vb, vc);
 }
 
-void PPULLVMRecompiler::VMULESB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULESB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULESB", &PPUInterpreter::VMULESB, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULESH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULESH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULESH", &PPUInterpreter::VMULESH, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULEUB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULEUB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULEUB", &PPUInterpreter::VMULEUB, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULEUH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULEUH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULEUH", &PPUInterpreter::VMULEUH, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULOSB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULOSB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOSB", &PPUInterpreter::VMULOSB, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULOSH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULOSH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOSH", &PPUInterpreter::VMULOSH, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULOUB(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULOUB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOUB", &PPUInterpreter::VMULOUB, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VMULOUH(u32 vd, u32 va, u32 vb) {
+void Compiler::VMULOUH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VMULOUH", &PPUInterpreter::VMULOUH, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) {
+void Compiler::VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) {
     auto va_v4f32  = GetVrAsFloatVec(va);
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto vc_v4f32  = GetVrAsFloatVec(vc);
@@ -982,7 +964,7 @@ void PPULLVMRecompiler::VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) {
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VNOR(u32 vd, u32 va, u32 vb) {
+void Compiler::VNOR(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateOr(va_v8i16, vb_v8i16);
@@ -990,14 +972,14 @@ void PPULLVMRecompiler::VNOR(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VOR(u32 vd, u32 va, u32 vb) {
+void Compiler::VOR(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateOr(va_v8i16, vb_v8i16);
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VPERM(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VPERM(u32 vd, u32 va, u32 vb, u32 vc) {
     auto va_v16i8 = GetVrAsIntVec(va, 8);
     auto vb_v16i8 = GetVrAsIntVec(vb, 8);
     auto vc_v16i8 = GetVrAsIntVec(vc, 8);
@@ -1019,81 +1001,81 @@ void PPULLVMRecompiler::VPERM(u32 vd, u32 va, u32 vb, u32 vc) {
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VPKPX(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKPX(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKPX", &PPUInterpreter::VPKPX, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKSHSS(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKSHSS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSHSS", &PPUInterpreter::VPKSHSS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKSHUS(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKSHUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSHUS", &PPUInterpreter::VPKSHUS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKSWSS(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKSWSS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSWSS", &PPUInterpreter::VPKSWSS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKSWUS(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKSWUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKSWUS", &PPUInterpreter::VPKSWUS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKUHUM(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKUHUM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUHUM", &PPUInterpreter::VPKUHUM, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKUHUS(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKUHUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUHUS", &PPUInterpreter::VPKUHUS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKUWUM(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKUWUM(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUWUM", &PPUInterpreter::VPKUWUM, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VPKUWUS(u32 vd, u32 va, u32 vb) {
+void Compiler::VPKUWUS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VPKUWUS", &PPUInterpreter::VPKUWUS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VREFP(u32 vd, u32 vb) {
+void Compiler::VREFP(u32 vd, u32 vb) {
     auto vb_v4f32  = GetVrAsFloatVec(vb);
     auto res_v4f32 = m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse_rcp_ps), vb_v4f32);
     SetVr(vd, res_v4f32);
 }
 
-void PPULLVMRecompiler::VRFIM(u32 vd, u32 vb) {
+void Compiler::VRFIM(u32 vd, u32 vb) {
     InterpreterCall("VRFIM", &PPUInterpreter::VRFIM, vd, vb);
 }
 
-void PPULLVMRecompiler::VRFIN(u32 vd, u32 vb) {
+void Compiler::VRFIN(u32 vd, u32 vb) {
     InterpreterCall("VRFIN", &PPUInterpreter::VRFIN, vd, vb);
 }
 
-void PPULLVMRecompiler::VRFIP(u32 vd, u32 vb) {
+void Compiler::VRFIP(u32 vd, u32 vb) {
     InterpreterCall("VRFIP", &PPUInterpreter::VRFIP, vd, vb);
 }
 
-void PPULLVMRecompiler::VRFIZ(u32 vd, u32 vb) {
+void Compiler::VRFIZ(u32 vd, u32 vb) {
     InterpreterCall("VRFIZ", &PPUInterpreter::VRFIZ, vd, vb);
 }
 
-void PPULLVMRecompiler::VRLB(u32 vd, u32 va, u32 vb) {
+void Compiler::VRLB(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VRLB", &PPUInterpreter::VRLB, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VRLH(u32 vd, u32 va, u32 vb) {
+void Compiler::VRLH(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VRLH", &PPUInterpreter::VRLH, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VRLW(u32 vd, u32 va, u32 vb) {
+void Compiler::VRLW(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VRLW", &PPUInterpreter::VRLW, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VRSQRTEFP(u32 vd, u32 vb) {
+void Compiler::VRSQRTEFP(u32 vd, u32 vb) {
     InterpreterCall("VRSQRTEFP", &PPUInterpreter::VRSQRTEFP, vd, vb);
 }
 
-void PPULLVMRecompiler::VSEL(u32 vd, u32 va, u32 vb, u32 vc) {
+void Compiler::VSEL(u32 vd, u32 va, u32 vb, u32 vc) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
     auto vc_v4i32 = GetVrAsIntVec(vc, 32);
@@ -1104,7 +1086,7 @@ void PPULLVMRecompiler::VSEL(u32 vd, u32 va, u32 vb, u32 vc) {
     SetVr(vd, vd_v4i32);
 }
 
-void PPULLVMRecompiler::VSL(u32 vd, u32 va, u32 vb) {
+void Compiler::VSL(u32 vd, u32 va, u32 vb) {
     auto va_i128  = GetVr(va);
     auto vb_v16i8 = GetVrAsIntVec(vb, 8);
     auto sh_i8    = m_ir_builder->CreateExtractElement(vb_v16i8, m_ir_builder->getInt8(0));
@@ -1114,7 +1096,7 @@ void PPULLVMRecompiler::VSL(u32 vd, u32 va, u32 vb) {
     SetVr(vd, va_i128);
 }
 
-void PPULLVMRecompiler::VSLB(u32 vd, u32 va, u32 vb) {
+void Compiler::VSLB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     vb_v16i8       = m_ir_builder->CreateAnd(vb_v16i8, m_ir_builder->CreateVectorSplat(16, m_ir_builder->getInt8(0x7)));
@@ -1122,7 +1104,7 @@ void PPULLVMRecompiler::VSLB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) {
+void Compiler::VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) {
     auto va_v16i8        = GetVrAsIntVec(va, 8);
     auto vb_v16i8        = GetVrAsIntVec(vb, 8);
     sh                   = 16 - sh;
@@ -1131,7 +1113,7 @@ void PPULLVMRecompiler::VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) {
     SetVr(vd, vd_v16i8);
 }
 
-void PPULLVMRecompiler::VSLH(u32 vd, u32 va, u32 vb) {
+void Compiler::VSLH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     vb_v8i16       = m_ir_builder->CreateAnd(vb_v8i16, m_ir_builder->CreateVectorSplat(8, m_ir_builder->getInt16(0xF)));
@@ -1139,7 +1121,7 @@ void PPULLVMRecompiler::VSLH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VSLO(u32 vd, u32 va, u32 vb) {
+void Compiler::VSLO(u32 vd, u32 va, u32 vb) {
     auto va_i128  = GetVr(va);
     auto vb_v16i8 = GetVrAsIntVec(vb, 8);
     auto sh_i8    = m_ir_builder->CreateExtractElement(vb_v16i8, m_ir_builder->getInt8(0));
@@ -1149,7 +1131,7 @@ void PPULLVMRecompiler::VSLO(u32 vd, u32 va, u32 vb) {
     SetVr(vd, va_i128);
 }
 
-void PPULLVMRecompiler::VSLW(u32 vd, u32 va, u32 vb) {
+void Compiler::VSLW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     vb_v4i32       = m_ir_builder->CreateAnd(vb_v4i32, m_ir_builder->CreateVectorSplat(4, m_ir_builder->getInt32(0x1F)));
@@ -1157,7 +1139,7 @@ void PPULLVMRecompiler::VSLW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VSPLTB(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::VSPLTB(u32 vd, u32 uimm5, u32 vb) {
     auto vb_v16i8    = GetVrAsIntVec(vb, 8);
     auto undef_v16i8 = UndefValue::get(VectorType::get(m_ir_builder->getInt8Ty(), 16));
     auto mask_v16i32 = m_ir_builder->CreateVectorSplat(16, m_ir_builder->getInt32(15 - uimm5));
@@ -1165,7 +1147,7 @@ void PPULLVMRecompiler::VSPLTB(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VSPLTH(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::VSPLTH(u32 vd, u32 uimm5, u32 vb) {
     auto vb_v8i16    = GetVrAsIntVec(vb, 16);
     auto undef_v8i16 = UndefValue::get(VectorType::get(m_ir_builder->getInt16Ty(), 8));
     auto mask_v8i32  = m_ir_builder->CreateVectorSplat(8, m_ir_builder->getInt32(7 - uimm5));
@@ -1173,22 +1155,22 @@ void PPULLVMRecompiler::VSPLTH(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VSPLTISB(u32 vd, s32 simm5) {
+void Compiler::VSPLTISB(u32 vd, s32 simm5) {
     auto vd_v16i8 = m_ir_builder->CreateVectorSplat(16, m_ir_builder->getInt8((s8)simm5));
     SetVr(vd, vd_v16i8);
 }
 
-void PPULLVMRecompiler::VSPLTISH(u32 vd, s32 simm5) {
+void Compiler::VSPLTISH(u32 vd, s32 simm5) {
     auto vd_v8i16 = m_ir_builder->CreateVectorSplat(8, m_ir_builder->getInt16((s16)simm5));
     SetVr(vd, vd_v8i16);
 }
 
-void PPULLVMRecompiler::VSPLTISW(u32 vd, s32 simm5) {
+void Compiler::VSPLTISW(u32 vd, s32 simm5) {
     auto vd_v4i32 = m_ir_builder->CreateVectorSplat(4, m_ir_builder->getInt32((s32)simm5));
     SetVr(vd, vd_v4i32);
 }
 
-void PPULLVMRecompiler::VSPLTW(u32 vd, u32 uimm5, u32 vb) {
+void Compiler::VSPLTW(u32 vd, u32 uimm5, u32 vb) {
     auto vb_v4i32    = GetVrAsIntVec(vb, 32);
     auto undef_v4i32 = UndefValue::get(VectorType::get(m_ir_builder->getInt32Ty(), 4));
     auto mask_v4i32  = m_ir_builder->CreateVectorSplat(4, m_ir_builder->getInt32(3 - uimm5));
@@ -1196,7 +1178,7 @@ void PPULLVMRecompiler::VSPLTW(u32 vd, u32 uimm5, u32 vb) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VSR(u32 vd, u32 va, u32 vb) {
+void Compiler::VSR(u32 vd, u32 va, u32 vb) {
     auto va_i128  = GetVr(va);
     auto vb_v16i8 = GetVrAsIntVec(vb, 8);
     auto sh_i8    = m_ir_builder->CreateExtractElement(vb_v16i8, m_ir_builder->getInt8(0));
@@ -1206,7 +1188,7 @@ void PPULLVMRecompiler::VSR(u32 vd, u32 va, u32 vb) {
     SetVr(vd, va_i128);
 }
 
-void PPULLVMRecompiler::VSRAB(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRAB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     vb_v16i8       = m_ir_builder->CreateAnd(vb_v16i8, m_ir_builder->CreateVectorSplat(16, m_ir_builder->getInt8(0x7)));
@@ -1214,7 +1196,7 @@ void PPULLVMRecompiler::VSRAB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VSRAH(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRAH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     vb_v8i16       = m_ir_builder->CreateAnd(vb_v8i16, m_ir_builder->CreateVectorSplat(8, m_ir_builder->getInt16(0xF)));
@@ -1222,7 +1204,7 @@ void PPULLVMRecompiler::VSRAH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VSRAW(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRAW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     vb_v4i32       = m_ir_builder->CreateAnd(vb_v4i32, m_ir_builder->CreateVectorSplat(4, m_ir_builder->getInt32(0x1F)));
@@ -1230,7 +1212,7 @@ void PPULLVMRecompiler::VSRAW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VSRB(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRB(u32 vd, u32 va, u32 vb) {
     auto va_v16i8  = GetVrAsIntVec(va, 8);
     auto vb_v16i8  = GetVrAsIntVec(vb, 8);
     vb_v16i8       = m_ir_builder->CreateAnd(vb_v16i8, m_ir_builder->CreateVectorSplat(16, m_ir_builder->getInt8(0x7)));
@@ -1238,7 +1220,7 @@ void PPULLVMRecompiler::VSRB(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v16i8);
 }
 
-void PPULLVMRecompiler::VSRH(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRH(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     vb_v8i16       = m_ir_builder->CreateAnd(vb_v8i16, m_ir_builder->CreateVectorSplat(8, m_ir_builder->getInt16(0xF)));
@@ -1246,7 +1228,7 @@ void PPULLVMRecompiler::VSRH(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::VSRO(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRO(u32 vd, u32 va, u32 vb) {
     auto va_i128  = GetVr(va);
     auto vb_v16i8 = GetVrAsIntVec(vb, 8);
     auto sh_i8    = m_ir_builder->CreateExtractElement(vb_v16i8, m_ir_builder->getInt8(0));
@@ -1256,7 +1238,7 @@ void PPULLVMRecompiler::VSRO(u32 vd, u32 va, u32 vb) {
     SetVr(vd, va_i128);
 }
 
-void PPULLVMRecompiler::VSRW(u32 vd, u32 va, u32 vb) {
+void Compiler::VSRW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32  = GetVrAsIntVec(va, 32);
     auto vb_v4i32  = GetVrAsIntVec(vb, 32);
     vb_v4i32       = m_ir_builder->CreateAnd(vb_v4i32, m_ir_builder->CreateVectorSplat(4, m_ir_builder->getInt32(0x1F)));
@@ -1264,7 +1246,7 @@ void PPULLVMRecompiler::VSRW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, res_v4i32);
 }
 
-void PPULLVMRecompiler::VSUBCUW(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBCUW(u32 vd, u32 va, u32 vb) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
 
@@ -1273,14 +1255,14 @@ void PPULLVMRecompiler::VSUBCUW(u32 vd, u32 va, u32 vb) {
     SetVr(vd, cmpv4i32);
 }
 
-void PPULLVMRecompiler::VSUBFP(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBFP(u32 vd, u32 va, u32 vb) {
     auto va_v4f32   = GetVrAsFloatVec(va);
     auto vb_v4f32   = GetVrAsFloatVec(vb);
     auto diff_v4f32 = m_ir_builder->CreateFSub(va_v4f32, vb_v4f32);
     SetVr(vd, diff_v4f32);
 }
 
-void PPULLVMRecompiler::VSUBSBS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBSBS(u32 vd, u32 va, u32 vb) {
     auto va_v16i8   = GetVrAsIntVec(va, 8);
     auto vb_v16i8   = GetVrAsIntVec(vb, 8);
     auto diff_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_psubs_b), va_v16i8, vb_v16i8);
@@ -1289,7 +1271,7 @@ void PPULLVMRecompiler::VSUBSBS(u32 vd, u32 va, u32 vb) {
     // TODO: Set VSCR.SAT
 }
 
-void PPULLVMRecompiler::VSUBSHS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBSHS(u32 vd, u32 va, u32 vb) {
     auto va_v8i16   = GetVrAsIntVec(va, 16);
     auto vb_v8i16   = GetVrAsIntVec(vb, 16);
     auto diff_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_psubs_w), va_v8i16, vb_v8i16);
@@ -1298,7 +1280,7 @@ void PPULLVMRecompiler::VSUBSHS(u32 vd, u32 va, u32 vb) {
     // TODO: Set VSCR.SAT
 }
 
-void PPULLVMRecompiler::VSUBSWS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBSWS(u32 vd, u32 va, u32 vb) {
     auto va_v4i32 = GetVrAsIntVec(va, 32);
     auto vb_v4i32 = GetVrAsIntVec(vb, 32);
 
@@ -1329,14 +1311,14 @@ void PPULLVMRecompiler::VSUBSWS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VSUBUBM(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBUBM(u32 vd, u32 va, u32 vb) {
     auto va_v16i8   = GetVrAsIntVec(va, 8);
     auto vb_v16i8   = GetVrAsIntVec(vb, 8);
     auto diff_v16i8 = m_ir_builder->CreateSub(va_v16i8, vb_v16i8);
     SetVr(vd, diff_v16i8);
 }
 
-void PPULLVMRecompiler::VSUBUBS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBUBS(u32 vd, u32 va, u32 vb) {
     auto va_v16i8   = GetVrAsIntVec(va, 8);
     auto vb_v16i8   = GetVrAsIntVec(vb, 8);
     auto diff_v16i8 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_psubus_b), va_v16i8, vb_v16i8);
@@ -1345,14 +1327,14 @@ void PPULLVMRecompiler::VSUBUBS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VSUBUHM(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBUHM(u32 vd, u32 va, u32 vb) {
     auto va_v8i16   = GetVrAsIntVec(va, 16);
     auto vb_v8i16   = GetVrAsIntVec(vb, 16);
     auto diff_v8i16 = m_ir_builder->CreateSub(va_v8i16, vb_v8i16);
     SetVr(vd, diff_v8i16);
 }
 
-void PPULLVMRecompiler::VSUBUHS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBUHS(u32 vd, u32 va, u32 vb) {
     auto va_v8i16   = GetVrAsIntVec(va, 16);
     auto vb_v8i16   = GetVrAsIntVec(vb, 16);
     auto diff_v8i16 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_psubus_w), va_v8i16, vb_v8i16);
@@ -1361,14 +1343,14 @@ void PPULLVMRecompiler::VSUBUHS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VSUBUWM(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBUWM(u32 vd, u32 va, u32 vb) {
     auto va_v4i32   = GetVrAsIntVec(va, 32);
     auto vb_v4i32   = GetVrAsIntVec(vb, 32);
     auto diff_v4i32 = m_ir_builder->CreateSub(va_v4i32, vb_v4i32);
     SetVr(vd, diff_v4i32);
 }
 
-void PPULLVMRecompiler::VSUBUWS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUBUWS(u32 vd, u32 va, u32 vb) {
     auto va_v4i32   = GetVrAsIntVec(va, 32);
     auto vb_v4i32   = GetVrAsIntVec(vb, 32);
     auto diff_v4i32 = m_ir_builder->CreateSub(va_v4i32, vb_v4i32);
@@ -1380,65 +1362,65 @@ void PPULLVMRecompiler::VSUBUWS(u32 vd, u32 va, u32 vb) {
     // TODO: Set SAT
 }
 
-void PPULLVMRecompiler::VSUMSWS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUMSWS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUMSWS", &PPUInterpreter::VSUMSWS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VSUM2SWS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUM2SWS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM2SWS", &PPUInterpreter::VSUM2SWS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VSUM4SBS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUM4SBS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM4SBS", &PPUInterpreter::VSUM4SBS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VSUM4SHS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUM4SHS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM4SHS", &PPUInterpreter::VSUM4SHS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VSUM4UBS(u32 vd, u32 va, u32 vb) {
+void Compiler::VSUM4UBS(u32 vd, u32 va, u32 vb) {
     InterpreterCall("VSUM4UBS", &PPUInterpreter::VSUM4UBS, vd, va, vb);
 }
 
-void PPULLVMRecompiler::VUPKHPX(u32 vd, u32 vb) {
+void Compiler::VUPKHPX(u32 vd, u32 vb) {
     InterpreterCall("VUPKHPX", &PPUInterpreter::VUPKHPX, vd, vb);
 }
 
-void PPULLVMRecompiler::VUPKHSB(u32 vd, u32 vb) {
+void Compiler::VUPKHSB(u32 vd, u32 vb) {
     InterpreterCall("VUPKHSB", &PPUInterpreter::VUPKHSB, vd, vb);
 }
 
-void PPULLVMRecompiler::VUPKHSH(u32 vd, u32 vb) {
+void Compiler::VUPKHSH(u32 vd, u32 vb) {
     InterpreterCall("VUPKHSH", &PPUInterpreter::VUPKHSH, vd, vb);
 }
 
-void PPULLVMRecompiler::VUPKLPX(u32 vd, u32 vb) {
+void Compiler::VUPKLPX(u32 vd, u32 vb) {
     InterpreterCall("VUPKLPX", &PPUInterpreter::VUPKLPX, vd, vb);
 }
 
-void PPULLVMRecompiler::VUPKLSB(u32 vd, u32 vb) {
+void Compiler::VUPKLSB(u32 vd, u32 vb) {
     InterpreterCall("VUPKLSB", &PPUInterpreter::VUPKLSB, vd, vb);
 }
 
-void PPULLVMRecompiler::VUPKLSH(u32 vd, u32 vb) {
+void Compiler::VUPKLSH(u32 vd, u32 vb) {
     InterpreterCall("VUPKLSH", &PPUInterpreter::VUPKLSH, vd, vb);
 }
 
-void PPULLVMRecompiler::VXOR(u32 vd, u32 va, u32 vb) {
+void Compiler::VXOR(u32 vd, u32 va, u32 vb) {
     auto va_v8i16  = GetVrAsIntVec(va, 16);
     auto vb_v8i16  = GetVrAsIntVec(vb, 16);
     auto res_v8i16 = m_ir_builder->CreateXor(va_v8i16, vb_v8i16);
     SetVr(vd, res_v8i16);
 }
 
-void PPULLVMRecompiler::MULLI(u32 rd, u32 ra, s32 simm16) {
+void Compiler::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 PPULLVMRecompiler::SUBFIC(u32 rd, u32 ra, s32 simm16) {
+void Compiler::SUBFIC(u32 rd, u32 ra, s32 simm16) {
     auto ra_i64   = GetGpr(ra);
     ra_i64        = m_ir_builder->CreateNeg(ra_i64);
     auto res_s    = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::uadd_with_overflow, m_ir_builder->getInt64Ty()), ra_i64, m_ir_builder->getInt64((s64)simm16));
@@ -1449,7 +1431,7 @@ void PPULLVMRecompiler::SUBFIC(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("SUBFIC", &PPUInterpreter::SUBFIC, rd, ra, simm16);
 }
 
-void PPULLVMRecompiler::CMPLI(u32 crfd, u32 l, u32 ra, u32 uimm16) {
+void Compiler::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());
@@ -1461,7 +1443,7 @@ void PPULLVMRecompiler::CMPLI(u32 crfd, u32 l, u32 ra, u32 uimm16) {
     //InterpreterCall("CMPLI", &PPUInterpreter::CMPLI, crfd, l, ra, uimm16);
 }
 
-void PPULLVMRecompiler::CMPI(u32 crfd, u32 l, u32 ra, s32 simm16) {
+void Compiler::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());
@@ -1473,7 +1455,7 @@ void PPULLVMRecompiler::CMPI(u32 crfd, u32 l, u32 ra, s32 simm16) {
     //InterpreterCall("CMPI", &PPUInterpreter::CMPI, crfd, l, ra, simm16);
 }
 
-void PPULLVMRecompiler::ADDIC(u32 rd, u32 ra, s32 simm16) {
+void Compiler::ADDIC(u32 rd, u32 ra, s32 simm16) {
     auto ra_i64   = GetGpr(ra);
     auto res_s    = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::uadd_with_overflow, m_ir_builder->getInt64Ty()), m_ir_builder->getInt64((s64)simm16), ra_i64);
     auto sum_i64  = m_ir_builder->CreateExtractValue(res_s, {0});
@@ -1483,13 +1465,13 @@ void PPULLVMRecompiler::ADDIC(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("ADDIC", &PPUInterpreter::ADDIC, rd, ra, simm16);
 }
 
-void PPULLVMRecompiler::ADDIC_(u32 rd, u32 ra, s32 simm16) {
+void Compiler::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 PPULLVMRecompiler::ADDI(u32 rd, u32 ra, s32 simm16) {
+void Compiler::ADDI(u32 rd, u32 ra, s32 simm16) {
     if (ra == 0) {
         SetGpr(rd, m_ir_builder->getInt64((s64)simm16));
     } else {
@@ -1500,7 +1482,7 @@ void PPULLVMRecompiler::ADDI(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("ADDI", &PPUInterpreter::ADDI, rd, ra, simm16);
 }
 
-void PPULLVMRecompiler::ADDIS(u32 rd, u32 ra, s32 simm16) {
+void Compiler::ADDIS(u32 rd, u32 ra, s32 simm16) {
     if (ra == 0) {
         SetGpr(rd, m_ir_builder->getInt64((s64)simm16 << 16));
     } else {
@@ -1511,7 +1493,7 @@ void PPULLVMRecompiler::ADDIS(u32 rd, u32 ra, s32 simm16) {
     //InterpreterCall("ADDIS", &PPUInterpreter::ADDIS, rd, ra, simm16);
 }
 
-void PPULLVMRecompiler::BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) {
+void Compiler::BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) {
     auto target_i64 = m_ir_builder->getInt64(branchTarget(aa ? 0 : m_current_instruction_address, bd));
     CreateBranch(CheckBranchCondition(bo, bi), target_i64, lk ? true : false);
     //m_hit_branch_instruction = true;
@@ -1521,11 +1503,11 @@ void PPULLVMRecompiler::BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) {
     //m_ir_builder->CreateRetVoid();
 }
 
-void PPULLVMRecompiler::SC(u32 sc_code) {
+void Compiler::SC(u32 sc_code) {
     InterpreterCall("SC", &PPUInterpreter::SC, sc_code);
 }
 
-void PPULLVMRecompiler::B(s32 ll, u32 aa, u32 lk) {
+void Compiler::B(s32 ll, u32 aa, u32 lk) {
     auto target_i64 = m_ir_builder->getInt64(branchTarget(aa ? 0 : m_current_instruction_address, ll));
     CreateBranch(nullptr, target_i64, lk ? true : false);
     //m_hit_branch_instruction = true;
@@ -1534,7 +1516,7 @@ void PPULLVMRecompiler::B(s32 ll, u32 aa, u32 lk) {
     //m_ir_builder->CreateRetVoid();
 }
 
-void PPULLVMRecompiler::MCRF(u32 crfd, u32 crfs) {
+void Compiler::MCRF(u32 crfd, u32 crfs) {
     if (crfd != crfs) {
         auto cr_i32  = GetCr();
         auto crf_i32 = GetNibble(cr_i32, crfs);
@@ -1544,10 +1526,10 @@ void PPULLVMRecompiler::MCRF(u32 crfd, u32 crfs) {
     //InterpreterCall("MCRF", &PPUInterpreter::MCRF, crfd, crfs);
 }
 
-void PPULLVMRecompiler::BCLR(u32 bo, u32 bi, u32 bh, u32 lk) {
+void Compiler::BCLR(u32 bo, u32 bi, u32 bh, u32 lk) {
     auto lr_i64 = GetLr();
     lr_i64      = m_ir_builder->CreateAnd(lr_i64, ~0x3ULL);
-    CreateBranch(CheckBranchCondition(bo, bi), lr_i64, lk ? true : false);
+    CreateBranch(CheckBranchCondition(bo, bi), lr_i64, lk ? true : false, true);
     //m_hit_branch_instruction = true;
     //SetPc(m_ir_builder->getInt32(m_current_instruction_address));
     //InterpreterCall("BCLR", &PPUInterpreter::BCLR, bo, bi, bh, lk);
@@ -1555,7 +1537,7 @@ void PPULLVMRecompiler::BCLR(u32 bo, u32 bi, u32 bh, u32 lk) {
     //m_ir_builder->CreateRetVoid();
 }
 
-void PPULLVMRecompiler::CRNOR(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1566,7 +1548,7 @@ void PPULLVMRecompiler::CRNOR(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRNOR", &PPUInterpreter::CRNOR, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::CRANDC(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1577,12 +1559,12 @@ void PPULLVMRecompiler::CRANDC(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRANDC", &PPUInterpreter::CRANDC, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::ISYNC() {
+void Compiler::ISYNC() {
     m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_mfence));
     //InterpreterCall("ISYNC", &PPUInterpreter::ISYNC);
 }
 
-void PPULLVMRecompiler::CRXOR(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1592,7 +1574,7 @@ void PPULLVMRecompiler::CRXOR(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRXOR", &PPUInterpreter::CRXOR, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::CRNAND(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1603,7 +1585,7 @@ void PPULLVMRecompiler::CRNAND(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRNAND", &PPUInterpreter::CRNAND, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::CRAND(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1613,7 +1595,7 @@ void PPULLVMRecompiler::CRAND(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRAND", &PPUInterpreter::CRAND, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::CREQV(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1624,7 +1606,7 @@ void PPULLVMRecompiler::CREQV(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CREQV", &PPUInterpreter::CREQV, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::CRORC(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1635,7 +1617,7 @@ void PPULLVMRecompiler::CRORC(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CRORC", &PPUInterpreter::CRORC, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::CROR(u32 crbd, u32 crba, u32 crbb) {
+void Compiler::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);
@@ -1645,7 +1627,7 @@ void PPULLVMRecompiler::CROR(u32 crbd, u32 crba, u32 crbb) {
     //InterpreterCall("CROR", &PPUInterpreter::CROR, crbd, crba, crbb);
 }
 
-void PPULLVMRecompiler::BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) {
+void Compiler::BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) {
     auto ctr_i64 = GetCtr();
     ctr_i64      = m_ir_builder->CreateAnd(ctr_i64, ~0x3ULL);
     CreateBranch(CheckBranchCondition(bo, bi), ctr_i64, lk ? true : false);
@@ -1656,7 +1638,7 @@ void PPULLVMRecompiler::BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) {
     //m_ir_builder->CreateRetVoid();
 }
 
-void PPULLVMRecompiler::RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
+void Compiler::RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto rs_i64  = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     auto rsh_i64 = m_ir_builder->CreateShl(rs_i64, 32);
@@ -1681,7 +1663,7 @@ 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 PPULLVMRecompiler::RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
+void Compiler::RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto rs_i64  = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     auto rsh_i64 = m_ir_builder->CreateShl(rs_i64, 32);
@@ -1702,7 +1684,7 @@ 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 PPULLVMRecompiler::RLWNM(u32 ra, u32 rs, u32 rb, u32 mb, u32 me, bool rc) {
+void Compiler::RLWNM(u32 ra, u32 rs, u32 rb, u32 mb, u32 me, bool rc) {
     auto rs_i32   = GetGpr(rs, 32);
     auto rs_i64   = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     auto rsh_i64  = m_ir_builder->CreateShl(rs_i64, 32);
@@ -1722,35 +1704,35 @@ 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 PPULLVMRecompiler::ORI(u32 ra, u32 rs, u32 uimm16) {
+void Compiler::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 PPULLVMRecompiler::ORIS(u32 ra, u32 rs, u32 uimm16) {
+void Compiler::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 PPULLVMRecompiler::XORI(u32 ra, u32 rs, u32 uimm16) {
+void Compiler::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 PPULLVMRecompiler::XORIS(u32 ra, u32 rs, u32 uimm16) {
+void Compiler::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 PPULLVMRecompiler::ANDI_(u32 ra, u32 rs, u32 uimm16) {
+void Compiler::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);
@@ -1758,7 +1740,7 @@ void PPULLVMRecompiler::ANDI_(u32 ra, u32 rs, u32 uimm16) {
     //InterpreterCall("ANDI_", &PPUInterpreter::ANDI_, ra, rs, uimm16);
 }
 
-void PPULLVMRecompiler::ANDIS_(u32 ra, u32 rs, u32 uimm16) {
+void Compiler::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);
@@ -1766,7 +1748,7 @@ void PPULLVMRecompiler::ANDIS_(u32 ra, u32 rs, u32 uimm16) {
     //InterpreterCall("ANDIS_", &PPUInterpreter::ANDIS_, ra, rs, uimm16);
 }
 
-void PPULLVMRecompiler::RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
+void Compiler::RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = rs_i64;
     if (sh) {
@@ -1784,7 +1766,7 @@ void PPULLVMRecompiler::RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     //InterpreterCall("RLDICL", &PPUInterpreter::RLDICL, ra, rs, sh, mb, rc);
 }
 
-void PPULLVMRecompiler::RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) {
+void Compiler::RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = rs_i64;
     if (sh) {
@@ -1802,7 +1784,7 @@ void PPULLVMRecompiler::RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) {
     //InterpreterCall("RLDICR", &PPUInterpreter::RLDICR, ra, rs, sh, me, rc);
 }
 
-void PPULLVMRecompiler::RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
+void Compiler::RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = rs_i64;
     if (sh) {
@@ -1820,7 +1802,7 @@ void PPULLVMRecompiler::RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     //InterpreterCall("RLDIC", &PPUInterpreter::RLDIC, ra, rs, sh, mb, rc);
 }
 
-void PPULLVMRecompiler::RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
+void Compiler::RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto ra_i64  = GetGpr(ra);
     auto res_i64 = rs_i64;
@@ -1842,7 +1824,7 @@ void PPULLVMRecompiler::RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) {
     //InterpreterCall("RLDIMI", &PPUInterpreter::RLDIMI, ra, rs, sh, mb, rc);
 }
 
-void PPULLVMRecompiler::RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) {
+void Compiler::RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) {
     auto rs_i64   = GetGpr(rs);
     auto rb_i64   = GetGpr(rb);
     auto shl_i64  = m_ir_builder->CreateAnd(rb_i64, 0x3F);
@@ -1865,7 +1847,7 @@ void PPULLVMRecompiler::RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, boo
     //InterpreterCall("RLDC_LR", &PPUInterpreter::RLDC_LR, ra, rs, rb, m_eb, is_r, rc);
 }
 
-void PPULLVMRecompiler::CMP(u32 crfd, u32 l, u32 ra, u32 rb) {
+void Compiler::CMP(u32 crfd, u32 l, u32 ra, u32 rb) {
     Value * ra_i64;
     Value * rb_i64;
     if (l == 0) {
@@ -1880,11 +1862,11 @@ void PPULLVMRecompiler::CMP(u32 crfd, u32 l, u32 ra, u32 rb) {
     //InterpreterCall("CMP", &PPUInterpreter::CMP, crfd, l, ra, rb);
 }
 
-void PPULLVMRecompiler::TW(u32 to, u32 ra, u32 rb) {
+void Compiler::TW(u32 to, u32 ra, u32 rb) {
     InterpreterCall("TW", &PPUInterpreter::TW, to, ra, rb);
 }
 
-void PPULLVMRecompiler::LVSL(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVSL(u32 vd, u32 ra, u32 rb) {
     static const u128 s_lvsl_values[] = {
         {0x08090A0B0C0D0E0F, 0x0001020304050607},
         {0x090A0B0C0D0E0F10, 0x0102030405060708},
@@ -1919,7 +1901,7 @@ void PPULLVMRecompiler::LVSL(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVSL", &PPUInterpreter::LVSL, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::LVEBX(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVEBX(u32 vd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -1936,7 +1918,7 @@ void PPULLVMRecompiler::LVEBX(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVEBX", &PPUInterpreter::LVEBX, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64    = GetGpr(ra);
     ra_i64         = m_ir_builder->CreateNeg(ra_i64);
     auto rb_i64    = GetGpr(rb);
@@ -1956,7 +1938,7 @@ void PPULLVMRecompiler::SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("SUBFC", &PPUInterpreter::SUBFC, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64   = GetGpr(ra);
     auto rb_i64   = GetGpr(rb);
     auto res_s    = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::uadd_with_overflow, m_ir_builder->getInt64Ty()), ra_i64, rb_i64);
@@ -1975,7 +1957,7 @@ void PPULLVMRecompiler::ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("ADDC", &PPUInterpreter::ADDC, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::MULHDU(u32 rd, u32 ra, u32 rb, bool rc) {
+void Compiler::MULHDU(u32 rd, u32 ra, u32 rb, bool rc) {
     auto ra_i64    = GetGpr(ra);
     auto rb_i64    = GetGpr(rb);
     auto ra_i128   = m_ir_builder->CreateZExt(ra_i64, m_ir_builder->getIntNTy(128));
@@ -1992,7 +1974,7 @@ void PPULLVMRecompiler::MULHDU(u32 rd, u32 ra, u32 rb, bool rc) {
     //InterpreterCall("MULHDU", &PPUInterpreter::MULHDU, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompiler::MULHWU(u32 rd, u32 ra, u32 rb, bool rc) {
+void Compiler::MULHWU(u32 rd, u32 ra, u32 rb, bool rc) {
     auto ra_i32   = GetGpr(ra, 32);
     auto rb_i32   = GetGpr(rb, 32);
     auto ra_i64   = m_ir_builder->CreateZExt(ra_i32, m_ir_builder->getInt64Ty());
@@ -2007,27 +1989,27 @@ void PPULLVMRecompiler::MULHWU(u32 rd, u32 ra, u32 rb, bool rc) {
     //InterpreterCall("MULHWU", &PPUInterpreter::MULHWU, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompiler::MFOCRF(u32 a, u32 rd, u32 crm) {
+void Compiler::MFOCRF(u32 a, u32 rd, u32 crm) {
     auto cr_i32 = GetCr();
     auto cr_i64 = m_ir_builder->CreateZExt(cr_i32, m_ir_builder->getInt64Ty());
     SetGpr(rd, cr_i64);
     //InterpreterCall("MFOCRF", &PPUInterpreter::MFOCRF, a, rd, crm);
 }
 
-void PPULLVMRecompiler::LWARX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LWARX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
         addr_i64    = m_ir_builder->CreateAdd(ra_i64, addr_i64);
     }
 
-    auto resv_addr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, R_ADDR));
+    auto resv_addr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, R_ADDR));
     auto resv_addr_i64_ptr = m_ir_builder->CreateBitCast(resv_addr_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(addr_i64, resv_addr_i64_ptr, 8);
 
     auto resv_val_i32     = ReadMemory(addr_i64, 32, 4, false, false);
     auto resv_val_i64     = m_ir_builder->CreateZExt(resv_val_i32, m_ir_builder->getInt64Ty());
-    auto resv_val_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, R_VALUE));
+    auto resv_val_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, R_VALUE));
     auto resv_val_i64_ptr = m_ir_builder->CreateBitCast(resv_val_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(resv_val_i64, resv_val_i64_ptr, 8);
 
@@ -2037,7 +2019,7 @@ void PPULLVMRecompiler::LWARX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWARX", &PPUInterpreter::LWARX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LDX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LDX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2049,7 +2031,7 @@ void PPULLVMRecompiler::LDX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDX", &PPUInterpreter::LDX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LWZX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LWZX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2062,7 +2044,7 @@ void PPULLVMRecompiler::LWZX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWZX", &PPUInterpreter::LWZX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::SLW(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::SLW(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto rs_i64  = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     auto rb_i8   = GetGpr(rb, 8);
@@ -2080,7 +2062,7 @@ void PPULLVMRecompiler::SLW(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("SLW", &PPUInterpreter::SLW, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::CNTLZW(u32 ra, u32 rs, bool rc) {
+void Compiler::CNTLZW(u32 ra, u32 rs, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto res_i32 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::ctlz, m_ir_builder->getInt32Ty()), rs_i32, m_ir_builder->getInt1(false));
     auto res_i64 = m_ir_builder->CreateZExt(res_i32, m_ir_builder->getInt64Ty());
@@ -2093,7 +2075,7 @@ void PPULLVMRecompiler::CNTLZW(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("CNTLZW", &PPUInterpreter::CNTLZW, ra, rs, rc);
 }
 
-void PPULLVMRecompiler::SLD(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::SLD(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i64   = GetGpr(rs);
     auto rs_i128  = m_ir_builder->CreateZExt(rs_i64, m_ir_builder->getIntNTy(128));
     auto rb_i8    = GetGpr(rb, 8);
@@ -2110,7 +2092,7 @@ void PPULLVMRecompiler::SLD(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("SLD", &PPUInterpreter::SLD, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::AND(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::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);
@@ -2122,7 +2104,7 @@ void PPULLVMRecompiler::AND(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("AND", &PPUInterpreter::AND, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::CMPL(u32 crfd, u32 l, u32 ra, u32 rb) {
+void Compiler::CMPL(u32 crfd, u32 l, u32 ra, u32 rb) {
     Value * ra_i64;
     Value * rb_i64;
     if (l == 0) {
@@ -2137,7 +2119,7 @@ void PPULLVMRecompiler::CMPL(u32 crfd, u32 l, u32 ra, u32 rb) {
     //InterpreterCall("CMPL", &PPUInterpreter::CMPL, crfd, l, ra, rb);
 }
 
-void PPULLVMRecompiler::LVSR(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVSR(u32 vd, u32 ra, u32 rb) {
     static const u128 s_lvsr_values[] = {
         {0x18191A1B1C1D1E1F, 0x1011121314151617},
         {0x1718191A1B1C1D1E, 0x0F10111213141516},
@@ -2172,7 +2154,7 @@ void PPULLVMRecompiler::LVSR(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVSR", &PPUInterpreter::LVSR, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::LVEHX(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVEHX(u32 vd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2191,7 +2173,7 @@ void PPULLVMRecompiler::LVEHX(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVEHX", &PPUInterpreter::LVEHX, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64   = GetGpr(ra);
     auto rb_i64   = GetGpr(rb);
     auto diff_i64 = m_ir_builder->CreateSub(rb_i64, ra_i64);
@@ -2207,7 +2189,7 @@ void PPULLVMRecompiler::SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("SUBF", &PPUInterpreter::SUBF, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::LDUX(u32 rd, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2218,12 +2200,12 @@ void PPULLVMRecompiler::LDUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDUX", &PPUInterpreter::LDUX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::DCBST(u32 ra, u32 rb) {
+void Compiler::DCBST(u32 ra, u32 rb) {
     // TODO: Implement this
     //InterpreterCall("DCBST", &PPUInterpreter::DCBST, ra, rb);
 }
 
-void PPULLVMRecompiler::LWZUX(u32 rd, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2235,7 +2217,7 @@ void PPULLVMRecompiler::LWZUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWZUX", &PPUInterpreter::LWZUX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::CNTLZD(u32 ra, u32 rs, bool rc) {
+void Compiler::CNTLZD(u32 ra, u32 rs, bool rc) {
     auto rs_i64  = GetGpr(rs);
     auto res_i64 = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::ctlz, m_ir_builder->getInt64Ty()), rs_i64, m_ir_builder->getInt1(false));
     SetGpr(ra, res_i64);
@@ -2247,15 +2229,15 @@ void PPULLVMRecompiler::CNTLZD(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("CNTLZD", &PPUInterpreter::CNTLZD, ra, rs, rc);
 }
 
-void PPULLVMRecompiler::ANDC(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::ANDC(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("ANDC", &PPUInterpreter::ANDC, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::TD(u32 to, u32 ra, u32 rb) {
+void Compiler::TD(u32 to, u32 ra, u32 rb) {
     InterpreterCall("TD", &PPUInterpreter::TD, to, ra, rb);
 }
 
-void PPULLVMRecompiler::LVEWX(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVEWX(u32 vd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2274,7 +2256,7 @@ void PPULLVMRecompiler::LVEWX(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVEWX", &PPUInterpreter::LVEWX, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::MULHD(u32 rd, u32 ra, u32 rb, bool rc) {
+void Compiler::MULHD(u32 rd, u32 ra, u32 rb, bool rc) {
     auto ra_i64    = GetGpr(ra);
     auto rb_i64    = GetGpr(rb);
     auto ra_i128   = m_ir_builder->CreateSExt(ra_i64, m_ir_builder->getIntNTy(128));
@@ -2291,7 +2273,7 @@ void PPULLVMRecompiler::MULHD(u32 rd, u32 ra, u32 rb, bool rc) {
     //InterpreterCall("MULHD", &PPUInterpreter::MULHD, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompiler::MULHW(u32 rd, u32 ra, u32 rb, bool rc) {
+void Compiler::MULHW(u32 rd, u32 ra, u32 rb, bool rc) {
     auto ra_i32   = GetGpr(ra, 32);
     auto rb_i32   = GetGpr(rb, 32);
     auto ra_i64   = m_ir_builder->CreateSExt(ra_i32, m_ir_builder->getInt64Ty());
@@ -2306,19 +2288,19 @@ void PPULLVMRecompiler::MULHW(u32 rd, u32 ra, u32 rb, bool rc) {
     //InterpreterCall("MULHW", &PPUInterpreter::MULHW, rd, ra, rb, rc);
 }
 
-void PPULLVMRecompiler::LDARX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LDARX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
         addr_i64    = m_ir_builder->CreateAdd(ra_i64, addr_i64);
     }
 
-    auto resv_addr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, R_ADDR));
+    auto resv_addr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, R_ADDR));
     auto resv_addr_i64_ptr = m_ir_builder->CreateBitCast(resv_addr_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(addr_i64, resv_addr_i64_ptr, 8);
 
     auto resv_val_i64     = ReadMemory(addr_i64, 64, 8, false);
-    auto resv_val_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, R_VALUE));
+    auto resv_val_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, R_VALUE));
     auto resv_val_i64_ptr = m_ir_builder->CreateBitCast(resv_val_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(resv_val_i64, resv_val_i64_ptr, 8);
 
@@ -2327,12 +2309,12 @@ void PPULLVMRecompiler::LDARX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDARX", &PPUInterpreter::LDARX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::DCBF(u32 ra, u32 rb) {
+void Compiler::DCBF(u32 ra, u32 rb) {
     // TODO: Implement this
     //InterpreterCall("DCBF", &PPUInterpreter::DCBF, ra, rb);
 }
 
-void PPULLVMRecompiler::LBZX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LBZX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2345,7 +2327,7 @@ void PPULLVMRecompiler::LBZX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LBZX", &PPUInterpreter::LBZX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LVX(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVX(u32 vd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2358,7 +2340,7 @@ void PPULLVMRecompiler::LVX(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVX", &PPUInterpreter::LVX, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::NEG(u32 rd, u32 ra, u32 oe, bool rc) {
+void Compiler::NEG(u32 rd, u32 ra, u32 oe, bool rc) {
     auto ra_i64   = GetGpr(ra);
     auto diff_i64 = m_ir_builder->CreateSub(m_ir_builder->getInt64(0), ra_i64);
     SetGpr(rd, diff_i64);
@@ -2373,7 +2355,7 @@ void PPULLVMRecompiler::NEG(u32 rd, u32 ra, u32 oe, bool rc) {
     //InterpreterCall("NEG", &PPUInterpreter::NEG, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompiler::LBZUX(u32 rd, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2385,7 +2367,7 @@ void PPULLVMRecompiler::LBZUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LBZUX", &PPUInterpreter::LBZUX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::NOR(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::NOR(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);
@@ -2398,7 +2380,7 @@ void PPULLVMRecompiler::NOR(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("NOR", &PPUInterpreter::NOR, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::STVEBX(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVEBX(u32 vs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2413,15 +2395,15 @@ void PPULLVMRecompiler::STVEBX(u32 vs, u32 ra, u32 rb) {
     //InterpreterCall("STVEBX", &PPUInterpreter::STVEBX, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("SUBFE", &PPUInterpreter::SUBFE, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     InterpreterCall("ADDE", &PPUInterpreter::ADDE, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::MTOCRF(u32 l, u32 crm, u32 rs) {
+void Compiler::MTOCRF(u32 l, u32 crm, u32 rs) {
     auto rs_i32 = GetGpr(rs, 32);
     auto cr_i32 = GetCr();
     u32  mask   = 0;
@@ -2442,7 +2424,7 @@ void PPULLVMRecompiler::MTOCRF(u32 l, u32 crm, u32 rs) {
     //InterpreterCall("MTOCRF", &PPUInterpreter::MTOCRF, l, crm, rs);
 }
 
-void PPULLVMRecompiler::STDX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STDX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2453,11 +2435,11 @@ void PPULLVMRecompiler::STDX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STDX", &PPUInterpreter::STDX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STWCX_(u32 rs, u32 ra, u32 rb) {
+void Compiler::STWCX_(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STWCX_", &PPUInterpreter::STWCX_, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STWX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STWX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2468,7 +2450,7 @@ void PPULLVMRecompiler::STWX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STWX", &PPUInterpreter::STWX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STVEHX(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVEHX(u32 vs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2485,7 +2467,7 @@ void PPULLVMRecompiler::STVEHX(u32 vs, u32 ra, u32 rb) {
     //InterpreterCall("STVEHX", &PPUInterpreter::STVEHX, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::STDUX(u32 rs, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2495,7 +2477,7 @@ void PPULLVMRecompiler::STDUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STDUX", &PPUInterpreter::STDUX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STWUX(u32 rs, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2505,7 +2487,7 @@ void PPULLVMRecompiler::STWUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STWUX", &PPUInterpreter::STWUX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STVEWX(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVEWX(u32 vs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2522,7 +2504,7 @@ void PPULLVMRecompiler::STVEWX(u32 vs, u32 ra, u32 rb) {
     //InterpreterCall("STVEWX", &PPUInterpreter::STVEWX, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::ADDZE(u32 rd, u32 ra, u32 oe, bool rc) {
+void Compiler::ADDZE(u32 rd, u32 ra, u32 oe, bool rc) {
     auto ra_i64   = GetGpr(ra);
     auto ca_i64   = GetXerCa();
     auto res_s    = m_ir_builder->CreateCall2(Intrinsic::getDeclaration(m_module, Intrinsic::uadd_with_overflow, m_ir_builder->getInt64Ty()), ra_i64, ca_i64);
@@ -2537,15 +2519,15 @@ void PPULLVMRecompiler::ADDZE(u32 rd, u32 ra, u32 oe, bool rc) {
     //InterpreterCall("ADDZE", &PPUInterpreter::ADDZE, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompiler::SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) {
+void Compiler::SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("SUBFZE", &PPUInterpreter::SUBFZE, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompiler::STDCX_(u32 rs, u32 ra, u32 rb) {
+void Compiler::STDCX_(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STDCX_", &PPUInterpreter::STDCX_, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STBX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STBX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2556,7 +2538,7 @@ void PPULLVMRecompiler::STBX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STBX", &PPUInterpreter::STBX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STVX(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVX(u32 vs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2568,11 +2550,11 @@ void PPULLVMRecompiler::STVX(u32 vs, u32 ra, u32 rb) {
     //InterpreterCall("STVX", &PPUInterpreter::STVX, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::SUBFME(u32 rd, u32 ra, u32 oe, bool rc) {
+void Compiler::SUBFME(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("SUBFME", &PPUInterpreter::SUBFME, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompiler::MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64   = GetGpr(ra);
     auto rb_i64   = GetGpr(rb);
     auto prod_i64 = m_ir_builder->CreateMul(ra_i64, rb_i64);
@@ -2586,11 +2568,11 @@ void PPULLVMRecompiler::MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("MULLD", &PPUInterpreter::MULLD, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::ADDME(u32 rd, u32 ra, u32 oe, bool rc) {
+void Compiler::ADDME(u32 rd, u32 ra, u32 oe, bool rc) {
     InterpreterCall("ADDME", &PPUInterpreter::ADDME, rd, ra, oe, rc);
 }
 
-void PPULLVMRecompiler::MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i32   = GetGpr(ra, 32);
     auto rb_i32   = GetGpr(rb, 32);
     auto ra_i64   = m_ir_builder->CreateSExt(ra_i32, m_ir_builder->getInt64Ty());
@@ -2606,12 +2588,12 @@ void PPULLVMRecompiler::MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("MULLW", &PPUInterpreter::MULLW, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::DCBTST(u32 ra, u32 rb, u32 th) {
+void Compiler::DCBTST(u32 ra, u32 rb, u32 th) {
     // TODO: Implement this
     //InterpreterCall("DCBTST", &PPUInterpreter::DCBTST, ra, rb, th);
 }
 
-void PPULLVMRecompiler::STBUX(u32 rs, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2621,7 +2603,7 @@ void PPULLVMRecompiler::STBUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STBUX", &PPUInterpreter::STBUX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::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);
@@ -2637,12 +2619,12 @@ void PPULLVMRecompiler::ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("ADD", &PPUInterpreter::ADD, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::DCBT(u32 ra, u32 rb, u32 th) {
+void Compiler::DCBT(u32 ra, u32 rb, u32 th) {
     // TODO: Implement this using prefetch
     //InterpreterCall("DCBT", &PPUInterpreter::DCBT, ra, rb, th);
 }
 
-void PPULLVMRecompiler::LHZX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LHZX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2655,15 +2637,15 @@ void PPULLVMRecompiler::LHZX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHZX", &PPUInterpreter::LHZX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::EQV(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::EQV(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("EQV", &PPUInterpreter::EQV, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::ECIWX(u32 rd, u32 ra, u32 rb) {
+void Compiler::ECIWX(u32 rd, u32 ra, u32 rb) {
     InterpreterCall("ECIWX", &PPUInterpreter::ECIWX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LHZUX(u32 rd, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2675,7 +2657,7 @@ void PPULLVMRecompiler::LHZUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHZUX", &PPUInterpreter::LHZUX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::XOR(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::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);
@@ -2687,7 +2669,7 @@ void PPULLVMRecompiler::XOR(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("XOR", &PPUInterpreter::XOR, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::MFSPR(u32 rd, u32 spr) {
+void Compiler::MFSPR(u32 rd, u32 spr) {
     Value * rd_i64;
     auto    n      = (spr >> 5) | ((spr & 0x1f) << 5);
 
@@ -2713,7 +2695,7 @@ void PPULLVMRecompiler::MFSPR(u32 rd, u32 spr) {
     //InterpreterCall("MFSPR", &PPUInterpreter::MFSPR, rd, spr);
 }
 
-void PPULLVMRecompiler::LWAX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LWAX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2726,11 +2708,11 @@ void PPULLVMRecompiler::LWAX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWAX", &PPUInterpreter::LWAX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::DST(u32 ra, u32 rb, u32 strm, u32 t) {
+void Compiler::DST(u32 ra, u32 rb, u32 strm, u32 t) {
     InterpreterCall("DST", &PPUInterpreter::DST, ra, rb, strm, t);
 }
 
-void PPULLVMRecompiler::LHAX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LHAX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2743,21 +2725,13 @@ void PPULLVMRecompiler::LHAX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHAX", &PPUInterpreter::LHAX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LVXL(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVXL(u32 vd, u32 ra, u32 rb) {
     LVX(vd, ra, rb);
     //InterpreterCall("LVXL", &PPUInterpreter::LVXL, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::MFTB(u32 rd, u32 spr) {
-    static Function * s_get_time_fn = nullptr;
-
-    if (s_get_time_fn == nullptr) {
-        s_get_time_fn = (Function *)m_module->getOrInsertFunction("get_time", m_ir_builder->getInt64Ty(), nullptr);
-        s_get_time_fn->setCallingConv(CallingConv::X86_64_Win64);
-        m_execution_engine->addGlobalMapping(s_get_time_fn, (void *)get_time);
-    }
-    
-    auto tb_i64 = (Value *)m_ir_builder->CreateCall(s_get_time_fn);
+void Compiler::MFTB(u32 rd, u32 spr) {
+    auto tb_i64 = Call<u64>("get_time", get_time);
 
     u32 n = (spr >> 5) | ((spr & 0x1f) << 5);
     if (n == 0x10D) {
@@ -2767,7 +2741,7 @@ void PPULLVMRecompiler::MFTB(u32 rd, u32 spr) {
     SetGpr(rd, tb_i64);
 }
 
-void PPULLVMRecompiler::LWAUX(u32 rd, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2779,11 +2753,11 @@ void PPULLVMRecompiler::LWAUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWAUX", &PPUInterpreter::LWAUX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::DSTST(u32 ra, u32 rb, u32 strm, u32 t) {
+void Compiler::DSTST(u32 ra, u32 rb, u32 strm, u32 t) {
     InterpreterCall("DSTST", &PPUInterpreter::DSTST, ra, rb, strm, t);
 }
 
-void PPULLVMRecompiler::LHAUX(u32 rd, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2795,7 +2769,7 @@ void PPULLVMRecompiler::LHAUX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHAUX", &PPUInterpreter::LHAUX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::STHX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STHX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2806,15 +2780,15 @@ void PPULLVMRecompiler::STHX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STHX", &PPUInterpreter::STHX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::ORC(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::ORC(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("ORC", &PPUInterpreter::ORC, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::ECOWX(u32 rs, u32 ra, u32 rb) {
+void Compiler::ECOWX(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("ECOWX", &PPUInterpreter::ECOWX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STHUX(u32 rs, u32 ra, u32 rb) {
+void Compiler::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);
@@ -2824,7 +2798,7 @@ void PPULLVMRecompiler::STHUX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STHUX", &PPUInterpreter::STHUX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::OR(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::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);
@@ -2836,7 +2810,7 @@ void PPULLVMRecompiler::OR(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("OR", &PPUInterpreter::OR, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64  = GetGpr(ra);
     auto rb_i64  = GetGpr(rb);
     auto res_i64 = m_ir_builder->CreateUDiv(ra_i64, rb_i64);
@@ -2851,7 +2825,7 @@ void PPULLVMRecompiler::DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("DIVDU", &PPUInterpreter::DIVDU, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i32  = GetGpr(ra, 32);
     auto rb_i32  = GetGpr(rb, 32);
     auto res_i32 = m_ir_builder->CreateUDiv(ra_i32, rb_i32);
@@ -2867,7 +2841,7 @@ void PPULLVMRecompiler::DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("DIVWU", &PPUInterpreter::DIVWU, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::MTSPR(u32 spr, u32 rs) {
+void Compiler::MTSPR(u32 spr, u32 rs) {
     auto rs_i64 = GetGpr(rs);
     auto n      = (spr >> 5) | ((spr & 0x1f) << 5);
 
@@ -2892,16 +2866,16 @@ void PPULLVMRecompiler::MTSPR(u32 spr, u32 rs) {
     //InterpreterCall("MTSPR", &PPUInterpreter::MTSPR, spr, rs);
 }
 
-void PPULLVMRecompiler::NAND(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::NAND(u32 ra, u32 rs, u32 rb, bool rc) {
     InterpreterCall("NAND", &PPUInterpreter::NAND, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::STVXL(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVXL(u32 vs, u32 ra, u32 rb) {
     STVX(vs, ra, rb);
     //InterpreterCall("STVXL", &PPUInterpreter::STVXL, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i64  = GetGpr(ra);
     auto rb_i64  = GetGpr(rb);
     auto res_i64 = m_ir_builder->CreateSDiv(ra_i64, rb_i64);
@@ -2916,7 +2890,7 @@ void PPULLVMRecompiler::DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("DIVD", &PPUInterpreter::DIVD, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
+void Compiler::DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     auto ra_i32  = GetGpr(ra, 32);
     auto rb_i32  = GetGpr(rb, 32);
     auto res_i32 = m_ir_builder->CreateSDiv(ra_i32, rb_i32);
@@ -2932,7 +2906,7 @@ void PPULLVMRecompiler::DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) {
     //InterpreterCall("DIVW", &PPUInterpreter::DIVW, rd, ra, rb, oe, rc);
 }
 
-void PPULLVMRecompiler::LVLX(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVLX(u32 vd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2949,7 +2923,7 @@ void PPULLVMRecompiler::LVLX(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVLX", &PPUInterpreter::LVLX, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::LDBRX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LDBRX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2961,11 +2935,11 @@ void PPULLVMRecompiler::LDBRX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LDBRX", &PPUInterpreter::LDBRX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LSWX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LSWX(u32 rd, u32 ra, u32 rb) {
     InterpreterCall("LSWX", &PPUInterpreter::LSWX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LWBRX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LWBRX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2978,7 +2952,7 @@ void PPULLVMRecompiler::LWBRX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LWBRX", &PPUInterpreter::LWBRX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::LFSX(u32 frd, u32 ra, u32 rb) {
+void Compiler::LFSX(u32 frd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -2990,7 +2964,7 @@ void PPULLVMRecompiler::LFSX(u32 frd, u32 ra, u32 rb) {
     //InterpreterCall("LFSX", &PPUInterpreter::LFSX, frd, ra, rb);
 }
 
-void PPULLVMRecompiler::SRW(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::SRW(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto rs_i64  = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     auto rb_i8   = GetGpr(rb, 8);
@@ -3006,7 +2980,7 @@ void PPULLVMRecompiler::SRW(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("SRW", &PPUInterpreter::SRW, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::SRD(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::SRD(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i64   = GetGpr(rs);
     auto rs_i128  = m_ir_builder->CreateZExt(rs_i64, m_ir_builder->getIntNTy(128));
     auto rb_i8    = GetGpr(rb, 8);
@@ -3023,7 +2997,7 @@ void PPULLVMRecompiler::SRD(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("SRD", &PPUInterpreter::SRD, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::LVRX(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVRX(u32 vd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3045,7 +3019,7 @@ void PPULLVMRecompiler::LVRX(u32 vd, u32 ra, u32 rb) {
     //InterpreterCall("LVRX", &PPUInterpreter::LVRX, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::LSWI(u32 rd, u32 ra, u32 nb) {
+void Compiler::LSWI(u32 rd, u32 ra, u32 nb) {
     auto addr_i64 = ra ? GetGpr(ra) : m_ir_builder->getInt64(0);
 
     nb = nb ? nb : 32;
@@ -3067,7 +3041,7 @@ void PPULLVMRecompiler::LSWI(u32 rd, u32 ra, u32 nb) {
     //InterpreterCall("LSWI", &PPUInterpreter::LSWI, rd, ra, nb);
 }
 
-void PPULLVMRecompiler::LFSUX(u32 frd, u32 ra, u32 rb) {
+void Compiler::LFSUX(u32 frd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -3077,12 +3051,12 @@ void PPULLVMRecompiler::LFSUX(u32 frd, u32 ra, u32 rb) {
     //InterpreterCall("LFSUX", &PPUInterpreter::LFSUX, frd, ra, rb);
 }
 
-void PPULLVMRecompiler::SYNC(u32 l) {
+void Compiler::SYNC(u32 l) {
     m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_mfence));
     //InterpreterCall("SYNC", &PPUInterpreter::SYNC, l);
 }
 
-void PPULLVMRecompiler::LFDX(u32 frd, u32 ra, u32 rb) {
+void Compiler::LFDX(u32 frd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3094,7 +3068,7 @@ void PPULLVMRecompiler::LFDX(u32 frd, u32 ra, u32 rb) {
     //InterpreterCall("LFDX", &PPUInterpreter::LFDX, frd, ra, rb);
 }
 
-void PPULLVMRecompiler::LFDUX(u32 frd, u32 ra, u32 rb) {
+void Compiler::LFDUX(u32 frd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -3104,15 +3078,15 @@ void PPULLVMRecompiler::LFDUX(u32 frd, u32 ra, u32 rb) {
     //InterpreterCall("LFDUX", &PPUInterpreter::LFDUX, frd, ra, rb);
 }
 
-void PPULLVMRecompiler::STVLX(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVLX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVLX", &PPUInterpreter::STVLX, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::STSWX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STSWX(u32 rs, u32 ra, u32 rb) {
     InterpreterCall("STSWX", &PPUInterpreter::STSWX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STWBRX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STWBRX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3123,7 +3097,7 @@ void PPULLVMRecompiler::STWBRX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STWBRX", &PPUInterpreter::STWBRX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::STFSX(u32 frs, u32 ra, u32 rb) {
+void Compiler::STFSX(u32 frs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3135,11 +3109,11 @@ void PPULLVMRecompiler::STFSX(u32 frs, u32 ra, u32 rb) {
     //InterpreterCall("STFSX", &PPUInterpreter::STFSX, frs, ra, rb);
 }
 
-void PPULLVMRecompiler::STVRX(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVRX(u32 vs, u32 ra, u32 rb) {
     InterpreterCall("STVRX", &PPUInterpreter::STVRX, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::STFSUX(u32 frs, u32 ra, u32 rb) {
+void Compiler::STFSUX(u32 frs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -3150,7 +3124,7 @@ void PPULLVMRecompiler::STFSUX(u32 frs, u32 ra, u32 rb) {
     //InterpreterCall("STFSUX", &PPUInterpreter::STFSUX, frs, ra, rb);
 }
 
-void PPULLVMRecompiler::STSWI(u32 rd, u32 ra, u32 nb) {
+void Compiler::STSWI(u32 rd, u32 ra, u32 nb) {
     auto addr_i64 = ra ? GetGpr(ra) : m_ir_builder->getInt64(0);
 
     nb = nb ? nb : 32;
@@ -3185,7 +3159,7 @@ void PPULLVMRecompiler::STSWI(u32 rd, u32 ra, u32 nb) {
     //InterpreterCall("STSWI", &PPUInterpreter::STSWI, rd, ra, nb);
 }
 
-void PPULLVMRecompiler::STFDX(u32 frs, u32 ra, u32 rb) {
+void Compiler::STFDX(u32 frs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3197,7 +3171,7 @@ void PPULLVMRecompiler::STFDX(u32 frs, u32 ra, u32 rb) {
     //InterpreterCall("STFDX", &PPUInterpreter::STFDX, frs, ra, rb);
 }
 
-void PPULLVMRecompiler::STFDUX(u32 frs, u32 ra, u32 rb) {
+void Compiler::STFDUX(u32 frs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     auto ra_i64   = GetGpr(ra);
     addr_i64      = m_ir_builder->CreateAdd(ra_i64, addr_i64);
@@ -3208,12 +3182,12 @@ void PPULLVMRecompiler::STFDUX(u32 frs, u32 ra, u32 rb) {
     //InterpreterCall("STFDUX", &PPUInterpreter::STFDUX, frs, ra, rb);
 }
 
-void PPULLVMRecompiler::LVLXL(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVLXL(u32 vd, u32 ra, u32 rb) {
     LVLX(vd, ra, rb);
     //InterpreterCall("LVLXL", &PPUInterpreter::LVLXL, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::LHBRX(u32 rd, u32 ra, u32 rb) {
+void Compiler::LHBRX(u32 rd, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3226,7 +3200,7 @@ void PPULLVMRecompiler::LHBRX(u32 rd, u32 ra, u32 rb) {
     //InterpreterCall("LHBRX", &PPUInterpreter::LHBRX, rd, ra, rb);
 }
 
-void PPULLVMRecompiler::SRAW(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::SRAW(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto rs_i64  = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     rs_i64       = m_ir_builder->CreateShl(rs_i64, 32);
@@ -3250,7 +3224,7 @@ void PPULLVMRecompiler::SRAW(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("SRAW", &PPUInterpreter::SRAW, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::SRAD(u32 ra, u32 rs, u32 rb, bool rc) {
+void Compiler::SRAD(u32 ra, u32 rs, u32 rb, bool rc) {
     auto rs_i64   = GetGpr(rs);
     auto rs_i128  = m_ir_builder->CreateZExt(rs_i64, m_ir_builder->getIntNTy(128));
     rs_i128       = m_ir_builder->CreateShl(rs_i128, 64);
@@ -3275,16 +3249,16 @@ void PPULLVMRecompiler::SRAD(u32 ra, u32 rs, u32 rb, bool rc) {
     //InterpreterCall("SRAD", &PPUInterpreter::SRAD, ra, rs, rb, rc);
 }
 
-void PPULLVMRecompiler::LVRXL(u32 vd, u32 ra, u32 rb) {
+void Compiler::LVRXL(u32 vd, u32 ra, u32 rb) {
     LVRX(vd, ra, rb);
     //InterpreterCall("LVRXL", &PPUInterpreter::LVRXL, vd, ra, rb);
 }
 
-void PPULLVMRecompiler::DSS(u32 strm, u32 a) {
+void Compiler::DSS(u32 strm, u32 a) {
     InterpreterCall("DSS", &PPUInterpreter::DSS, strm, a);
 }
 
-void PPULLVMRecompiler::SRAWI(u32 ra, u32 rs, u32 sh, bool rc) {
+void Compiler::SRAWI(u32 ra, u32 rs, u32 sh, bool rc) {
     auto rs_i32  = GetGpr(rs, 32);
     auto rs_i64  = m_ir_builder->CreateZExt(rs_i32, m_ir_builder->getInt64Ty());
     rs_i64       = m_ir_builder->CreateShl(rs_i64, 32);
@@ -3305,7 +3279,7 @@ void PPULLVMRecompiler::SRAWI(u32 ra, u32 rs, u32 sh, bool rc) {
     //InterpreterCall("SRAWI", &PPUInterpreter::SRAWI, ra, rs, sh, rc);
 }
 
-void PPULLVMRecompiler::SRADI1(u32 ra, u32 rs, u32 sh, bool rc) {
+void Compiler::SRADI1(u32 ra, u32 rs, u32 sh, bool rc) {
     auto rs_i64   = GetGpr(rs);
     auto rs_i128  = m_ir_builder->CreateZExt(rs_i64, m_ir_builder->getIntNTy(128));
     rs_i128       = m_ir_builder->CreateShl(rs_i128, 64);
@@ -3327,22 +3301,22 @@ void PPULLVMRecompiler::SRADI1(u32 ra, u32 rs, u32 sh, bool rc) {
     //InterpreterCall("SRADI1", &PPUInterpreter::SRADI1, ra, rs, sh, rc);
 }
 
-void PPULLVMRecompiler::SRADI2(u32 ra, u32 rs, u32 sh, bool rc) {
+void Compiler::SRADI2(u32 ra, u32 rs, u32 sh, bool rc) {
     SRADI1(ra, rs, sh, rc);
     //InterpreterCall("SRADI2", &PPUInterpreter::SRADI2, ra, rs, sh, rc);
 }
 
-void PPULLVMRecompiler::EIEIO() {
+void Compiler::EIEIO() {
     m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::x86_sse2_mfence));
     //InterpreterCall("EIEIO", &PPUInterpreter::EIEIO);
 }
 
-void PPULLVMRecompiler::STVLXL(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVLXL(u32 vs, u32 ra, u32 rb) {
     STVLX(vs, ra, rb);
     //InterpreterCall("STVLXL", &PPUInterpreter::STVLXL, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::STHBRX(u32 rs, u32 ra, u32 rb) {
+void Compiler::STHBRX(u32 rs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3353,7 +3327,7 @@ void PPULLVMRecompiler::STHBRX(u32 rs, u32 ra, u32 rb) {
     //InterpreterCall("STHBRX", &PPUInterpreter::STHBRX, rs, ra, rb);
 }
 
-void PPULLVMRecompiler::EXTSH(u32 ra, u32 rs, bool rc) {
+void Compiler::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);
@@ -3364,12 +3338,12 @@ void PPULLVMRecompiler::EXTSH(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("EXTSH", &PPUInterpreter::EXTSH, ra, rs, rc);
 }
 
-void PPULLVMRecompiler::STVRXL(u32 vs, u32 ra, u32 rb) {
+void Compiler::STVRXL(u32 vs, u32 ra, u32 rb) {
     STVRX(vs, ra, rb);
     //InterpreterCall("STVRXL", &PPUInterpreter::STVRXL, vs, ra, rb);
 }
 
-void PPULLVMRecompiler::EXTSB(u32 ra, u32 rs, bool rc) {
+void Compiler::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);
@@ -3380,7 +3354,7 @@ void PPULLVMRecompiler::EXTSB(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("EXTSB", &PPUInterpreter::EXTSB, ra, rs, rc);
 }
 
-void PPULLVMRecompiler::STFIWX(u32 frs, u32 ra, u32 rb) {
+void Compiler::STFIWX(u32 frs, u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3393,7 +3367,7 @@ void PPULLVMRecompiler::STFIWX(u32 frs, u32 ra, u32 rb) {
     //InterpreterCall("STFIWX", &PPUInterpreter::STFIWX, frs, ra, rb);
 }
 
-void PPULLVMRecompiler::EXTSW(u32 ra, u32 rs, bool rc) {
+void Compiler::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);
@@ -3404,11 +3378,11 @@ void PPULLVMRecompiler::EXTSW(u32 ra, u32 rs, bool rc) {
     //InterpreterCall("EXTSW", &PPUInterpreter::EXTSW, ra, rs, rc);
 }
 
-void PPULLVMRecompiler::ICBI(u32 ra, u32 rs) {
+void Compiler::ICBI(u32 ra, u32 rs) {
     InterpreterCall("ICBI", &PPUInterpreter::ICBI, ra, rs);
 }
 
-void PPULLVMRecompiler::DCBZ(u32 ra, u32 rb) {
+void Compiler::DCBZ(u32 ra, u32 rb) {
     auto addr_i64 = GetGpr(rb);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3425,7 +3399,7 @@ void PPULLVMRecompiler::DCBZ(u32 ra, u32 rb) {
     //InterpreterCall("DCBZ", &PPUInterpreter::DCBZ, ra, rb);L
 }
 
-void PPULLVMRecompiler::LWZ(u32 rd, u32 ra, s32 d) {
+void Compiler::LWZ(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3438,7 +3412,7 @@ void PPULLVMRecompiler::LWZ(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LWZ", &PPUInterpreter::LWZ, rd, ra, d);
 }
 
-void PPULLVMRecompiler::LWZU(u32 rd, u32 ra, s32 d) {
+void Compiler::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);
@@ -3450,7 +3424,7 @@ void PPULLVMRecompiler::LWZU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LWZU", &PPUInterpreter::LWZU, rd, ra, d);
 }
 
-void PPULLVMRecompiler::LBZ(u32 rd, u32 ra, s32 d) {
+void Compiler::LBZ(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3463,7 +3437,7 @@ void PPULLVMRecompiler::LBZ(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LBZ", &PPUInterpreter::LBZ, rd, ra, d);
 }
 
-void PPULLVMRecompiler::LBZU(u32 rd, u32 ra, s32 d) {
+void Compiler::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);
@@ -3475,7 +3449,7 @@ void PPULLVMRecompiler::LBZU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LBZU", &PPUInterpreter::LBZU, rd, ra, d);
 }
 
-void PPULLVMRecompiler::STW(u32 rs, u32 ra, s32 d) {
+void Compiler::STW(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3486,7 +3460,7 @@ void PPULLVMRecompiler::STW(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STW", &PPUInterpreter::STW, rs, ra, d);
 }
 
-void PPULLVMRecompiler::STWU(u32 rs, u32 ra, s32 d) {
+void Compiler::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);
@@ -3496,7 +3470,7 @@ void PPULLVMRecompiler::STWU(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STWU", &PPUInterpreter::STWU, rs, ra, d);
 }
 
-void PPULLVMRecompiler::STB(u32 rs, u32 ra, s32 d) {
+void Compiler::STB(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3507,7 +3481,7 @@ void PPULLVMRecompiler::STB(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STB", &PPUInterpreter::STB, rs, ra, d);
 }
 
-void PPULLVMRecompiler::STBU(u32 rs, u32 ra, s32 d) {
+void Compiler::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);
@@ -3517,7 +3491,7 @@ void PPULLVMRecompiler::STBU(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STBU", &PPUInterpreter::STBU, rs, ra, d);
 }
 
-void PPULLVMRecompiler::LHZ(u32 rd, u32 ra, s32 d) {
+void Compiler::LHZ(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3530,7 +3504,7 @@ void PPULLVMRecompiler::LHZ(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHZ", &PPUInterpreter::LHZ, rd, ra, d);
 }
 
-void PPULLVMRecompiler::LHZU(u32 rd, u32 ra, s32 d) {
+void Compiler::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);
@@ -3542,7 +3516,7 @@ void PPULLVMRecompiler::LHZU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHZU", &PPUInterpreter::LHZU, rd, ra, d);
 }
 
-void PPULLVMRecompiler::LHA(u32 rd, u32 ra, s32 d) {
+void Compiler::LHA(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3555,7 +3529,7 @@ void PPULLVMRecompiler::LHA(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHA", &PPUInterpreter::LHA, rd, ra, d);
 }
 
-void PPULLVMRecompiler::LHAU(u32 rd, u32 ra, s32 d) {
+void Compiler::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);
@@ -3567,7 +3541,7 @@ void PPULLVMRecompiler::LHAU(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LHAU", &PPUInterpreter::LHAU, rd, ra, d);
 }
 
-void PPULLVMRecompiler::STH(u32 rs, u32 ra, s32 d) {
+void Compiler::STH(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3578,7 +3552,7 @@ void PPULLVMRecompiler::STH(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STH", &PPUInterpreter::STH, rs, ra, d);
 }
 
-void PPULLVMRecompiler::STHU(u32 rs, u32 ra, s32 d) {
+void Compiler::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);
@@ -3588,7 +3562,7 @@ void PPULLVMRecompiler::STHU(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STHU", &PPUInterpreter::STHU, rs, ra, d);
 }
 
-void PPULLVMRecompiler::LMW(u32 rd, u32 ra, s32 d) {
+void Compiler::LMW(u32 rd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         addr_i64 = m_ir_builder->CreateAdd(addr_i64, GetGpr(ra));
@@ -3604,7 +3578,7 @@ void PPULLVMRecompiler::LMW(u32 rd, u32 ra, s32 d) {
     //InterpreterCall("LMW", &PPUInterpreter::LMW, rd, ra, d);
 }
 
-void PPULLVMRecompiler::STMW(u32 rs, u32 ra, s32 d) {
+void Compiler::STMW(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         addr_i64 = m_ir_builder->CreateAdd(addr_i64, GetGpr(ra));
@@ -3619,7 +3593,7 @@ void PPULLVMRecompiler::STMW(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STMW", &PPUInterpreter::STMW, rs, ra, d);
 }
 
-void PPULLVMRecompiler::LFS(u32 frd, u32 ra, s32 d) {
+void Compiler::LFS(u32 frd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3631,7 +3605,7 @@ void PPULLVMRecompiler::LFS(u32 frd, u32 ra, s32 d) {
     //InterpreterCall("LFS", &PPUInterpreter::LFS, frd, ra, d);
 }
 
-void PPULLVMRecompiler::LFSU(u32 frd, u32 ra, s32 ds) {
+void Compiler::LFSU(u32 frd, 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);
@@ -3641,7 +3615,7 @@ void PPULLVMRecompiler::LFSU(u32 frd, u32 ra, s32 ds) {
     //InterpreterCall("LFSU", &PPUInterpreter::LFSU, frd, ra, ds);
 }
 
-void PPULLVMRecompiler::LFD(u32 frd, u32 ra, s32 d) {
+void Compiler::LFD(u32 frd, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3653,7 +3627,7 @@ void PPULLVMRecompiler::LFD(u32 frd, u32 ra, s32 d) {
     //InterpreterCall("LFD", &PPUInterpreter::LFD, frd, ra, d);
 }
 
-void PPULLVMRecompiler::LFDU(u32 frd, u32 ra, s32 ds) {
+void Compiler::LFDU(u32 frd, 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);
@@ -3664,7 +3638,7 @@ void PPULLVMRecompiler::LFDU(u32 frd, u32 ra, s32 ds) {
     //InterpreterCall("LFDU", &PPUInterpreter::LFDU, frd, ra, ds);
 }
 
-void PPULLVMRecompiler::STFS(u32 frs, u32 ra, s32 d) {
+void Compiler::STFS(u32 frs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3676,7 +3650,7 @@ void PPULLVMRecompiler::STFS(u32 frs, u32 ra, s32 d) {
     //InterpreterCall("STFS", &PPUInterpreter::STFS, frs, ra, d);
 }
 
-void PPULLVMRecompiler::STFSU(u32 frs, u32 ra, s32 d) {
+void Compiler::STFSU(u32 frs, 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);
@@ -3687,7 +3661,7 @@ void PPULLVMRecompiler::STFSU(u32 frs, u32 ra, s32 d) {
     //InterpreterCall("STFSU", &PPUInterpreter::STFSU, frs, ra, d);
 }
 
-void PPULLVMRecompiler::STFD(u32 frs, u32 ra, s32 d) {
+void Compiler::STFD(u32 frs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3699,7 +3673,7 @@ void PPULLVMRecompiler::STFD(u32 frs, u32 ra, s32 d) {
     //InterpreterCall("STFD", &PPUInterpreter::STFD, frs, ra, d);
 }
 
-void PPULLVMRecompiler::STFDU(u32 frs, u32 ra, s32 d) {
+void Compiler::STFDU(u32 frs, 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);
@@ -3710,7 +3684,7 @@ void PPULLVMRecompiler::STFDU(u32 frs, u32 ra, s32 d) {
     //InterpreterCall("STFDU", &PPUInterpreter::STFDU, frs, ra, d);
 }
 
-void PPULLVMRecompiler::LD(u32 rd, u32 ra, s32 ds) {
+void Compiler::LD(u32 rd, u32 ra, s32 ds) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)ds);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3722,7 +3696,7 @@ void PPULLVMRecompiler::LD(u32 rd, u32 ra, s32 ds) {
     //InterpreterCall("LD", &PPUInterpreter::LD, rd, ra, ds);
 }
 
-void PPULLVMRecompiler::LDU(u32 rd, u32 ra, s32 ds) {
+void Compiler::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);
@@ -3733,7 +3707,7 @@ void PPULLVMRecompiler::LDU(u32 rd, u32 ra, s32 ds) {
     //InterpreterCall("LDU", &PPUInterpreter::LDU, rd, ra, ds);
 }
 
-void PPULLVMRecompiler::LWA(u32 rd, u32 ra, s32 ds) {
+void Compiler::LWA(u32 rd, u32 ra, s32 ds) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)ds);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3746,7 +3720,7 @@ void PPULLVMRecompiler::LWA(u32 rd, u32 ra, s32 ds) {
     //InterpreterCall("LWA", &PPUInterpreter::LWA, rd, ra, ds);
 }
 
-void PPULLVMRecompiler::FDIVS(u32 frd, u32 fra, u32 frb, bool rc) {
+void Compiler::FDIVS(u32 frd, u32 fra, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = m_ir_builder->CreateFDiv(ra_f64, rb_f64);
@@ -3758,7 +3732,7 @@ void PPULLVMRecompiler::FDIVS(u32 frd, u32 fra, u32 frb, bool rc) {
     //InterpreterCall("FDIVS", &PPUInterpreter::FDIVS, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompiler::FSUBS(u32 frd, u32 fra, u32 frb, bool rc) {
+void Compiler::FSUBS(u32 frd, u32 fra, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = m_ir_builder->CreateFSub(ra_f64, rb_f64);
@@ -3770,7 +3744,7 @@ void PPULLVMRecompiler::FSUBS(u32 frd, u32 fra, u32 frb, bool rc) {
     //InterpreterCall("FSUBS", &PPUInterpreter::FSUBS, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompiler::FADDS(u32 frd, u32 fra, u32 frb, bool rc) {
+void Compiler::FADDS(u32 frd, u32 fra, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = m_ir_builder->CreateFAdd(ra_f64, rb_f64);
@@ -3782,7 +3756,7 @@ void PPULLVMRecompiler::FADDS(u32 frd, u32 fra, u32 frb, bool rc) {
     //InterpreterCall("FADDS", &PPUInterpreter::FADDS, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompiler::FSQRTS(u32 frd, u32 frb, bool rc) {
+void Compiler::FSQRTS(u32 frd, u32 frb, bool rc) {
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = (Value *)m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::sqrt, m_ir_builder->getDoubleTy()), rb_f64);
     auto res_f32 = m_ir_builder->CreateFPTrunc(res_f64, m_ir_builder->getFloatTy());
@@ -3793,11 +3767,11 @@ void PPULLVMRecompiler::FSQRTS(u32 frd, u32 frb, bool rc) {
     //InterpreterCall("FSQRTS", &PPUInterpreter::FSQRTS, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FRES(u32 frd, u32 frb, bool rc) {
+void Compiler::FRES(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FRES", &PPUInterpreter::FRES, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FMULS(u32 frd, u32 fra, u32 frc, bool rc) {
+void Compiler::FMULS(u32 frd, u32 fra, u32 frc, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rc_f64  = GetFpr(frc);
     auto res_f64 = m_ir_builder->CreateFMul(ra_f64, rc_f64);
@@ -3809,7 +3783,7 @@ void PPULLVMRecompiler::FMULS(u32 frd, u32 fra, u32 frc, bool rc) {
     //InterpreterCall("FMULS", &PPUInterpreter::FMULS, frd, fra, frc, rc);
 }
 
-void PPULLVMRecompiler::FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -3822,7 +3796,7 @@ void PPULLVMRecompiler::FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FMADDS", &PPUInterpreter::FMADDS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -3836,7 +3810,7 @@ void PPULLVMRecompiler::FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FMSUBS", &PPUInterpreter::FMSUBS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -3851,7 +3825,7 @@ void PPULLVMRecompiler::FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FNMSUBS", &PPUInterpreter::FNMSUBS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -3865,7 +3839,7 @@ void PPULLVMRecompiler::FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FNMADDS", &PPUInterpreter::FNMADDS, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::STD(u32 rs, u32 ra, s32 d) {
+void Compiler::STD(u32 rs, u32 ra, s32 d) {
     auto addr_i64 = (Value *)m_ir_builder->getInt64((s64)d);
     if (ra) {
         auto ra_i64 = GetGpr(ra);
@@ -3876,7 +3850,7 @@ void PPULLVMRecompiler::STD(u32 rs, u32 ra, s32 d) {
     //InterpreterCall("STD", &PPUInterpreter::STD, rs, ra, d);
 }
 
-void PPULLVMRecompiler::STDU(u32 rs, u32 ra, s32 ds) {
+void Compiler::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);
@@ -3886,47 +3860,47 @@ void PPULLVMRecompiler::STDU(u32 rs, u32 ra, s32 ds) {
     //InterpreterCall("STDU", &PPUInterpreter::STDU, rs, ra, ds);
 }
 
-void PPULLVMRecompiler::MTFSB1(u32 crbd, bool rc) {
+void Compiler::MTFSB1(u32 crbd, bool rc) {
     InterpreterCall("MTFSB1", &PPUInterpreter::MTFSB1, crbd, rc);
 }
 
-void PPULLVMRecompiler::MCRFS(u32 crbd, u32 crbs) {
+void Compiler::MCRFS(u32 crbd, u32 crbs) {
     InterpreterCall("MCRFS", &PPUInterpreter::MCRFS, crbd, crbs);
 }
 
-void PPULLVMRecompiler::MTFSB0(u32 crbd, bool rc) {
+void Compiler::MTFSB0(u32 crbd, bool rc) {
     InterpreterCall("MTFSB0", &PPUInterpreter::MTFSB0, crbd, rc);
 }
 
-void PPULLVMRecompiler::MTFSFI(u32 crfd, u32 i, bool rc) {
+void Compiler::MTFSFI(u32 crfd, u32 i, bool rc) {
     InterpreterCall("MTFSFI", &PPUInterpreter::MTFSFI, crfd, i, rc);
 }
 
-void PPULLVMRecompiler::MFFS(u32 frd, bool rc) {
+void Compiler::MFFS(u32 frd, bool rc) {
     InterpreterCall("MFFS", &PPUInterpreter::MFFS, frd, rc);
 }
 
-void PPULLVMRecompiler::MTFSF(u32 flm, u32 frb, bool rc) {
+void Compiler::MTFSF(u32 flm, u32 frb, bool rc) {
     InterpreterCall("MTFSF", &PPUInterpreter::MTFSF, flm, frb, rc);
 }
 
-void PPULLVMRecompiler::FCMPU(u32 crfd, u32 fra, u32 frb) {
+void Compiler::FCMPU(u32 crfd, u32 fra, u32 frb) {
     InterpreterCall("FCMPU", &PPUInterpreter::FCMPU, crfd, fra, frb);
 }
 
-void PPULLVMRecompiler::FRSP(u32 frd, u32 frb, bool rc) {
+void Compiler::FRSP(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FRSP", &PPUInterpreter::FRSP, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FCTIW(u32 frd, u32 frb, bool rc) {
+void Compiler::FCTIW(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTIW", &PPUInterpreter::FCTIW, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FCTIWZ(u32 frd, u32 frb, bool rc) {
+void Compiler::FCTIWZ(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTIWZ", &PPUInterpreter::FCTIWZ, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FDIV(u32 frd, u32 fra, u32 frb, bool rc) {
+void Compiler::FDIV(u32 frd, u32 fra, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = m_ir_builder->CreateFDiv(ra_f64, rb_f64);
@@ -3936,7 +3910,7 @@ void PPULLVMRecompiler::FDIV(u32 frd, u32 fra, u32 frb, bool rc) {
     //InterpreterCall("FDIV", &PPUInterpreter::FDIV, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompiler::FSUB(u32 frd, u32 fra, u32 frb, bool rc) {
+void Compiler::FSUB(u32 frd, u32 fra, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = m_ir_builder->CreateFSub(ra_f64, rb_f64);
@@ -3946,7 +3920,7 @@ void PPULLVMRecompiler::FSUB(u32 frd, u32 fra, u32 frb, bool rc) {
     //InterpreterCall("FSUB", &PPUInterpreter::FSUB, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompiler::FADD(u32 frd, u32 fra, u32 frb, bool rc) {
+void Compiler::FADD(u32 frd, u32 fra, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = m_ir_builder->CreateFAdd(ra_f64, rb_f64);
@@ -3956,7 +3930,7 @@ void PPULLVMRecompiler::FADD(u32 frd, u32 fra, u32 frb, bool rc) {
     //InterpreterCall("FADD", &PPUInterpreter::FADD, frd, fra, frb, rc);
 }
 
-void PPULLVMRecompiler::FSQRT(u32 frd, u32 frb, bool rc) {
+void Compiler::FSQRT(u32 frd, u32 frb, bool rc) {
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = (Value *)m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::sqrt, m_ir_builder->getDoubleTy()), rb_f64);
     SetFpr(frd, res_f64);
@@ -3965,11 +3939,11 @@ void PPULLVMRecompiler::FSQRT(u32 frd, u32 frb, bool rc) {
     //InterpreterCall("FSQRT", &PPUInterpreter::FSQRT, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     InterpreterCall("FSEL", &PPUInterpreter::FSEL, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FMUL(u32 frd, u32 fra, u32 frc, bool rc) {
+void Compiler::FMUL(u32 frd, u32 fra, u32 frc, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rc_f64  = GetFpr(frc);
     auto res_f64 = m_ir_builder->CreateFMul(ra_f64, rc_f64);
@@ -3979,11 +3953,11 @@ void PPULLVMRecompiler::FMUL(u32 frd, u32 fra, u32 frc, bool rc) {
     //InterpreterCall("FMUL", &PPUInterpreter::FMUL, frd, fra, frc, rc);
 }
 
-void PPULLVMRecompiler::FRSQRTE(u32 frd, u32 frb, bool rc) {
+void Compiler::FRSQRTE(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FRSQRTE", &PPUInterpreter::FRSQRTE, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -3995,7 +3969,7 @@ void PPULLVMRecompiler::FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FMSUB", &PPUInterpreter::FMSUB, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -4006,7 +3980,7 @@ void PPULLVMRecompiler::FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FMADD", &PPUInterpreter::FMADD, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -4018,7 +3992,7 @@ void PPULLVMRecompiler::FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FNMSUB", &PPUInterpreter::FNMSUB, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
+void Compiler::FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     auto ra_f64  = GetFpr(fra);
     auto rb_f64  = GetFpr(frb);
     auto rc_f64  = GetFpr(frc);
@@ -4031,11 +4005,11 @@ void PPULLVMRecompiler::FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) {
     //InterpreterCall("FNMADD", &PPUInterpreter::FNMADD, frd, fra, frc, frb, rc);
 }
 
-void PPULLVMRecompiler::FCMPO(u32 crfd, u32 fra, u32 frb) {
+void Compiler::FCMPO(u32 crfd, u32 fra, u32 frb) {
     InterpreterCall("FCMPO", &PPUInterpreter::FCMPO, crfd, fra, frb);
 }
 
-void PPULLVMRecompiler::FNEG(u32 frd, u32 frb, bool rc) {
+void Compiler::FNEG(u32 frd, u32 frb, bool rc) {
     auto rb_f64  = GetFpr(frb);
     rb_f64       = m_ir_builder->CreateFNeg(rb_f64);
     SetFpr(frd, rb_f64);
@@ -4044,13 +4018,13 @@ void PPULLVMRecompiler::FNEG(u32 frd, u32 frb, bool rc) {
     //InterpreterCall("FNEG", &PPUInterpreter::FNEG, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FMR(u32 frd, u32 frb, bool rc) {
+void Compiler::FMR(u32 frd, u32 frb, bool rc) {
     SetFpr(frd, GetFpr(frb));
     // TODO: Set flags
     //InterpreterCall("FMR", &PPUInterpreter::FMR, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FNABS(u32 frd, u32 frb, bool rc) {
+void Compiler::FNABS(u32 frd, u32 frb, bool rc) {
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = (Value *)m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::fabs, m_ir_builder->getDoubleTy()), rb_f64);
     res_f64      = m_ir_builder->CreateFNeg(res_f64);
@@ -4060,7 +4034,7 @@ void PPULLVMRecompiler::FNABS(u32 frd, u32 frb, bool rc) {
     //InterpreterCall("FNABS", &PPUInterpreter::FNABS, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FABS(u32 frd, u32 frb, bool rc) {
+void Compiler::FABS(u32 frd, u32 frb, bool rc) {
     auto rb_f64  = GetFpr(frb);
     auto res_f64 = (Value *)m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::fabs, m_ir_builder->getDoubleTy()), rb_f64);
     SetFpr(frd, res_f64);
@@ -4069,15 +4043,15 @@ void PPULLVMRecompiler::FABS(u32 frd, u32 frb, bool rc) {
     //InterpreterCall("FABS", &PPUInterpreter::FABS, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FCTID(u32 frd, u32 frb, bool rc) {
+void Compiler::FCTID(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTID", &PPUInterpreter::FCTID, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FCTIDZ(u32 frd, u32 frb, bool rc) {
+void Compiler::FCTIDZ(u32 frd, u32 frb, bool rc) {
     InterpreterCall("FCTIDZ", &PPUInterpreter::FCTIDZ, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::FCFID(u32 frd, u32 frb, bool rc) {
+void Compiler::FCFID(u32 frd, u32 frb, bool rc) {
     auto rb_i64  = GetFpr(frb, 64, true);
     auto res_f64 = m_ir_builder->CreateSIToFP(rb_i64, m_ir_builder->getDoubleTy());
     SetFpr(frd, res_f64);
@@ -4086,12 +4060,26 @@ void PPULLVMRecompiler::FCFID(u32 frd, u32 frb, bool rc) {
     //InterpreterCall("FCFID", &PPUInterpreter::FCFID, frd, frb, rc);
 }
 
-void PPULLVMRecompiler::UNK(const u32 code, const u32 opcode, const u32 gcode) {
+void Compiler::UNK(const u32 code, const u32 opcode, const u32 gcode) {
     //InterpreterCall("UNK", &PPUInterpreter::UNK, code, opcode, gcode);
 }
 
-BasicBlock * PPULLVMRecompiler::GetBlockInFunction(u32 address, Function * function, bool create_if_not_exist) {
-    auto         block_name = fmt::Format("instr_0x%X", address);
+std::string Compiler::GetBasicBlockNameFromAddress(u32 address) {
+    std::string name;
+
+    if (address == 0) {
+        name = "entry";
+    } else if (address == 0xFFFFFFFF) {
+        name = "unknown";
+    } else {
+        name = fmt::Format("instr_0x%X", address);
+    }
+
+    return name;
+}
+
+BasicBlock * Compiler::GetBasicBlockFromAddress(u32 address, Function * function, bool create_if_not_exist) {
+    auto         block_name = GetBasicBlockNameFromAddress(address);
     BasicBlock * block      = nullptr;
     for (auto i = function->getBasicBlockList().begin(); i != function->getBasicBlockList().end(); i++) {
         if (i->getName() == block_name) {
@@ -4107,169 +4095,24 @@ BasicBlock * PPULLVMRecompiler::GetBlockInFunction(u32 address, Function * funct
     return block;
 }
 
-void PPULLVMRecompiler::Compile(u32 address) {
-    auto compilation_start = std::chrono::high_resolution_clock::now();
-
-    // Get the revision number for this section
-    u32  revision = 0;
-    auto compiled = m_compiled.lower_bound(std::make_pair(address, 0));
-    if (compiled != m_compiled.end() && compiled->first.first == address) {
-        revision = ~(compiled->first.second);
-        revision++;
-    }
-
-    auto ir_build_start = std::chrono::high_resolution_clock::now();
-
-    // Create a function for this section
-    auto function_name = fmt::Format("fn_0x%X_%u", address, revision);
-    m_current_function = (Function *)m_module->getOrInsertFunction(function_name, m_ir_builder->getVoidTy(),
-                                                                   m_ir_builder->getInt8PtrTy() /*ppu_state*/,
-                                                                   m_ir_builder->getInt8PtrTy() /*interpreter*/, nullptr);
-    m_current_function->setCallingConv(CallingConv::X86_64_Win64);
-    auto arg_i = m_current_function->arg_begin();
-    arg_i->setName("ppu_state");
-    (++arg_i)->setName("interpreter");
-
-    // Add an entry block that branches to the first instruction
-    m_ir_builder->SetInsertPoint(BasicBlock::Create(m_ir_builder->getContext(), "entry", m_current_function));
-    m_ir_builder->CreateBr(GetBlockInFunction(address, m_current_function, true));
-
-    // Convert each block in this section to LLVM IR
-    m_num_instructions = 0;
-    m_current_function_uncompiled_blocks_list.clear();
-    m_current_function_unhit_blocks_list.clear();
-    m_current_function_uncompiled_blocks_list.push_back(address);
-    while (!m_current_function_uncompiled_blocks_list.empty()) {
-        m_current_instruction_address = m_current_function_uncompiled_blocks_list.front();
-        auto block                    = GetBlockInFunction(m_current_instruction_address, m_current_function, true);
-        m_hit_branch_instruction      = false;
-        m_ir_builder->SetInsertPoint(block);
-        m_current_function_uncompiled_blocks_list.pop_front();
-
-        while (!m_hit_branch_instruction) {
-            if (!block->getInstList().empty()) {
-                break;
-            }
-
-            u32 instr = vm::read32(m_current_instruction_address);
-            Decode(instr);
-            m_num_instructions++;
-
-            m_current_instruction_address += 4;
-            if (!m_hit_branch_instruction) {
-                block = GetBlockInFunction(m_current_instruction_address, m_current_function, true);
-                m_ir_builder->CreateBr(block);
-                m_ir_builder->SetInsertPoint(block);
-            }
-        }
-    }
-
-    auto ir_build_end  = std::chrono::high_resolution_clock::now();
-    m_ir_build_time   += std::chrono::duration_cast<std::chrono::nanoseconds>(ir_build_end - ir_build_start);
-
-    // Optimize this function
-    auto optimize_start = std::chrono::high_resolution_clock::now();
-    m_fpm->run(*m_current_function);
-    auto optimize_end  = std::chrono::high_resolution_clock::now();
-    m_optimizing_time += std::chrono::duration_cast<std::chrono::nanoseconds>(optimize_end - optimize_start);
-
-    // Translate to machine code
-    auto translate_start = std::chrono::high_resolution_clock::now();
-    MachineCodeInfo mci;
-    m_execution_engine->runJITOnFunction(m_current_function, &mci);
-    auto translate_end  = std::chrono::high_resolution_clock::now();
-    m_translation_time += std::chrono::duration_cast<std::chrono::nanoseconds>(translate_end - translate_start);
-
-    // Add the executable to private and shared data stores
-    ExecutableInfo executable_info;
-    executable_info.executable                     = (Executable)mci.address();
-    executable_info.size                           = mci.size();
-    executable_info.num_instructions               = m_num_instructions;
-    executable_info.unhit_blocks_list              = std::move(m_current_function_unhit_blocks_list);
-    executable_info.llvm_function                  = m_current_function;
-    m_compiled[std::make_pair(address, ~revision)] = executable_info;
-
-    {
-        std::lock_guard<std::mutex> lock(m_compiled_shared_lock);
-        m_compiled_shared[std::make_pair(address, ~revision)] = std::make_pair(executable_info.executable, 0);
-    }
-
-    if (revision) {
-        m_revision.fetch_add(1, std::memory_order_relaxed);
-    }
-
-    auto compilation_end  = std::chrono::high_resolution_clock::now();
-    m_compilation_time   += std::chrono::duration_cast<std::chrono::nanoseconds>(compilation_end - compilation_start);
-}
-
-void PPULLVMRecompiler::RemoveUnusedOldVersions() {
-    u32 num_removed  = 0;
-    u32 prev_address = 0;
-    for (auto i = m_compiled.begin(); i != m_compiled.end(); i++) {
-        u32 current_address = i->first.first;
-        if (prev_address == current_address) {
-            bool erase_this_entry = false;
-
-            {
-                std::lock_guard<std::mutex> lock(m_compiled_shared_lock);
-                auto j = m_compiled_shared.find(i->first);
-                if (j->second.second == 0) {
-                    m_compiled_shared.erase(j);
-                    erase_this_entry = true;
-                }
-            }
-
-            if (erase_this_entry) {
-                auto tmp = i;
-                i--;
-                m_execution_engine->freeMachineCodeForFunction(tmp->second.llvm_function);
-                tmp->second.llvm_function->eraseFromParent();
-                m_compiled.erase(tmp);
-                num_removed++;
-            }
-        }
-
-        prev_address = current_address;
-    }
-
-    if (num_removed > 0) {
-        LOG_NOTICE(PPU, "Removed %u old versions", num_removed);
-    }
-}
-
-bool PPULLVMRecompiler::NeedsCompiling(u32 address) {
-    auto i = m_compiled.lower_bound(std::make_pair(address, 0));
-    if (i != m_compiled.end() && i->first.first == address) {
-        if (i->second.num_instructions >= 300) {
-            // This section has reached its limit. Don't allow further expansion.
-            return false;
-        }
-
-        // If any of the unhit blocks in this function have been hit, then recompile this section
-        for (auto j = i->second.unhit_blocks_list.begin(); j != i->second.unhit_blocks_list.end(); j++) {
-            if (m_hit_blocks.find(*j) != m_hit_blocks.end()) {
-                return true;
-            }
-        }
-
-        return false;
-    } else {
-        // This section has not been encountered before
-        return true;
-    }
-}
-
-Value * PPULLVMRecompiler::GetPPUState() {
+Value * Compiler::GetPPUStateArg() {
     return m_current_function->arg_begin();
 }
 
-Value * PPULLVMRecompiler::GetInterpreter() {
+Value * Compiler::GetInterpreterArg() {
     auto i = m_current_function->arg_begin();
     i++;
     return i;
 }
 
-Value * PPULLVMRecompiler::GetBit(Value * val, u32 n) {
+Value * Compiler::GetTracerArg() {
+    auto i = m_current_function->arg_begin();
+    i++;
+    i++;
+    return i;
+}
+
+Value * Compiler::GetBit(Value * val, u32 n) {
     Value * bit;
 
 #ifdef PPU_LLVM_RECOMPILER_USE_BMI
@@ -4291,11 +4134,11 @@ Value * PPULLVMRecompiler::GetBit(Value * val, u32 n) {
     return bit;
 }
 
-Value * PPULLVMRecompiler::ClrBit(Value * val, u32 n) {
+Value * Compiler::ClrBit(Value * val, u32 n) {
     return m_ir_builder->CreateAnd(val, ~((u64)1 << (val->getType()->getIntegerBitWidth() - n - 1)));
 }
 
-Value * PPULLVMRecompiler::SetBit(Value * val, u32 n, Value * bit, bool doClear) {
+Value * Compiler::SetBit(Value * val, u32 n, Value * bit, bool doClear) {
     if (doClear) {
         val = ClrBit(val, n);
     }
@@ -4313,7 +4156,7 @@ Value * PPULLVMRecompiler::SetBit(Value * val, u32 n, Value * bit, bool doClear)
     return m_ir_builder->CreateOr(val, bit);
 }
 
-Value * PPULLVMRecompiler::GetNibble(Value * val, u32 n) {
+Value * Compiler::GetNibble(Value * val, u32 n) {
     Value * nibble;
 
 #ifdef PPU_LLVM_RECOMPILER_USE_BMI
@@ -4335,11 +4178,11 @@ Value * PPULLVMRecompiler::GetNibble(Value * val, u32 n) {
     return nibble;
 }
 
-Value * PPULLVMRecompiler::ClrNibble(Value * val, u32 n) {
+Value * Compiler::ClrNibble(Value * val, u32 n) {
     return m_ir_builder->CreateAnd(val, ~((u64)0xF << ((((val->getType()->getIntegerBitWidth() >> 2) - 1) - n) * 4)));
 }
 
-Value * PPULLVMRecompiler::SetNibble(Value * val, u32 n, Value * nibble, bool doClear) {
+Value * Compiler::SetNibble(Value * val, u32 n, Value * nibble, bool doClear) {
     if (doClear) {
         val = ClrNibble(val, n);
     }
@@ -4357,7 +4200,7 @@ Value * PPULLVMRecompiler::SetNibble(Value * val, u32 n, Value * nibble, bool do
     return m_ir_builder->CreateOr(val, nibble);
 }
 
-Value * PPULLVMRecompiler::SetNibble(Value * val, u32 n, Value * b0, Value * b1, Value * b2, Value * b3, bool doClear) {
+Value * Compiler::SetNibble(Value * val, u32 n, Value * b0, Value * b1, Value * b2, Value * b3, bool doClear) {
     if (doClear) {
         val = ClrNibble(val, n);
     }
@@ -4381,58 +4224,58 @@ Value * PPULLVMRecompiler::SetNibble(Value * val, u32 n, Value * b0, Value * b1,
     return val;
 }
 
-Value * PPULLVMRecompiler::GetPc() {
-    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, PC));
+Value * Compiler::GetPc() {
+    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, PC));
     auto pc_i32_ptr = m_ir_builder->CreateBitCast(pc_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     return m_ir_builder->CreateAlignedLoad(pc_i32_ptr, 4);
 }
 
-void PPULLVMRecompiler::SetPc(Value * val_ix) {
-    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, PC));
+void Compiler::SetPc(Value * val_ix) {
+    auto pc_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, PC));
     auto pc_i32_ptr = m_ir_builder->CreateBitCast(pc_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     auto val_i32    = m_ir_builder->CreateZExtOrTrunc(val_ix, m_ir_builder->getInt32Ty());
     m_ir_builder->CreateAlignedStore(val_i32, pc_i32_ptr, 4);
 }
 
-Value * PPULLVMRecompiler::GetGpr(u32 r, u32 num_bits) {
-    auto r_i8_ptr = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, GPR[r]));
+Value * Compiler::GetGpr(u32 r, u32 num_bits) {
+    auto r_i8_ptr = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(r_ix_ptr, 8);
 }
 
-void PPULLVMRecompiler::SetGpr(u32 r, Value * val_x64) {
-    auto r_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, GPR[r]));
+void Compiler::SetGpr(u32 r, Value * val_x64) {
+    auto r_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedStore(val_i64, r_i64_ptr, 8);
 }
 
-Value * PPULLVMRecompiler::GetCr() {
-    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, CR));
+Value * Compiler::GetCr() {
+    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(cr_i32_ptr, 4);
 }
 
-Value * PPULLVMRecompiler::GetCrField(u32 n) {
+Value * Compiler::GetCrField(u32 n) {
     return GetNibble(GetCr(), n);
 }
 
-void PPULLVMRecompiler::SetCr(Value * val_x32) {
+void Compiler::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(), (unsigned int)offsetof(PPUThread, CR));
+    auto cr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, CR));
     auto cr_i32_ptr = m_ir_builder->CreateBitCast(cr_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(val_i32, cr_i32_ptr, 4);
 }
 
-void PPULLVMRecompiler::SetCrField(u32 n, Value * field) {
+void Compiler::SetCrField(u32 n, Value * field) {
     SetCr(SetNibble(GetCr(), n, field));
 }
 
-void PPULLVMRecompiler::SetCrField(u32 n, Value * b0, Value * b1, Value * b2, Value * b3) {
+void Compiler::SetCrField(u32 n, Value * b0, Value * b1, Value * b2, Value * b3) {
     SetCr(SetNibble(GetCr(), n, b0, b1, b2, b3));
 }
 
-void PPULLVMRecompiler::SetCrFieldSignedCmp(u32 n, Value * a, Value * b) {
+void Compiler::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);
@@ -4441,7 +4284,7 @@ void PPULLVMRecompiler::SetCrFieldSignedCmp(u32 n, Value * a, Value * b) {
     SetCr(cr_i32);
 }
 
-void PPULLVMRecompiler::SetCrFieldUnsignedCmp(u32 n, Value * a, Value * b) {
+void Compiler::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);
@@ -4450,7 +4293,7 @@ void PPULLVMRecompiler::SetCrFieldUnsignedCmp(u32 n, Value * a, Value * b) {
     SetCr(cr_i32);
 }
 
-void PPULLVMRecompiler::SetCr6AfterVectorCompare(u32 vr) {
+void Compiler::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));
@@ -4460,80 +4303,80 @@ void PPULLVMRecompiler::SetCr6AfterVectorCompare(u32 vr) {
     SetCr(cr_i32);
 }
 
-Value * PPULLVMRecompiler::GetLr() {
-    auto lr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, LR));
+Value * Compiler::GetLr() {
+    auto lr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, LR));
     auto lr_i64_ptr = m_ir_builder->CreateBitCast(lr_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     return m_ir_builder->CreateAlignedLoad(lr_i64_ptr, 8);
 }
 
-void PPULLVMRecompiler::SetLr(Value * val_x64) {
+void Compiler::SetLr(Value * val_x64) {
     auto val_i64     = m_ir_builder->CreateBitCast(val_x64, m_ir_builder->getInt64Ty());
-    auto lr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, LR));
+    auto lr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, LR));
     auto lr_i64_ptr = m_ir_builder->CreateBitCast(lr_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(val_i64, lr_i64_ptr, 8);
 }
 
-Value * PPULLVMRecompiler::GetCtr() {
-    auto ctr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, CTR));
+Value * Compiler::GetCtr() {
+    auto ctr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, CTR));
     auto ctr_i64_ptr = m_ir_builder->CreateBitCast(ctr_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     return m_ir_builder->CreateAlignedLoad(ctr_i64_ptr, 8);
 }
 
-void PPULLVMRecompiler::SetCtr(Value * val_x64) {
+void Compiler::SetCtr(Value * val_x64) {
     auto val_i64     = m_ir_builder->CreateBitCast(val_x64, m_ir_builder->getInt64Ty());
-    auto ctr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, CTR));
+    auto ctr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, CTR));
     auto ctr_i64_ptr = m_ir_builder->CreateBitCast(ctr_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(val_i64, ctr_i64_ptr, 8);
 }
 
-Value * PPULLVMRecompiler::GetXer() {
-    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, XER));
+Value * Compiler::GetXer() {
+    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(xer_i64_ptr, 8);
 }
 
-Value * PPULLVMRecompiler::GetXerCa() {
+Value * Compiler::GetXerCa() {
     return GetBit(GetXer(), 34);
 }
 
-Value * PPULLVMRecompiler::GetXerSo() {
+Value * Compiler::GetXerSo() {
     return GetBit(GetXer(), 32);
 }
 
-void PPULLVMRecompiler::SetXer(Value * val_x64) {
+void Compiler::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(), (unsigned int)offsetof(PPUThread, XER));
+    auto xer_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, XER));
     auto xer_i64_ptr = m_ir_builder->CreateBitCast(xer_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(val_i64, xer_i64_ptr, 8);
 }
 
-void PPULLVMRecompiler::SetXerCa(Value * ca) {
+void Compiler::SetXerCa(Value * ca) {
     auto xer_i64 = GetXer();
     xer_i64      = SetBit(xer_i64, 34, ca);
     SetXer(xer_i64);
 }
 
-void PPULLVMRecompiler::SetXerSo(Value * so) {
+void Compiler::SetXerSo(Value * so) {
     auto xer_i64 = GetXer();
     xer_i64      = SetBit(xer_i64, 32, so);
     SetXer(xer_i64);
 }
 
-Value * PPULLVMRecompiler::GetUsprg0() {
-    auto usrpg0_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, USPRG0));
+Value * Compiler::GetUsprg0() {
+    auto usrpg0_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, USPRG0));
     auto usprg0_i64_ptr = m_ir_builder->CreateBitCast(usrpg0_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     return m_ir_builder->CreateAlignedLoad(usprg0_i64_ptr, 8);
 }
 
-void PPULLVMRecompiler::SetUsprg0(Value * val_x64) {
+void Compiler::SetUsprg0(Value * val_x64) {
     auto val_i64        = m_ir_builder->CreateBitCast(val_x64, m_ir_builder->getInt64Ty());
-    auto usprg0_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, USPRG0));
+    auto usprg0_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, USPRG0));
     auto usprg0_i64_ptr = m_ir_builder->CreateBitCast(usprg0_i8_ptr, m_ir_builder->getInt64Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(val_i64, usprg0_i64_ptr, 8);
 }
 
-Value * PPULLVMRecompiler::GetFpr(u32 r, u32 bits, bool as_int) {
-    auto r_i8_ptr = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, FPR[r]));
+Value * Compiler::GetFpr(u32 r, u32 bits, bool as_int) {
+    auto r_i8_ptr = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, FPR[r]));
     if (!as_int) {
         auto r_f64_ptr = m_ir_builder->CreateBitCast(r_i8_ptr, m_ir_builder->getDoubleTy()->getPointerTo());
         auto r_f64     = m_ir_builder->CreateAlignedLoad(r_f64_ptr, 8);
@@ -4553,8 +4396,8 @@ Value * PPULLVMRecompiler::GetFpr(u32 r, u32 bits, bool as_int) {
     }
 }
 
-void PPULLVMRecompiler::SetFpr(u32 r, Value * val) {
-    auto r_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, FPR[r]));
+void Compiler::SetFpr(u32 r, Value * val) {
+    auto r_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, FPR[r]));
     auto r_f64_ptr = m_ir_builder->CreateBitCast(r_i8_ptr, m_ir_builder->getDoubleTy()->getPointerTo());
 
     Value* val_f64;
@@ -4570,54 +4413,54 @@ void PPULLVMRecompiler::SetFpr(u32 r, Value * val) {
     m_ir_builder->CreateAlignedStore(val_f64, r_f64_ptr, 8);
 }
 
-Value * PPULLVMRecompiler::GetVscr() {
-    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VSCR));
+Value * Compiler::GetVscr() {
+    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(vscr_i32_ptr, 4);
 }
 
-void PPULLVMRecompiler::SetVscr(Value * val_x32) {
+void Compiler::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(), (unsigned int)offsetof(PPUThread, VSCR));
+    auto vscr_i8_ptr  = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, VSCR));
     auto vscr_i32_ptr = m_ir_builder->CreateBitCast(vscr_i8_ptr, m_ir_builder->getInt32Ty()->getPointerTo());
     m_ir_builder->CreateAlignedStore(val_i32, vscr_i32_ptr, 4);
 }
 
-Value * PPULLVMRecompiler::GetVr(u32 vr) {
-    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
+Value * Compiler::GetVr(u32 vr) {
+    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (unsigned int)offsetof(PPUThread, VPR[vr]));
     auto vr_i128_ptr = m_ir_builder->CreateBitCast(vr_i8_ptr, m_ir_builder->getIntNTy(128)->getPointerTo());
     return m_ir_builder->CreateAlignedLoad(vr_i128_ptr, 16);
 }
 
-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]));
+Value * Compiler::GetVrAsIntVec(u32 vr, u32 vec_elt_num_bits) {
+    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(vr_vec_ptr, 16);
 }
 
-Value * PPULLVMRecompiler::GetVrAsFloatVec(u32 vr) {
-    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
+Value * Compiler::GetVrAsFloatVec(u32 vr) {
+    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(vr_v4f32_ptr, 16);
 }
 
-Value * PPULLVMRecompiler::GetVrAsDoubleVec(u32 vr) {
-    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
+Value * Compiler::GetVrAsDoubleVec(u32 vr) {
+    auto vr_i8_ptr    = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedLoad(vr_v2f64_ptr, 16);
 }
 
-void PPULLVMRecompiler::SetVr(u32 vr, Value * val_x128) {
-    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUState(), (unsigned int)offsetof(PPUThread, VPR[vr]));
+void Compiler::SetVr(u32 vr, Value * val_x128) {
+    auto vr_i8_ptr   = m_ir_builder->CreateConstGEP1_32(GetPPUStateArg(), (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->CreateAlignedStore(val_i128, vr_i128_ptr, 16);
 }
 
-Value * PPULLVMRecompiler::CheckBranchCondition(u32 bo, u32 bi) {
+Value * Compiler::CheckBranchCondition(u32 bo, u32 bi) {
     bool bo0 = bo & 0x10 ? true : false;
     bool bo1 = bo & 0x08 ? true : false;
     bool bo2 = bo & 0x04 ? true : false;
@@ -4659,54 +4502,49 @@ Value * PPULLVMRecompiler::CheckBranchCondition(u32 bo, u32 bi) {
     return cmp_i1;
 }
 
-void PPULLVMRecompiler::CreateBranch(llvm::Value * cmp_i1, llvm::Value * target_i64, bool lk) {
+void Compiler::CreateBranch(llvm::Value * cmp_i1, llvm::Value * target_i64, bool lk, bool target_is_lr) {
     if (lk) {
         SetLr(m_ir_builder->getInt64(m_current_instruction_address + 4));
     }
 
-    auto         current_block = m_ir_builder->GetInsertBlock();
+    auto current_block = m_ir_builder->GetInsertBlock();
+
     BasicBlock * target_block  = nullptr;
     if (dyn_cast<ConstantInt>(target_i64)) {
         // Target address is an immediate value.
         u32 target_address = (u32)(dyn_cast<ConstantInt>(target_i64)->getLimitedValue());
-        target_block       = GetBlockInFunction(target_address, m_current_function);
+        target_block       = GetBasicBlockFromAddress(target_address, m_current_function);
         if (!target_block) {
-            target_block = GetBlockInFunction(target_address, m_current_function, true);
-            if ((m_hit_blocks.find(target_address) != m_hit_blocks.end() || !cmp_i1) && m_num_instructions < 300) {
-                // Target block has either been hit or this is an unconditional branch.
-                m_current_function_uncompiled_blocks_list.push_back(target_address);
-                m_hit_blocks.insert(target_address);
-            } else {
-                // Target block has not been encountered yet and this is not an unconditional branch
-                m_ir_builder->SetInsertPoint(target_block);
-                SetPc(target_i64);
-                m_ir_builder->CreateRetVoid();
-                m_current_function_unhit_blocks_list.push_back(target_address);
-            }
+            target_block = BasicBlock::Create(m_ir_builder->getContext(), "", m_current_function);
+            m_ir_builder->SetInsertPoint(target_block);
+            SetPc(target_i64);
+            m_ir_builder->CreateBr(GetBasicBlockFromAddress(0xFFFFFFFF, m_current_function, true));
         }
     } else {
-        // Target addres is in a register
+        // Target address is in a register
         target_block = BasicBlock::Create(m_ir_builder->getContext(), "", m_current_function);
         m_ir_builder->SetInsertPoint(target_block);
         SetPc(target_i64);
-        m_ir_builder->CreateRetVoid();
+
+        if (target_is_lr && !lk) {
+            // Return from function call
+            m_ir_builder->CreateRetVoid();
+        } else {
+            auto switch_instr = m_ir_builder->CreateSwitch(target_i64, GetBasicBlockFromAddress(0xFFFFFFFF, m_current_function, true));
+            for (auto i = m_current_block_next_blocks->begin(); i != m_current_block_next_blocks->end(); i++) {
+                switch_instr->addCase(m_ir_builder->getInt32(i->address), GetBasicBlockFromAddress(i->address, m_current_function));
+            }
+        }
     }
 
     if (cmp_i1) {
         // Conditional branch
-        auto next_block = GetBlockInFunction(m_current_instruction_address + 4, m_current_function);
+        auto next_block = GetBasicBlockFromAddress(m_current_instruction_address + 4, m_current_function);
         if (!next_block) {
-            next_block = GetBlockInFunction(m_current_instruction_address + 4, m_current_function, true);
-            if (m_hit_blocks.find(m_current_instruction_address + 4) != m_hit_blocks.end() && m_num_instructions < 300) {
-                // Next block has already been hit.
-                m_current_function_uncompiled_blocks_list.push_back(m_current_instruction_address + 4);
-            } else {
-                // Next block has not been encountered yet
-                m_ir_builder->SetInsertPoint(next_block);
-                SetPc(m_ir_builder->getInt32(m_current_instruction_address + 4));
-                m_ir_builder->CreateRetVoid();
-                m_current_function_unhit_blocks_list.push_back(m_current_instruction_address + 4);
-            }
+            next_block = BasicBlock::Create(m_ir_builder->getContext(), "", m_current_function);
+            m_ir_builder->SetInsertPoint(next_block);
+            SetPc(m_ir_builder->getInt32(m_current_instruction_address + 4));
+            m_ir_builder->CreateBr(GetBasicBlockFromAddress(0xFFFFFFFF, m_current_function, true));
         }
 
         m_ir_builder->SetInsertPoint(current_block);
@@ -4720,7 +4558,7 @@ void PPULLVMRecompiler::CreateBranch(llvm::Value * cmp_i1, llvm::Value * target_
     m_hit_branch_instruction = true;
 }
 
-Value * PPULLVMRecompiler::ReadMemory(Value * addr_i64, u32 bits, u32 alignment, bool bswap, bool could_be_mmio) {
+Value * Compiler::ReadMemory(Value * addr_i64, u32 bits, u32 alignment, bool bswap, bool could_be_mmio) {
     if (bits != 32 || could_be_mmio == false) {
         auto eaddr_i64    = m_ir_builder->CreateAdd(addr_i64, m_ir_builder->getInt64((u64)vm::get_ptr<u8>(0)));
         auto eaddr_ix_ptr = m_ir_builder->CreateIntToPtr(eaddr_i64, m_ir_builder->getIntNTy(bits)->getPointerTo());
@@ -4760,7 +4598,7 @@ Value * PPULLVMRecompiler::ReadMemory(Value * addr_i64, u32 bits, u32 alignment,
         m_ir_builder->CreateBr(merge_bb);
 
         m_ir_builder->SetInsertPoint(else_bb);
-        auto val_else_i32 = Call<u32>("vm_read32", (u32(*)(u64))vm::read32, addr_i64);
+        auto val_else_i32 = Call<u32>("vm.read32", (u32(*)(u64))vm::read32, addr_i64);
         if (!bswap) {
             val_else_i32 = m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::bswap, m_ir_builder->getInt32Ty()), val_else_i32);
         }
@@ -4774,7 +4612,7 @@ Value * PPULLVMRecompiler::ReadMemory(Value * addr_i64, u32 bits, u32 alignment,
     }
 }
 
-void PPULLVMRecompiler::WriteMemory(Value * addr_i64, Value * val_ix, u32 alignment, bool bswap, bool could_be_mmio) {
+void Compiler::WriteMemory(Value * addr_i64, Value * val_ix, u32 alignment, bool bswap, bool could_be_mmio) {
     addr_i64 = m_ir_builder->CreateAnd(addr_i64, 0xFFFFFFFF);
     if (val_ix->getType()->getIntegerBitWidth() != 32 || could_be_mmio == false) {
         if (val_ix->getType()->getIntegerBitWidth() > 8 && bswap) {
@@ -4820,7 +4658,7 @@ void PPULLVMRecompiler::WriteMemory(Value * addr_i64, Value * val_ix, u32 alignm
             val_else_i32 = m_ir_builder->CreateCall(Intrinsic::getDeclaration(m_module, Intrinsic::bswap, m_ir_builder->getInt32Ty()), val_else_i32);
         }
 
-        Call<void>("vm_write32", (void(*)(u64, u32))vm::write32, addr_i64, val_else_i32);
+        Call<void>("vm.write32", (void(*)(u64, u32))vm::write32, addr_i64, val_else_i32);
         m_ir_builder->CreateBr(merge_bb);
 
         m_ir_builder->SetInsertPoint(merge_bb);
@@ -4828,19 +4666,19 @@ void PPULLVMRecompiler::WriteMemory(Value * addr_i64, Value * val_ix, u32 alignm
 }
 
 template<class Func, class... 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));
+Value * Compiler::InterpreterCall(const char * name, Func function, Args... args) {
+    auto i = m_stats.interpreter_fallback_stats.find(name);
+    if (i == m_stats.interpreter_fallback_stats.end()) {
+        i = m_stats.interpreter_fallback_stats.insert(m_stats.interpreter_fallback_stats.end(), std::make_pair<std::string, u64>(name, 0));
     }
 
     i->second++;
 
-    return Call<void>(name, function, GetInterpreter(), m_ir_builder->getInt32(args)...);
+    return Call<void>(name, function, GetInterpreterArg(), m_ir_builder->getInt32(args)...);
 }
 
 template<class T>
-Type * PPULLVMRecompiler::CppToLlvmType() {
+Type * Compiler::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) {
@@ -4865,7 +4703,7 @@ Type * PPULLVMRecompiler::CppToLlvmType() {
 }
 
 template<class ReturnType, class Func, class... Args>
-Value * PPULLVMRecompiler::Call(const char * name, Func function, Args... args) {
+Value * Compiler::Call(const char * name, Func function, Args... args) {
     auto fn = m_module->getFunction(name);
     if (!fn) {
         std::vector<Type *> fn_args_type = {args->getType()...};
@@ -4879,7 +4717,22 @@ Value * PPULLVMRecompiler::Call(const char * name, Func function, Args... args)
     return m_ir_builder->CreateCall(fn, fn_args);
 }
 
-void PPULLVMRecompiler::InitRotateMask() {
+bool Compiler::IsBranchInstruction(u32 instruction) {
+    bool is_branch = false;
+    u32  field1    = instruction >> 26;
+    if (field1 == 16 || field1 == 18) {
+        is_branch = true;
+    } else if (field1 == 19) {
+        u32 field2 = (instruction >> 1) & 0x3FF;
+        if (field2 == 16 || field2 == 528) {
+            is_branch = true;
+        }
+    }
+
+    return is_branch;
+}
+
+void Compiler::InitRotateMask() {
     for (u32 mb = 0; mb < 64; mb++) {
         for (u32 me = 0; me < 64; me++) {
             u64 mask = ((u64)-1 >> mb) ^ ((me >= 63) ? 0 : (u64)-1 >> (me + 1));
@@ -4888,101 +4741,188 @@ void PPULLVMRecompiler::InitRotateMask() {
     }
 }
 
-u32                 PPULLVMEmulator::s_num_instances    = 0;
-std::mutex          PPULLVMEmulator::s_recompiler_mutex;
-PPULLVMRecompiler * PPULLVMEmulator::s_recompiler       = nullptr;
+std::mutex                           RecompilationEngine::s_mutex;
+std::shared_ptr<RecompilationEngine> RecompilationEngine::s_the_instance;
 
-PPULLVMEmulator::PPULLVMEmulator(PPUThread & ppu)
+CompiledCodeFragment RecompilationEngine::GetCompiledCodeFragment(u32 address) {
+    return nullptr;
+}
+
+void ReleaseCompiledCodeFragment(CompiledCodeFragment compiled_code_fragment) {
+
+}
+
+u32 RecompilationEngine::GetCurrentRevision() {
+    return 0;
+}
+
+std::shared_ptr<RecompilationEngine> RecompilationEngine::GetInstance() {
+    if (s_the_instance == nullptr) {
+        std::lock_guard<std::mutex> lock(s_mutex);
+        s_the_instance = std::shared_ptr<RecompilationEngine>(new RecompilationEngine());
+    }
+
+    return s_the_instance;
+}
+
+Tracer::Tracer() {
+    m_trace.reserve(1000);
+    m_stack.reserve(100);
+}
+
+Tracer::~Tracer() {
+    Terminate();
+}
+
+void Tracer::Trace(BranchType branch_type, u32 address) {
+    ExecutionTrace * execution_trace = nullptr;
+    BlockId          block_id;
+    int              function;
+    int              start;
+
+    block_id.address = address;
+    block_id.type    = branch_type;
+    switch (branch_type) {
+    case FunctionCall:
+        m_stack.push_back((u32)m_trace.size());
+        m_trace.push_back(block_id);
+        break;
+    case Block:
+        function = m_stack.back();
+        for (int i = (int)m_trace.size() - 1; i >= function; i--) {
+            if (m_trace[i].address == address) {
+                // Found a loop within the current function
+                execution_trace                   = new ExecutionTrace();
+                execution_trace->type             = ExecutionTrace::Loop;
+                execution_trace->function_address = m_trace[function].address;
+                execution_trace->blocks.insert(execution_trace->blocks.begin(), m_trace.begin() + i, m_trace.end());
+                m_trace.erase(m_trace.begin() + i + 1, m_trace.end());
+                break;
+            }
+        }
+
+        if (!execution_trace) {
+            // A loop was not found
+            m_trace.push_back(block_id);
+        }
+        break;
+    case Return:
+        function = m_stack.back();
+        m_stack.pop_back();
+
+        start = function;
+
+        execution_trace                   = new ExecutionTrace();
+        execution_trace->function_address = m_trace[function].address;
+        execution_trace->type             = ExecutionTrace::Linear;
+        execution_trace->blocks.insert(execution_trace->blocks.begin(), m_trace.begin() + start, m_trace.end());
+        m_trace.erase(m_trace.begin() + start + 1, m_trace.end());
+        break;
+    case None:
+        break;
+    default:
+        assert(0);
+        break;
+    }
+
+    if (execution_trace) {
+        auto s = fmt::Format("Trace: 0x%08X, %s -> ", execution_trace->function_address, execution_trace->type == ExecutionTrace::Loop ? "Loop" : "Linear");
+        for (auto i = 0; i < execution_trace->blocks.size(); i++) {
+            s += fmt::Format("0x%08X ", execution_trace->blocks[i]);
+        }
+
+        LOG_NOTICE(PPU, s.c_str());
+        delete execution_trace;
+        // TODO: Notify recompilation engine
+    }
+}
+
+void Tracer::Terminate() {
+    // TODO: Notify recompilation engine
+}
+
+ppu_recompiler_llvm::ExecutionEngine::ExecutionEngine(PPUThread & ppu)
     : m_ppu(ppu)
     , m_interpreter(new PPUInterpreter(ppu))
     , m_decoder(m_interpreter)
-    , m_last_instr_was_branch(true)
+    , m_last_branch_type(FunctionCall)
     , m_last_cache_clear_time(std::chrono::high_resolution_clock::now())
-    , m_recompiler_revision(0) {
-    std::lock_guard<std::mutex> lock(s_recompiler_mutex);
+    , m_recompiler_revision(0)
+    , m_recompilation_engine(RecompilationEngine::GetInstance()) {
+}
 
-    s_num_instances++;
-    if (!s_recompiler) {
-        s_recompiler = new PPULLVMRecompiler();
-        s_recompiler->RunAllTests(&m_ppu, m_interpreter);
+ppu_recompiler_llvm::ExecutionEngine::~ExecutionEngine() {
+    for (auto iter = m_address_to_compiled_code_fragment.begin(); iter != m_address_to_compiled_code_fragment.end(); iter++) {
+        m_recompilation_engine->ReleaseCompiledCodeFragment(iter->second.first);
     }
 }
 
-PPULLVMEmulator::~PPULLVMEmulator() {
-    for (auto iter = m_address_to_executable.begin(); iter != m_address_to_executable.end(); iter++) {
-        s_recompiler->ReleaseExecutable(iter->first, iter->second.revision);
-    }
-
-    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 PPULLVMEmulator::DecodeMemory(const u32 address) {
+u8 ppu_recompiler_llvm::ExecutionEngine::DecodeMemory(const u32 address) {
     auto now = std::chrono::high_resolution_clock::now();
 
-    if (std::chrono::duration_cast<std::chrono::milliseconds>(now - m_last_cache_clear_time).count() > 1000) {
-        bool clear_all  = false;
+    if (std::chrono::duration_cast<std::chrono::milliseconds>(now - m_last_cache_clear_time).count() > 10000) {
+        bool clear_all = false;
 
-        u32 revision = s_recompiler->GetCurrentRevision();
+        u32 revision = m_recompilation_engine->GetCurrentRevision();
         if (m_recompiler_revision != revision) {
             m_recompiler_revision = revision;
             clear_all = true;
         }
 
-        for (auto iter = m_address_to_executable.begin(); iter != m_address_to_executable.end();) {
-            auto tmp = iter;
-            iter++;
-            if (tmp->second.num_hits == 0 || clear_all) {
-                m_address_to_executable.erase(tmp);
-                s_recompiler->ReleaseExecutable(tmp->first, tmp->second.revision);
+        for (auto i = m_address_to_compiled_code_fragment.begin(); i != m_address_to_compiled_code_fragment.end();) {
+            auto tmp = i;
+            i++;
+            if (tmp->second.second == 0 || clear_all) {
+                m_address_to_compiled_code_fragment.erase(tmp);
+                m_recompilation_engine->ReleaseCompiledCodeFragment(tmp->second.first);
             } else {
-                tmp->second.num_hits = 0;
+                tmp->second.second = 0;
             }
         }
 
         m_last_cache_clear_time = now;
     }
 
-    auto address_to_executable_iter = m_address_to_executable.find(address);
-    if (address_to_executable_iter == m_address_to_executable.end()) {
-        auto executable_and_revision = s_recompiler->GetExecutable(address);
-        if (executable_and_revision.first) {
-            ExecutableInfo executable_info;
-            executable_info.executable = executable_and_revision.first;
-            executable_info.revision   = executable_and_revision.second;
-            executable_info.num_hits   = 0;
-
-            address_to_executable_iter = m_address_to_executable.insert(m_address_to_executable.end(), std::make_pair(address, executable_info));
-            m_uncompiled.erase(address);
-        } else {
-            if (m_last_instr_was_branch) {
-                auto uncompiled_iter = m_uncompiled.find(address);
-                if (uncompiled_iter != m_uncompiled.end()) {
-                    uncompiled_iter->second++;
-                    if ((uncompiled_iter->second % 1000) == 0) {
-                        s_recompiler->RequestCompilation(address);
-                    }
-                } else {
-                    m_uncompiled[address] = 0;
-                }
-            }
+    auto i = m_address_to_compiled_code_fragment.find(address);
+    if (i == m_address_to_compiled_code_fragment.end()) {
+        auto compiled_code_fragment = m_recompilation_engine->GetCompiledCodeFragment(address);
+        if (compiled_code_fragment) {
+            i = m_address_to_compiled_code_fragment.insert(m_address_to_compiled_code_fragment.end(), std::make_pair(address, std::make_pair(compiled_code_fragment, 0)));
         }
     }
 
     u8 ret = 0;
-    if (address_to_executable_iter != m_address_to_executable.end()) {
-        address_to_executable_iter->second.executable(&m_ppu, m_interpreter);
-        address_to_executable_iter->second.num_hits++;
-        m_last_instr_was_branch = true;
+    if (i != m_address_to_compiled_code_fragment.end()) {
+        m_last_branch_type = None;
+        i->second.second++;
+        i->second.first(&m_ppu, m_interpreter);
     } else {
-        ret                     = m_decoder.DecodeMemory(address);
-        m_last_instr_was_branch = m_ppu.m_is_branch;
+        if (m_last_branch_type != None) {
+            m_tracer.Trace(m_last_branch_type, address);
+        }
+
+        ret                = m_decoder.DecodeMemory(address);
+        m_last_branch_type = m_ppu.m_is_branch ? GetBranchTypeFromInstruction(vm::read32(address)) : None;
     }
 
     return ret;
 }
+
+BranchType GetBranchTypeFromInstruction(u32 instruction) {
+    auto type   = BranchType::None;
+    auto field1 = instruction >> 26;
+    auto lk     = instruction & 1;
+
+    if (field1 == 16 || field1 == 18) {
+        type = lk ? FunctionCall : Block;
+    } else if (field1 == 19) {
+        u32 field2 = (instruction >> 1) & 0x3FF;
+        if (field2 == 16) {
+            type = lk ? FunctionCall : Return;
+        } else if (field2 == 528) {
+            type = lk ? FunctionCall : Block;
+        }
+    }
+
+    return type;
+}
diff --git a/rpcs3/Emu/Cell/PPULLVMRecompiler.h b/rpcs3/Emu/Cell/PPULLVMRecompiler.h
index 218dad9721..a93da8021b 100644
--- a/rpcs3/Emu/Cell/PPULLVMRecompiler.h
+++ b/rpcs3/Emu/Cell/PPULLVMRecompiler.h
@@ -11,779 +11,822 @@
 #include "llvm/ExecutionEngine/JIT.h"
 #include "llvm/PassManager.h"
 
-struct PPUState;
-
-/// PPU recompiler that uses LLVM for code generation and optimization
-class PPULLVMRecompiler : public ThreadBase, protected PPUOpcodes, protected PPCDecoder {
-public:
-    typedef void(*Executable)(PPUThread * ppu_state, PPUInterpreter * interpreter);
-
-    PPULLVMRecompiler();
-
-    PPULLVMRecompiler(const PPULLVMRecompiler & other) = delete;
-    PPULLVMRecompiler(PPULLVMRecompiler && other) = delete;
-
-    virtual ~PPULLVMRecompiler();
-
-    PPULLVMRecompiler & operator = (const PPULLVMRecompiler & other) = delete;
-    PPULLVMRecompiler & operator = (PPULLVMRecompiler && other) = delete;
-
-    /// Get the executable for the code starting at address
-    std::pair<Executable, u32> GetExecutable(u32 address);
-
-    /// Release an executable earlier obtained through GetExecutable
-    void ReleaseExecutable(u32 address, u32 revision);
-
-    /// Request the code at the sepcified address to be compiled
-    void RequestCompilation(u32 address);
-
-    /// Get the current revision
-    u32 GetCurrentRevision();
-
-    /// Execute all tests
-    void RunAllTests(PPUThread * ppu_state, PPUInterpreter * interpreter);
-
-    void Task() override;
-
-protected:
-    void Decode(const u32 code) override;
-
-    void NULL_OP() override;
-    void NOP() override;
-
-    void TDI(u32 to, u32 ra, s32 simm16) override;
-    void TWI(u32 to, u32 ra, s32 simm16) override;
-
-    void MFVSCR(u32 vd) override;
-    void MTVSCR(u32 vb) override;
-    void VADDCUW(u32 vd, u32 va, u32 vb) override;
-    void VADDFP(u32 vd, u32 va, u32 vb) override;
-    void VADDSBS(u32 vd, u32 va, u32 vb) override;
-    void VADDSHS(u32 vd, u32 va, u32 vb) override;
-    void VADDSWS(u32 vd, u32 va, u32 vb) override;
-    void VADDUBM(u32 vd, u32 va, u32 vb) override;
-    void VADDUBS(u32 vd, u32 va, u32 vb) override;
-    void VADDUHM(u32 vd, u32 va, u32 vb) override;
-    void VADDUHS(u32 vd, u32 va, u32 vb) override;
-    void VADDUWM(u32 vd, u32 va, u32 vb) override;
-    void VADDUWS(u32 vd, u32 va, u32 vb) override;
-    void VAND(u32 vd, u32 va, u32 vb) override;
-    void VANDC(u32 vd, u32 va, u32 vb) override;
-    void VAVGSB(u32 vd, u32 va, u32 vb) override;
-    void VAVGSH(u32 vd, u32 va, u32 vb) override;
-    void VAVGSW(u32 vd, u32 va, u32 vb) override;
-    void VAVGUB(u32 vd, u32 va, u32 vb) override;
-    void VAVGUH(u32 vd, u32 va, u32 vb) override;
-    void VAVGUW(u32 vd, u32 va, u32 vb) override;
-    void VCFSX(u32 vd, u32 uimm5, u32 vb) override;
-    void VCFUX(u32 vd, u32 uimm5, u32 vb) override;
-    void VCMPBFP(u32 vd, u32 va, u32 vb) override;
-    void VCMPBFP_(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQFP(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQFP_(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQUB(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQUB_(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQUH(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQUH_(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQUW(u32 vd, u32 va, u32 vb) override;
-    void VCMPEQUW_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGEFP(u32 vd, u32 va, u32 vb) override;
-    void VCMPGEFP_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTFP(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTFP_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTSB(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTSB_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTSH(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTSH_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTSW(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTSW_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTUB(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTUB_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTUH(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTUH_(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTUW(u32 vd, u32 va, u32 vb) override;
-    void VCMPGTUW_(u32 vd, u32 va, u32 vb) override;
-    void VCTSXS(u32 vd, u32 uimm5, u32 vb) override;
-    void VCTUXS(u32 vd, u32 uimm5, u32 vb) override;
-    void VEXPTEFP(u32 vd, u32 vb) override;
-    void VLOGEFP(u32 vd, u32 vb) override;
-    void VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) override;
-    void VMAXFP(u32 vd, u32 va, u32 vb) override;
-    void VMAXSB(u32 vd, u32 va, u32 vb) override;
-    void VMAXSH(u32 vd, u32 va, u32 vb) override;
-    void VMAXSW(u32 vd, u32 va, u32 vb) override;
-    void VMAXUB(u32 vd, u32 va, u32 vb) override;
-    void VMAXUH(u32 vd, u32 va, u32 vb) override;
-    void VMAXUW(u32 vd, u32 va, u32 vb) override;
-    void VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMINFP(u32 vd, u32 va, u32 vb) override;
-    void VMINSB(u32 vd, u32 va, u32 vb) override;
-    void VMINSH(u32 vd, u32 va, u32 vb) override;
-    void VMINSW(u32 vd, u32 va, u32 vb) override;
-    void VMINUB(u32 vd, u32 va, u32 vb) override;
-    void VMINUH(u32 vd, u32 va, u32 vb) override;
-    void VMINUW(u32 vd, u32 va, u32 vb) override;
-    void VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMRGHB(u32 vd, u32 va, u32 vb) override;
-    void VMRGHH(u32 vd, u32 va, u32 vb) override;
-    void VMRGHW(u32 vd, u32 va, u32 vb) override;
-    void VMRGLB(u32 vd, u32 va, u32 vb) override;
-    void VMRGLH(u32 vd, u32 va, u32 vb) override;
-    void VMRGLW(u32 vd, u32 va, u32 vb) override;
-    void VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VMULESB(u32 vd, u32 va, u32 vb) override;
-    void VMULESH(u32 vd, u32 va, u32 vb) override;
-    void VMULEUB(u32 vd, u32 va, u32 vb) override;
-    void VMULEUH(u32 vd, u32 va, u32 vb) override;
-    void VMULOSB(u32 vd, u32 va, u32 vb) override;
-    void VMULOSH(u32 vd, u32 va, u32 vb) override;
-    void VMULOUB(u32 vd, u32 va, u32 vb) override;
-    void VMULOUH(u32 vd, u32 va, u32 vb) override;
-    void VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) override;
-    void VNOR(u32 vd, u32 va, u32 vb) override;
-    void VOR(u32 vd, u32 va, u32 vb) override;
-    void VPERM(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VPKPX(u32 vd, u32 va, u32 vb) override;
-    void VPKSHSS(u32 vd, u32 va, u32 vb) override;
-    void VPKSHUS(u32 vd, u32 va, u32 vb) override;
-    void VPKSWSS(u32 vd, u32 va, u32 vb) override;
-    void VPKSWUS(u32 vd, u32 va, u32 vb) override;
-    void VPKUHUM(u32 vd, u32 va, u32 vb) override;
-    void VPKUHUS(u32 vd, u32 va, u32 vb) override;
-    void VPKUWUM(u32 vd, u32 va, u32 vb) override;
-    void VPKUWUS(u32 vd, u32 va, u32 vb) override;
-    void VREFP(u32 vd, u32 vb) override;
-    void VRFIM(u32 vd, u32 vb) override;
-    void VRFIN(u32 vd, u32 vb) override;
-    void VRFIP(u32 vd, u32 vb) override;
-    void VRFIZ(u32 vd, u32 vb) override;
-    void VRLB(u32 vd, u32 va, u32 vb) override;
-    void VRLH(u32 vd, u32 va, u32 vb) override;
-    void VRLW(u32 vd, u32 va, u32 vb) override;
-    void VRSQRTEFP(u32 vd, u32 vb) override;
-    void VSEL(u32 vd, u32 va, u32 vb, u32 vc) override;
-    void VSL(u32 vd, u32 va, u32 vb) override;
-    void VSLB(u32 vd, u32 va, u32 vb) override;
-    void VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) override;
-    void VSLH(u32 vd, u32 va, u32 vb) override;
-    void VSLO(u32 vd, u32 va, u32 vb) override;
-    void VSLW(u32 vd, u32 va, u32 vb) override;
-    void VSPLTB(u32 vd, u32 uimm5, u32 vb) override;
-    void VSPLTH(u32 vd, u32 uimm5, u32 vb) override;
-    void VSPLTISB(u32 vd, s32 simm5) override;
-    void VSPLTISH(u32 vd, s32 simm5) override;
-    void VSPLTISW(u32 vd, s32 simm5) override;
-    void VSPLTW(u32 vd, u32 uimm5, u32 vb) override;
-    void VSR(u32 vd, u32 va, u32 vb) override;
-    void VSRAB(u32 vd, u32 va, u32 vb) override;
-    void VSRAH(u32 vd, u32 va, u32 vb) override;
-    void VSRAW(u32 vd, u32 va, u32 vb) override;
-    void VSRB(u32 vd, u32 va, u32 vb) override;
-    void VSRH(u32 vd, u32 va, u32 vb) override;
-    void VSRO(u32 vd, u32 va, u32 vb) override;
-    void VSRW(u32 vd, u32 va, u32 vb) override;
-    void VSUBCUW(u32 vd, u32 va, u32 vb) override;
-    void VSUBFP(u32 vd, u32 va, u32 vb) override;
-    void VSUBSBS(u32 vd, u32 va, u32 vb) override;
-    void VSUBSHS(u32 vd, u32 va, u32 vb) override;
-    void VSUBSWS(u32 vd, u32 va, u32 vb) override;
-    void VSUBUBM(u32 vd, u32 va, u32 vb) override;
-    void VSUBUBS(u32 vd, u32 va, u32 vb) override;
-    void VSUBUHM(u32 vd, u32 va, u32 vb) override;
-    void VSUBUHS(u32 vd, u32 va, u32 vb) override;
-    void VSUBUWM(u32 vd, u32 va, u32 vb) override;
-    void VSUBUWS(u32 vd, u32 va, u32 vb) override;
-    void VSUMSWS(u32 vd, u32 va, u32 vb) override;
-    void VSUM2SWS(u32 vd, u32 va, u32 vb) override;
-    void VSUM4SBS(u32 vd, u32 va, u32 vb) override;
-    void VSUM4SHS(u32 vd, u32 va, u32 vb) override;
-    void VSUM4UBS(u32 vd, u32 va, u32 vb) override;
-    void VUPKHPX(u32 vd, u32 vb) override;
-    void VUPKHSB(u32 vd, u32 vb) override;
-    void VUPKHSH(u32 vd, u32 vb) override;
-    void VUPKLPX(u32 vd, u32 vb) override;
-    void VUPKLSB(u32 vd, u32 vb) override;
-    void VUPKLSH(u32 vd, u32 vb) override;
-    void VXOR(u32 vd, u32 va, u32 vb) override;
-    void MULLI(u32 rd, u32 ra, s32 simm16) override;
-    void SUBFIC(u32 rd, u32 ra, s32 simm16) override;
-    void CMPLI(u32 bf, u32 l, u32 ra, u32 uimm16) override;
-    void CMPI(u32 bf, u32 l, u32 ra, s32 simm16) override;
-    void ADDIC(u32 rd, u32 ra, s32 simm16) override;
-    void ADDIC_(u32 rd, u32 ra, s32 simm16) override;
-    void ADDI(u32 rd, u32 ra, s32 simm16) override;
-    void ADDIS(u32 rd, u32 ra, s32 simm16) override;
-    void BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) override;
-    void SC(u32 sc_code) override;
-    void B(s32 ll, u32 aa, u32 lk) override;
-    void MCRF(u32 crfd, u32 crfs) override;
-    void BCLR(u32 bo, u32 bi, u32 bh, u32 lk) override;
-    void CRNOR(u32 bt, u32 ba, u32 bb) override;
-    void CRANDC(u32 bt, u32 ba, u32 bb) override;
-    void ISYNC() override;
-    void CRXOR(u32 bt, u32 ba, u32 bb) override;
-    void CRNAND(u32 bt, u32 ba, u32 bb) override;
-    void CRAND(u32 bt, u32 ba, u32 bb) override;
-    void CREQV(u32 bt, u32 ba, u32 bb) override;
-    void CRORC(u32 bt, u32 ba, u32 bb) override;
-    void CROR(u32 bt, u32 ba, u32 bb) override;
-    void BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) override;
-    void RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) override;
-    void RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) override;
-    void RLWNM(u32 ra, u32 rs, u32 rb, u32 MB, u32 ME, bool rc) override;
-    void ORI(u32 rs, u32 ra, u32 uimm16) override;
-    void ORIS(u32 rs, u32 ra, u32 uimm16) override;
-    void XORI(u32 ra, u32 rs, u32 uimm16) override;
-    void XORIS(u32 ra, u32 rs, u32 uimm16) override;
-    void ANDI_(u32 ra, u32 rs, u32 uimm16) override;
-    void ANDIS_(u32 ra, u32 rs, u32 uimm16) override;
-    void RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) override;
-    void RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) override;
-    void RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) override;
-    void RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) override;
-    void RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) override;
-    void CMP(u32 crfd, u32 l, u32 ra, u32 rb) override;
-    void TW(u32 to, u32 ra, u32 rb) override;
-    void LVSL(u32 vd, u32 ra, u32 rb) override;
-    void LVEBX(u32 vd, u32 ra, u32 rb) override;
-    void SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void MULHDU(u32 rd, u32 ra, u32 rb, bool rc) override;
-    void ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void MULHWU(u32 rd, u32 ra, u32 rb, bool rc) override;
-    void MFOCRF(u32 a, u32 rd, u32 crm) override;
-    void LWARX(u32 rd, u32 ra, u32 rb) override;
-    void LDX(u32 ra, u32 rs, u32 rb) override;
-    void LWZX(u32 rd, u32 ra, u32 rb) override;
-    void SLW(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void CNTLZW(u32 ra, u32 rs, bool rc) override;
-    void SLD(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void AND(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void CMPL(u32 bf, u32 l, u32 ra, u32 rb) override;
-    void LVSR(u32 vd, u32 ra, u32 rb) override;
-    void LVEHX(u32 vd, u32 ra, u32 rb) override;
-    void SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void LDUX(u32 rd, u32 ra, u32 rb) override;
-    void DCBST(u32 ra, u32 rb) override;
-    void LWZUX(u32 rd, u32 ra, u32 rb) override;
-    void CNTLZD(u32 ra, u32 rs, bool rc) override;
-    void ANDC(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void TD(u32 to, u32 ra, u32 rb) override;
-    void LVEWX(u32 vd, u32 ra, u32 rb) override;
-    void MULHD(u32 rd, u32 ra, u32 rb, bool rc) override;
-    void MULHW(u32 rd, u32 ra, u32 rb, bool rc) override;
-    void LDARX(u32 rd, u32 ra, u32 rb) override;
-    void DCBF(u32 ra, u32 rb) override;
-    void LBZX(u32 rd, u32 ra, u32 rb) override;
-    void LVX(u32 vd, u32 ra, u32 rb) override;
-    void NEG(u32 rd, u32 ra, u32 oe, bool rc) override;
-    void LBZUX(u32 rd, u32 ra, u32 rb) override;
-    void NOR(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void STVEBX(u32 vs, u32 ra, u32 rb) override;
-    void SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void MTOCRF(u32 l, u32 crm, u32 rs) override;
-    void STDX(u32 rs, u32 ra, u32 rb) override;
-    void STWCX_(u32 rs, u32 ra, u32 rb) override;
-    void STWX(u32 rs, u32 ra, u32 rb) override;
-    void STVEHX(u32 vs, u32 ra, u32 rb) override;
-    void STDUX(u32 rs, u32 ra, u32 rb) override;
-    void STWUX(u32 rs, u32 ra, u32 rb) override;
-    void STVEWX(u32 vs, u32 ra, u32 rb) override;
-    void SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) override;
-    void ADDZE(u32 rd, u32 ra, u32 oe, bool rc) override;
-    void STDCX_(u32 rs, u32 ra, u32 rb) override;
-    void STBX(u32 rs, u32 ra, u32 rb) override;
-    void STVX(u32 vs, u32 ra, u32 rb) override;
-    void MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void SUBFME(u32 rd, u32 ra, u32 oe, bool rc) override;
-    void ADDME(u32 rd, u32 ra, u32 oe, bool rc) override;
-    void MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void DCBTST(u32 ra, u32 rb, u32 th) override;
-    void STBUX(u32 rs, u32 ra, u32 rb) override;
-    void ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void DCBT(u32 ra, u32 rb, u32 th) override;
-    void LHZX(u32 rd, u32 ra, u32 rb) override;
-    void EQV(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void ECIWX(u32 rd, u32 ra, u32 rb) override;
-    void LHZUX(u32 rd, u32 ra, u32 rb) override;
-    void XOR(u32 rs, u32 ra, u32 rb, bool rc) override;
-    void MFSPR(u32 rd, u32 spr) override;
-    void LWAX(u32 rd, u32 ra, u32 rb) override;
-    void DST(u32 ra, u32 rb, u32 strm, u32 t) override;
-    void LHAX(u32 rd, u32 ra, u32 rb) override;
-    void LVXL(u32 vd, u32 ra, u32 rb) override;
-    void MFTB(u32 rd, u32 spr) override;
-    void LWAUX(u32 rd, u32 ra, u32 rb) override;
-    void DSTST(u32 ra, u32 rb, u32 strm, u32 t) override;
-    void LHAUX(u32 rd, u32 ra, u32 rb) override;
-    void STHX(u32 rs, u32 ra, u32 rb) override;
-    void ORC(u32 rs, u32 ra, u32 rb, bool rc) override;
-    void ECOWX(u32 rs, u32 ra, u32 rb) override;
-    void STHUX(u32 rs, u32 ra, u32 rb) override;
-    void OR(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void MTSPR(u32 spr, u32 rs) override;
-    //DCBI
-    void NAND(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void STVXL(u32 vs, u32 ra, u32 rb) override;
-    void DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
-    void LVLX(u32 vd, u32 ra, u32 rb) override;
-    void LDBRX(u32 rd, u32 ra, u32 rb) override;
-    void LSWX(u32 rd, u32 ra, u32 rb) override;
-    void LWBRX(u32 rd, u32 ra, u32 rb) override;
-    void LFSX(u32 frd, u32 ra, u32 rb) override;
-    void SRW(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void SRD(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void LVRX(u32 vd, u32 ra, u32 rb) override;
-    void LSWI(u32 rd, u32 ra, u32 nb) override;
-    void LFSUX(u32 frd, u32 ra, u32 rb) override;
-    void SYNC(u32 l) override;
-    void LFDX(u32 frd, u32 ra, u32 rb) override;
-    void LFDUX(u32 frd, u32 ra, u32 rb) override;
-    void STVLX(u32 vs, u32 ra, u32 rb) override;
-    void STSWX(u32 rs, u32 ra, u32 rb) override;
-    void STWBRX(u32 rs, u32 ra, u32 rb) override;
-    void STFSX(u32 frs, u32 ra, u32 rb) override;
-    void STVRX(u32 vs, u32 ra, u32 rb) override;
-    void STFSUX(u32 frs, u32 ra, u32 rb) override;
-    void STSWI(u32 rd, u32 ra, u32 nb) override;
-    void STFDX(u32 frs, u32 ra, u32 rb) override;
-    void STFDUX(u32 frs, u32 ra, u32 rb) override;
-    void LVLXL(u32 vd, u32 ra, u32 rb) override;
-    void LHBRX(u32 rd, u32 ra, u32 rb) override;
-    void SRAW(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void SRAD(u32 ra, u32 rs, u32 rb, bool rc) override;
-    void LVRXL(u32 vd, u32 ra, u32 rb) override;
-    void DSS(u32 strm, u32 a) override;
-    void SRAWI(u32 ra, u32 rs, u32 sh, bool rc) override;
-    void SRADI1(u32 ra, u32 rs, u32 sh, bool rc) override;
-    void SRADI2(u32 ra, u32 rs, u32 sh, bool rc) override;
-    void EIEIO() override;
-    void STVLXL(u32 vs, u32 ra, u32 rb) override;
-    void STHBRX(u32 rs, u32 ra, u32 rb) override;
-    void EXTSH(u32 ra, u32 rs, bool rc) override;
-    void STVRXL(u32 sd, u32 ra, u32 rb) override;
-    void EXTSB(u32 ra, u32 rs, bool rc) override;
-    void STFIWX(u32 frs, u32 ra, u32 rb) override;
-    void EXTSW(u32 ra, u32 rs, bool rc) override;
-    void ICBI(u32 ra, u32 rb) override;
-    void DCBZ(u32 ra, u32 rb) override;
-    void LWZ(u32 rd, u32 ra, s32 d) override;
-    void LWZU(u32 rd, u32 ra, s32 d) override;
-    void LBZ(u32 rd, u32 ra, s32 d) override;
-    void LBZU(u32 rd, u32 ra, s32 d) override;
-    void STW(u32 rs, u32 ra, s32 d) override;
-    void STWU(u32 rs, u32 ra, s32 d) override;
-    void STB(u32 rs, u32 ra, s32 d) override;
-    void STBU(u32 rs, u32 ra, s32 d) override;
-    void LHZ(u32 rd, u32 ra, s32 d) override;
-    void LHZU(u32 rd, u32 ra, s32 d) override;
-    void LHA(u32 rs, u32 ra, s32 d) override;
-    void LHAU(u32 rs, u32 ra, s32 d) override;
-    void STH(u32 rs, u32 ra, s32 d) override;
-    void STHU(u32 rs, u32 ra, s32 d) override;
-    void LMW(u32 rd, u32 ra, s32 d) override;
-    void STMW(u32 rs, u32 ra, s32 d) override;
-    void LFS(u32 frd, u32 ra, s32 d) override;
-    void LFSU(u32 frd, u32 ra, s32 d) override;
-    void LFD(u32 frd, u32 ra, s32 d) override;
-    void LFDU(u32 frd, u32 ra, s32 d) override;
-    void STFS(u32 frs, u32 ra, s32 d) override;
-    void STFSU(u32 frs, u32 ra, s32 d) override;
-    void STFD(u32 frs, u32 ra, s32 d) override;
-    void STFDU(u32 frs, u32 ra, s32 d) override;
-    void LD(u32 rd, u32 ra, s32 ds) override;
-    void LDU(u32 rd, u32 ra, s32 ds) override;
-    void LWA(u32 rd, u32 ra, s32 ds) override;
-    void FDIVS(u32 frd, u32 fra, u32 frb, bool rc) override;
-    void FSUBS(u32 frd, u32 fra, u32 frb, bool rc) override;
-    void FADDS(u32 frd, u32 fra, u32 frb, bool rc) override;
-    void FSQRTS(u32 frd, u32 frb, bool rc) override;
-    void FRES(u32 frd, u32 frb, bool rc) override;
-    void FMULS(u32 frd, u32 fra, u32 frc, bool rc) override;
-    void FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void STD(u32 rs, u32 ra, s32 ds) override;
-    void STDU(u32 rs, u32 ra, s32 ds) override;
-    void MTFSB1(u32 bt, bool rc) override;
-    void MCRFS(u32 bf, u32 bfa) override;
-    void MTFSB0(u32 bt, bool rc) override;
-    void MTFSFI(u32 crfd, u32 i, bool rc) override;
-    void MFFS(u32 frd, bool rc) override;
-    void MTFSF(u32 flm, u32 frb, bool rc) override;
-
-    void FCMPU(u32 bf, u32 fra, u32 frb) override;
-    void FRSP(u32 frd, u32 frb, bool rc) override;
-    void FCTIW(u32 frd, u32 frb, bool rc) override;
-    void FCTIWZ(u32 frd, u32 frb, bool rc) override;
-    void FDIV(u32 frd, u32 fra, u32 frb, bool rc) override;
-    void FSUB(u32 frd, u32 fra, u32 frb, bool rc) override;
-    void FADD(u32 frd, u32 fra, u32 frb, bool rc) override;
-    void FSQRT(u32 frd, u32 frb, bool rc) override;
-    void FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FMUL(u32 frd, u32 fra, u32 frc, bool rc) override;
-    void FRSQRTE(u32 frd, u32 frb, bool rc) override;
-    void FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
-    void FCMPO(u32 crfd, u32 fra, u32 frb) override;
-    void FNEG(u32 frd, u32 frb, bool rc) override;
-    void FMR(u32 frd, u32 frb, bool rc) override;
-    void FNABS(u32 frd, u32 frb, bool rc) override;
-    void FABS(u32 frd, u32 frb, bool rc) override;
-    void FCTID(u32 frd, u32 frb, bool rc) override;
-    void FCTIDZ(u32 frd, u32 frb, bool rc) override;
-    void FCFID(u32 frd, u32 frb, bool rc) override;
-
-    void UNK(const u32 code, const u32 opcode, const u32 gcode) override;
-
-private:
-    struct ExecutableInfo {
-        /// Pointer to the executable
-        Executable executable;
-
-        /// Size of the executable
-        size_t size;
-
-        /// Number of PPU instructions compiled into this executable
-        u32 num_instructions;
-
-        /// List of blocks that this executable refers to that have not been hit yet
-        std::list<u32> unhit_blocks_list;
-
-        /// LLVM function corresponding to the executable
-        llvm::Function * llvm_function;
+namespace ppu_recompiler_llvm {
+    /// Branch type
+    enum BranchType {
+        None,
+        FunctionCall,
+        Block,
+        Return,
     };
 
-    /// Lock for accessing m_compiled_shared
-    // TODO: Use a RW lock
-    std::mutex m_compiled_shared_lock;
+    /// Unique id of a block
+    union BlockId {
+        u64 block_id;
 
-    /// Sections that have been compiled. This data store is shared with the execution threads.
-    /// Keys are starting address of the section and ~revision. Data is pointer to the executable and its reference count.
-    std::map<std::pair<u32, u32>, std::pair<Executable, u32>> m_compiled_shared;
+        struct {
+            /// Address of the block
+            u32 address;
 
-    /// Lock for accessing m_uncompiled_shared
-    std::mutex m_uncompiled_shared_lock;
-
-    /// Current revision. This is incremented everytime a section is compiled.
-    std::atomic<u32> m_revision;
-
-    /// Sections that have not been compiled yet. This data store is shared with the execution threads.
-    std::list<u32> m_uncompiled_shared;
-
-    /// Set of all blocks that have been hit
-    std::set<u32> m_hit_blocks;
-
-    /// Sections that have been compiled. Keys are starting address of the section and ~revision.
-    std::map<std::pair<u32, u32>, ExecutableInfo> m_compiled;
-
-    /// LLVM context
-    llvm::LLVMContext * m_llvm_context;
-
-    /// LLVM IR builder
-    llvm::IRBuilder<> * m_ir_builder;
-
-    /// Module to which all generated code is output to
-    llvm::Module * m_module;
-
-    /// JIT execution engine
-    llvm::ExecutionEngine * m_execution_engine;
-
-    /// Function pass manager
-    llvm::FunctionPassManager * m_fpm;
-
-    /// A flag used to detect branch instructions.
-    /// This is set to false at the start of compilation of a block.
-    /// When a branch instruction is encountered, this is set to true by the decode function.
-    bool m_hit_branch_instruction;
-
-    /// The function being compiled
-    llvm::Function * m_current_function;
-
-    /// List of blocks to be compiled in the current function being compiled
-    std::list<u32> m_current_function_uncompiled_blocks_list;
-
-    /// List of blocks that the current function refers to but have not been hit yet
-    std::list<u32> m_current_function_unhit_blocks_list;
-
-    /// Address of the current instruction
-    u32 m_current_instruction_address;
-
-    /// Number of instructions in this section
-    u32 m_num_instructions;
-
-    /// Time spent building the LLVM IR
-    std::chrono::nanoseconds m_ir_build_time;
-
-    /// Time spent optimizing
-    std::chrono::nanoseconds m_optimizing_time;
-
-    /// Time spent translating LLVM IR to machine code
-    std::chrono::nanoseconds m_translation_time;
-
-    /// Time spent compiling
-    std::chrono::nanoseconds m_compilation_time;
-
-    /// Time spent idling
-    std::chrono::nanoseconds m_idling_time;
-
-    /// Total time
-    std::chrono::nanoseconds m_total_time;
-
-    /// Contains the number of times the interpreter fallback was used
-    std::map<std::string, u64> m_interpreter_fallback_stats;
-
-    /// Get the block in function for the instruction at the specified address.
-    llvm::BasicBlock * GetBlockInFunction(u32 address, llvm::Function * function, bool create_if_not_exist = false);
-
-    /// Compile the section startin at address
-    void Compile(u32 address);
-
-    /// Remove old versions of executables that are no longer used by any execution thread
-    void RemoveUnusedOldVersions();
-
-    /// Test whether the blocks needs to be compiled
-    bool NeedsCompiling(u32 address);
-
-    /// Get PPU state pointer
-    llvm::Value * GetPPUState();
-
-    /// Get interpreter pointer
-    llvm::Value * GetInterpreter();
-
-    /// Get a bit
-    llvm::Value * GetBit(llvm::Value * val, u32 n);
-
-    /// Clear a bit
-    llvm::Value * ClrBit(llvm::Value * val, u32 n);
-
-    /// Set a bit
-    llvm::Value * SetBit(llvm::Value * val, u32 n, llvm::Value * bit, bool doClear = true);
-
-    /// Get a nibble
-    llvm::Value * GetNibble(llvm::Value * val, u32 n);
-
-    /// Clear a nibble
-    llvm::Value * ClrNibble(llvm::Value * val, u32 n);
-
-    /// Set a nibble
-    llvm::Value * SetNibble(llvm::Value * val, u32 n, llvm::Value * nibble, bool doClear = true);
-
-    /// Set a nibble
-    llvm::Value * SetNibble(llvm::Value * val, u32 n, llvm::Value * b0, llvm::Value * b1, llvm::Value * b2, llvm::Value * b3, bool doClear = true);
-
-    /// Load PC
-    llvm::Value * GetPc();
-
-    /// Set PC
-    void SetPc(llvm::Value * val_ix);
-
-    /// Load GPR
-    llvm::Value * GetGpr(u32 r, u32 num_bits = 64);
-
-    /// Set GPR
-    void SetGpr(u32 r, llvm::Value * val_x64);
-
-    /// Load CR
-    llvm::Value * GetCr();
-
-    /// Load CR and get field CRn
-    llvm::Value * GetCrField(u32 n);
-
-    /// Set CR
-    void SetCr(llvm::Value * val_x32);
-
-    /// Set CR field
-    void SetCrField(u32 n, llvm::Value * field);
-
-    /// Set CR field
-    void SetCrField(u32 n, llvm::Value * b0, llvm::Value * b1, llvm::Value * b2, llvm::Value * b3);
-
-    /// Set CR field based on signed comparison
-    void SetCrFieldSignedCmp(u32 n, llvm::Value * a, llvm::Value * b);
-
-    /// Set CR field based on unsigned comparison
-    void SetCrFieldUnsignedCmp(u32 n, llvm::Value * a, llvm::Value * b);
-
-    /// Set CR6 based on the result of the vector compare instruction
-    void SetCr6AfterVectorCompare(u32 vr);
-
-    /// Get LR
-    llvm::Value * GetLr();
-
-    /// Set LR
-    void SetLr(llvm::Value * val_x64);
-
-    /// Get CTR
-    llvm::Value * GetCtr();
-
-    /// Set CTR
-    void SetCtr(llvm::Value * val_x64);
-
-    /// Load XER and convert it to an i64
-    llvm::Value * GetXer();
-
-    /// Load XER and return the CA bit
-    llvm::Value * GetXerCa();
-
-    /// Load XER and return the SO bit
-    llvm::Value * GetXerSo();
-
-    /// Set XER
-    void SetXer(llvm::Value * val_x64);
-
-    /// Set the CA bit of XER
-    void SetXerCa(llvm::Value * ca);
-
-    /// Set the SO bit of XER
-    void SetXerSo(llvm::Value * so);
-
-    /// Get USPRG0
-    llvm::Value * GetUsprg0();
-
-    /// Set USPRG0
-    void SetUsprg0(llvm::Value * val_x64);
-
-    /// Get FPR
-    llvm::Value * GetFpr(u32 r, u32 bits = 64, bool as_int = false);
-
-    /// Set FPR
-    void SetFpr(u32 r, llvm::Value * val);
-
-    /// Load VSCR
-    llvm::Value * GetVscr();
-
-    /// Set VSCR
-    void SetVscr(llvm::Value * val_x32);
-
-    /// Load VR
-    llvm::Value * GetVr(u32 vr);
-
-    /// Load VR and convert it to an integer vector
-    llvm::Value * GetVrAsIntVec(u32 vr, u32 vec_elt_num_bits);
-
-    /// Load VR and convert it to a float vector with 4 elements
-    llvm::Value * GetVrAsFloatVec(u32 vr);
-
-    /// Load VR and convert it to a double vector with 2 elements
-    llvm::Value * GetVrAsDoubleVec(u32 vr);
-
-    /// Set VR to the specified value
-    void SetVr(u32 vr, llvm::Value * val_x128);
-
-    /// Check condition for branch instructions
-    llvm::Value * CheckBranchCondition(u32 bo, u32 bi);
-
-    /// Create IR for a branch instruction
-    void CreateBranch(llvm::Value * cmp_i1, llvm::Value * target_i64, bool lk);
-
-    /// Read from memory
-    llvm::Value * ReadMemory(llvm::Value * addr_i64, u32 bits, u32 alignment = 0, bool bswap = true, bool could_be_mmio = true);
-
-    /// Write to memory
-    void WriteMemory(llvm::Value * addr_i64, llvm::Value * val_ix, u32 alignment = 0, bool bswap = true, bool could_be_mmio = true);
-
-    /// Call an interpreter function
-    template<class Func, class... Args>
-    llvm::Value * InterpreterCall(const char * name, Func function, Args... args);
-
-    /// Convert a C++ type to an LLVM type
-    template<class T>
-    llvm::Type * CppToLlvmType();
-
-    /// Call a function
-    template<class ReturnType, class Func, class... Args>
-    llvm::Value * Call(const char * name, Func function, Args... args);
-
-    /// Test an instruction against the interpreter
-    template <class PPULLVMRecompilerFn, class PPUInterpreterFn, class... Args>
-    void VerifyInstructionAgainstInterpreter(const char * name, PPULLVMRecompilerFn recomp_fn, PPUInterpreterFn interp_fn, PPUState & input_state, Args... args);
-
-    /// Excute a test
-    void RunTest(const char * name, std::function<void()> test_case, std::function<void()> input, std::function<bool(std::string & msg)> check_result);
-
-    /// A mask used in rotate instructions
-    static u64 s_rotate_mask[64][64];
-
-    /// A flag indicating whether s_rotate_mask has been initialised or not
-    static bool s_rotate_mask_inited;
-
-    /// Initialse s_rotate_mask
-    static void InitRotateMask();
-};
-
-/// PPU emulator that uses LLVM to convert PPU instructions to host CPU instructions
-class PPULLVMEmulator : public CPUDecoder {
-public:
-    PPULLVMEmulator(PPUThread & ppu);
-    PPULLVMEmulator() = delete;
-
-    PPULLVMEmulator(const PPULLVMEmulator & other) = delete;
-    PPULLVMEmulator(PPULLVMEmulator && other) = delete;
-
-    virtual ~PPULLVMEmulator();
-
-    PPULLVMEmulator & operator = (const PPULLVMEmulator & other) = delete;
-    PPULLVMEmulator & operator = (PPULLVMEmulator && other) = delete;
-
-    u8 DecodeMemory(const u32 address) override;
-
-private:
-    struct ExecutableInfo {
-        /// Pointer to the executable
-        PPULLVMRecompiler::Executable executable;
-
-        /// The revision of the executable
-        u32 revision;
-
-        /// Number of times the executable was hit
-        u32 num_hits;
+            /// The type of the block
+            BranchType type;
+        };
     };
 
-    /// PPU processor context
-    PPUThread & m_ppu;
+    /// An execution trace.
+    struct ExecutionTrace {
+        /// The function in which this trace was found
+        u32 function_address;
 
-    /// PPU Interpreter
-    PPUInterpreter * m_interpreter;
+        /// Execution trace type
+        enum {
+            Linear,
+            Loop,
+        } type;
 
-    /// PPU instruction Decoder
-    PPUDecoder m_decoder;
+        /// Sequence of blocks enountered in this trace
+        std::vector<BlockId> blocks;
+    };
 
-    /// Set to true if the last executed instruction was a branch
-    bool m_last_instr_was_branch;
+    /// A fragment of PPU code. A list of (block, list of next blocks) pairs.
+    typedef std::vector<std::pair<BlockId, std::vector<BlockId>>> CodeFragment;
 
-    /// The time at which the m_address_to_executable cache was last cleared
-    std::chrono::high_resolution_clock::time_point m_last_cache_clear_time;
+    /// Pointer to a function built by compiling a fragment of PPU code
+    typedef u64(*CompiledCodeFragment)(PPUThread * ppu_state, PPUInterpreter * interpreter);
 
-    /// The revision of the recompiler to which this thread is synced
-    u32 m_recompiler_revision;
+    struct PPUState;
 
-    /// Address to executable map. Key is address.
-    std::unordered_map<u32, ExecutableInfo> m_address_to_executable;
+    /// PPU compiler that uses LLVM for code generation and optimization
+    class Compiler : protected PPUOpcodes, protected PPCDecoder {
+    public:
+        struct Stats {
+            /// Time spent building the LLVM IR
+            std::chrono::nanoseconds ir_build_time;
 
-    /// Sections that have not been compiled yet. Key is starting address of the section.
-    std::unordered_map<u32, u64> m_uncompiled;
+            /// Time spent optimizing
+            std::chrono::nanoseconds optimization_time;
 
-    /// Number of instances of this class
-    static u32 s_num_instances;
+            /// Time spent translating LLVM IR to machine code
+            std::chrono::nanoseconds translation_time;
 
-    /// Mutex used prevent multiple instances of the recompiler from being created
-    static std::mutex s_recompiler_mutex;
+            /// Total time
+            std::chrono::nanoseconds total_time;
 
-    /// PPU to LLVM recompiler
-    static PPULLVMRecompiler * s_recompiler;
-};
+            /// Contains the number of times interpreter fallback was used
+            std::map<std::string, u64> interpreter_fallback_stats;
+        };
+
+        Compiler();
+
+        Compiler(const Compiler & other) = delete;
+        Compiler(Compiler && other) = delete;
+
+        virtual ~Compiler();
+
+        Compiler & operator = (const Compiler & other) = delete;
+        Compiler & operator = (Compiler && other) = delete;
+
+        /// Compile a code fragment
+        CompiledCodeFragment Compile(const std::string & name, const CodeFragment & code_fragment);
+
+        /// Free a compiled code fragment
+        void FreeCompiledCodeFragment(CompiledCodeFragment compiled_code_fragment);
+
+        /// Retrieve compiler stats
+        Stats GetStats();
+
+        /// Execute all tests
+        void RunAllTests(PPUThread * ppu_state, PPUInterpreter * interpreter);
+
+    protected:
+        void Decode(const u32 code) override;
+
+        void NULL_OP() override;
+        void NOP() override;
+
+        void TDI(u32 to, u32 ra, s32 simm16) override;
+        void TWI(u32 to, u32 ra, s32 simm16) override;
+
+        void MFVSCR(u32 vd) override;
+        void MTVSCR(u32 vb) override;
+        void VADDCUW(u32 vd, u32 va, u32 vb) override;
+        void VADDFP(u32 vd, u32 va, u32 vb) override;
+        void VADDSBS(u32 vd, u32 va, u32 vb) override;
+        void VADDSHS(u32 vd, u32 va, u32 vb) override;
+        void VADDSWS(u32 vd, u32 va, u32 vb) override;
+        void VADDUBM(u32 vd, u32 va, u32 vb) override;
+        void VADDUBS(u32 vd, u32 va, u32 vb) override;
+        void VADDUHM(u32 vd, u32 va, u32 vb) override;
+        void VADDUHS(u32 vd, u32 va, u32 vb) override;
+        void VADDUWM(u32 vd, u32 va, u32 vb) override;
+        void VADDUWS(u32 vd, u32 va, u32 vb) override;
+        void VAND(u32 vd, u32 va, u32 vb) override;
+        void VANDC(u32 vd, u32 va, u32 vb) override;
+        void VAVGSB(u32 vd, u32 va, u32 vb) override;
+        void VAVGSH(u32 vd, u32 va, u32 vb) override;
+        void VAVGSW(u32 vd, u32 va, u32 vb) override;
+        void VAVGUB(u32 vd, u32 va, u32 vb) override;
+        void VAVGUH(u32 vd, u32 va, u32 vb) override;
+        void VAVGUW(u32 vd, u32 va, u32 vb) override;
+        void VCFSX(u32 vd, u32 uimm5, u32 vb) override;
+        void VCFUX(u32 vd, u32 uimm5, u32 vb) override;
+        void VCMPBFP(u32 vd, u32 va, u32 vb) override;
+        void VCMPBFP_(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQFP(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQFP_(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQUB(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQUB_(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQUH(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQUH_(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQUW(u32 vd, u32 va, u32 vb) override;
+        void VCMPEQUW_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGEFP(u32 vd, u32 va, u32 vb) override;
+        void VCMPGEFP_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTFP(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTFP_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTSB(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTSB_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTSH(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTSH_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTSW(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTSW_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTUB(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTUB_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTUH(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTUH_(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTUW(u32 vd, u32 va, u32 vb) override;
+        void VCMPGTUW_(u32 vd, u32 va, u32 vb) override;
+        void VCTSXS(u32 vd, u32 uimm5, u32 vb) override;
+        void VCTUXS(u32 vd, u32 uimm5, u32 vb) override;
+        void VEXPTEFP(u32 vd, u32 vb) override;
+        void VLOGEFP(u32 vd, u32 vb) override;
+        void VMADDFP(u32 vd, u32 va, u32 vc, u32 vb) override;
+        void VMAXFP(u32 vd, u32 va, u32 vb) override;
+        void VMAXSB(u32 vd, u32 va, u32 vb) override;
+        void VMAXSH(u32 vd, u32 va, u32 vb) override;
+        void VMAXSW(u32 vd, u32 va, u32 vb) override;
+        void VMAXUB(u32 vd, u32 va, u32 vb) override;
+        void VMAXUH(u32 vd, u32 va, u32 vb) override;
+        void VMAXUW(u32 vd, u32 va, u32 vb) override;
+        void VMHADDSHS(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMHRADDSHS(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMINFP(u32 vd, u32 va, u32 vb) override;
+        void VMINSB(u32 vd, u32 va, u32 vb) override;
+        void VMINSH(u32 vd, u32 va, u32 vb) override;
+        void VMINSW(u32 vd, u32 va, u32 vb) override;
+        void VMINUB(u32 vd, u32 va, u32 vb) override;
+        void VMINUH(u32 vd, u32 va, u32 vb) override;
+        void VMINUW(u32 vd, u32 va, u32 vb) override;
+        void VMLADDUHM(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMRGHB(u32 vd, u32 va, u32 vb) override;
+        void VMRGHH(u32 vd, u32 va, u32 vb) override;
+        void VMRGHW(u32 vd, u32 va, u32 vb) override;
+        void VMRGLB(u32 vd, u32 va, u32 vb) override;
+        void VMRGLH(u32 vd, u32 va, u32 vb) override;
+        void VMRGLW(u32 vd, u32 va, u32 vb) override;
+        void VMSUMMBM(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMSUMSHM(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMSUMSHS(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMSUMUBM(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMSUMUHM(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMSUMUHS(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VMULESB(u32 vd, u32 va, u32 vb) override;
+        void VMULESH(u32 vd, u32 va, u32 vb) override;
+        void VMULEUB(u32 vd, u32 va, u32 vb) override;
+        void VMULEUH(u32 vd, u32 va, u32 vb) override;
+        void VMULOSB(u32 vd, u32 va, u32 vb) override;
+        void VMULOSH(u32 vd, u32 va, u32 vb) override;
+        void VMULOUB(u32 vd, u32 va, u32 vb) override;
+        void VMULOUH(u32 vd, u32 va, u32 vb) override;
+        void VNMSUBFP(u32 vd, u32 va, u32 vc, u32 vb) override;
+        void VNOR(u32 vd, u32 va, u32 vb) override;
+        void VOR(u32 vd, u32 va, u32 vb) override;
+        void VPERM(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VPKPX(u32 vd, u32 va, u32 vb) override;
+        void VPKSHSS(u32 vd, u32 va, u32 vb) override;
+        void VPKSHUS(u32 vd, u32 va, u32 vb) override;
+        void VPKSWSS(u32 vd, u32 va, u32 vb) override;
+        void VPKSWUS(u32 vd, u32 va, u32 vb) override;
+        void VPKUHUM(u32 vd, u32 va, u32 vb) override;
+        void VPKUHUS(u32 vd, u32 va, u32 vb) override;
+        void VPKUWUM(u32 vd, u32 va, u32 vb) override;
+        void VPKUWUS(u32 vd, u32 va, u32 vb) override;
+        void VREFP(u32 vd, u32 vb) override;
+        void VRFIM(u32 vd, u32 vb) override;
+        void VRFIN(u32 vd, u32 vb) override;
+        void VRFIP(u32 vd, u32 vb) override;
+        void VRFIZ(u32 vd, u32 vb) override;
+        void VRLB(u32 vd, u32 va, u32 vb) override;
+        void VRLH(u32 vd, u32 va, u32 vb) override;
+        void VRLW(u32 vd, u32 va, u32 vb) override;
+        void VRSQRTEFP(u32 vd, u32 vb) override;
+        void VSEL(u32 vd, u32 va, u32 vb, u32 vc) override;
+        void VSL(u32 vd, u32 va, u32 vb) override;
+        void VSLB(u32 vd, u32 va, u32 vb) override;
+        void VSLDOI(u32 vd, u32 va, u32 vb, u32 sh) override;
+        void VSLH(u32 vd, u32 va, u32 vb) override;
+        void VSLO(u32 vd, u32 va, u32 vb) override;
+        void VSLW(u32 vd, u32 va, u32 vb) override;
+        void VSPLTB(u32 vd, u32 uimm5, u32 vb) override;
+        void VSPLTH(u32 vd, u32 uimm5, u32 vb) override;
+        void VSPLTISB(u32 vd, s32 simm5) override;
+        void VSPLTISH(u32 vd, s32 simm5) override;
+        void VSPLTISW(u32 vd, s32 simm5) override;
+        void VSPLTW(u32 vd, u32 uimm5, u32 vb) override;
+        void VSR(u32 vd, u32 va, u32 vb) override;
+        void VSRAB(u32 vd, u32 va, u32 vb) override;
+        void VSRAH(u32 vd, u32 va, u32 vb) override;
+        void VSRAW(u32 vd, u32 va, u32 vb) override;
+        void VSRB(u32 vd, u32 va, u32 vb) override;
+        void VSRH(u32 vd, u32 va, u32 vb) override;
+        void VSRO(u32 vd, u32 va, u32 vb) override;
+        void VSRW(u32 vd, u32 va, u32 vb) override;
+        void VSUBCUW(u32 vd, u32 va, u32 vb) override;
+        void VSUBFP(u32 vd, u32 va, u32 vb) override;
+        void VSUBSBS(u32 vd, u32 va, u32 vb) override;
+        void VSUBSHS(u32 vd, u32 va, u32 vb) override;
+        void VSUBSWS(u32 vd, u32 va, u32 vb) override;
+        void VSUBUBM(u32 vd, u32 va, u32 vb) override;
+        void VSUBUBS(u32 vd, u32 va, u32 vb) override;
+        void VSUBUHM(u32 vd, u32 va, u32 vb) override;
+        void VSUBUHS(u32 vd, u32 va, u32 vb) override;
+        void VSUBUWM(u32 vd, u32 va, u32 vb) override;
+        void VSUBUWS(u32 vd, u32 va, u32 vb) override;
+        void VSUMSWS(u32 vd, u32 va, u32 vb) override;
+        void VSUM2SWS(u32 vd, u32 va, u32 vb) override;
+        void VSUM4SBS(u32 vd, u32 va, u32 vb) override;
+        void VSUM4SHS(u32 vd, u32 va, u32 vb) override;
+        void VSUM4UBS(u32 vd, u32 va, u32 vb) override;
+        void VUPKHPX(u32 vd, u32 vb) override;
+        void VUPKHSB(u32 vd, u32 vb) override;
+        void VUPKHSH(u32 vd, u32 vb) override;
+        void VUPKLPX(u32 vd, u32 vb) override;
+        void VUPKLSB(u32 vd, u32 vb) override;
+        void VUPKLSH(u32 vd, u32 vb) override;
+        void VXOR(u32 vd, u32 va, u32 vb) override;
+        void MULLI(u32 rd, u32 ra, s32 simm16) override;
+        void SUBFIC(u32 rd, u32 ra, s32 simm16) override;
+        void CMPLI(u32 bf, u32 l, u32 ra, u32 uimm16) override;
+        void CMPI(u32 bf, u32 l, u32 ra, s32 simm16) override;
+        void ADDIC(u32 rd, u32 ra, s32 simm16) override;
+        void ADDIC_(u32 rd, u32 ra, s32 simm16) override;
+        void ADDI(u32 rd, u32 ra, s32 simm16) override;
+        void ADDIS(u32 rd, u32 ra, s32 simm16) override;
+        void BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) override;
+        void SC(u32 sc_code) override;
+        void B(s32 ll, u32 aa, u32 lk) override;
+        void MCRF(u32 crfd, u32 crfs) override;
+        void BCLR(u32 bo, u32 bi, u32 bh, u32 lk) override;
+        void CRNOR(u32 bt, u32 ba, u32 bb) override;
+        void CRANDC(u32 bt, u32 ba, u32 bb) override;
+        void ISYNC() override;
+        void CRXOR(u32 bt, u32 ba, u32 bb) override;
+        void CRNAND(u32 bt, u32 ba, u32 bb) override;
+        void CRAND(u32 bt, u32 ba, u32 bb) override;
+        void CREQV(u32 bt, u32 ba, u32 bb) override;
+        void CRORC(u32 bt, u32 ba, u32 bb) override;
+        void CROR(u32 bt, u32 ba, u32 bb) override;
+        void BCCTR(u32 bo, u32 bi, u32 bh, u32 lk) override;
+        void RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) override;
+        void RLWINM(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc) override;
+        void RLWNM(u32 ra, u32 rs, u32 rb, u32 MB, u32 ME, bool rc) override;
+        void ORI(u32 rs, u32 ra, u32 uimm16) override;
+        void ORIS(u32 rs, u32 ra, u32 uimm16) override;
+        void XORI(u32 ra, u32 rs, u32 uimm16) override;
+        void XORIS(u32 ra, u32 rs, u32 uimm16) override;
+        void ANDI_(u32 ra, u32 rs, u32 uimm16) override;
+        void ANDIS_(u32 ra, u32 rs, u32 uimm16) override;
+        void RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) override;
+        void RLDICR(u32 ra, u32 rs, u32 sh, u32 me, bool rc) override;
+        void RLDIC(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) override;
+        void RLDIMI(u32 ra, u32 rs, u32 sh, u32 mb, bool rc) override;
+        void RLDC_LR(u32 ra, u32 rs, u32 rb, u32 m_eb, bool is_r, bool rc) override;
+        void CMP(u32 crfd, u32 l, u32 ra, u32 rb) override;
+        void TW(u32 to, u32 ra, u32 rb) override;
+        void LVSL(u32 vd, u32 ra, u32 rb) override;
+        void LVEBX(u32 vd, u32 ra, u32 rb) override;
+        void SUBFC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void MULHDU(u32 rd, u32 ra, u32 rb, bool rc) override;
+        void ADDC(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void MULHWU(u32 rd, u32 ra, u32 rb, bool rc) override;
+        void MFOCRF(u32 a, u32 rd, u32 crm) override;
+        void LWARX(u32 rd, u32 ra, u32 rb) override;
+        void LDX(u32 ra, u32 rs, u32 rb) override;
+        void LWZX(u32 rd, u32 ra, u32 rb) override;
+        void SLW(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void CNTLZW(u32 ra, u32 rs, bool rc) override;
+        void SLD(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void AND(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void CMPL(u32 bf, u32 l, u32 ra, u32 rb) override;
+        void LVSR(u32 vd, u32 ra, u32 rb) override;
+        void LVEHX(u32 vd, u32 ra, u32 rb) override;
+        void SUBF(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void LDUX(u32 rd, u32 ra, u32 rb) override;
+        void DCBST(u32 ra, u32 rb) override;
+        void LWZUX(u32 rd, u32 ra, u32 rb) override;
+        void CNTLZD(u32 ra, u32 rs, bool rc) override;
+        void ANDC(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void TD(u32 to, u32 ra, u32 rb) override;
+        void LVEWX(u32 vd, u32 ra, u32 rb) override;
+        void MULHD(u32 rd, u32 ra, u32 rb, bool rc) override;
+        void MULHW(u32 rd, u32 ra, u32 rb, bool rc) override;
+        void LDARX(u32 rd, u32 ra, u32 rb) override;
+        void DCBF(u32 ra, u32 rb) override;
+        void LBZX(u32 rd, u32 ra, u32 rb) override;
+        void LVX(u32 vd, u32 ra, u32 rb) override;
+        void NEG(u32 rd, u32 ra, u32 oe, bool rc) override;
+        void LBZUX(u32 rd, u32 ra, u32 rb) override;
+        void NOR(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void STVEBX(u32 vs, u32 ra, u32 rb) override;
+        void SUBFE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void ADDE(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void MTOCRF(u32 l, u32 crm, u32 rs) override;
+        void STDX(u32 rs, u32 ra, u32 rb) override;
+        void STWCX_(u32 rs, u32 ra, u32 rb) override;
+        void STWX(u32 rs, u32 ra, u32 rb) override;
+        void STVEHX(u32 vs, u32 ra, u32 rb) override;
+        void STDUX(u32 rs, u32 ra, u32 rb) override;
+        void STWUX(u32 rs, u32 ra, u32 rb) override;
+        void STVEWX(u32 vs, u32 ra, u32 rb) override;
+        void SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) override;
+        void ADDZE(u32 rd, u32 ra, u32 oe, bool rc) override;
+        void STDCX_(u32 rs, u32 ra, u32 rb) override;
+        void STBX(u32 rs, u32 ra, u32 rb) override;
+        void STVX(u32 vs, u32 ra, u32 rb) override;
+        void MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void SUBFME(u32 rd, u32 ra, u32 oe, bool rc) override;
+        void ADDME(u32 rd, u32 ra, u32 oe, bool rc) override;
+        void MULLW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void DCBTST(u32 ra, u32 rb, u32 th) override;
+        void STBUX(u32 rs, u32 ra, u32 rb) override;
+        void ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void DCBT(u32 ra, u32 rb, u32 th) override;
+        void LHZX(u32 rd, u32 ra, u32 rb) override;
+        void EQV(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void ECIWX(u32 rd, u32 ra, u32 rb) override;
+        void LHZUX(u32 rd, u32 ra, u32 rb) override;
+        void XOR(u32 rs, u32 ra, u32 rb, bool rc) override;
+        void MFSPR(u32 rd, u32 spr) override;
+        void LWAX(u32 rd, u32 ra, u32 rb) override;
+        void DST(u32 ra, u32 rb, u32 strm, u32 t) override;
+        void LHAX(u32 rd, u32 ra, u32 rb) override;
+        void LVXL(u32 vd, u32 ra, u32 rb) override;
+        void MFTB(u32 rd, u32 spr) override;
+        void LWAUX(u32 rd, u32 ra, u32 rb) override;
+        void DSTST(u32 ra, u32 rb, u32 strm, u32 t) override;
+        void LHAUX(u32 rd, u32 ra, u32 rb) override;
+        void STHX(u32 rs, u32 ra, u32 rb) override;
+        void ORC(u32 rs, u32 ra, u32 rb, bool rc) override;
+        void ECOWX(u32 rs, u32 ra, u32 rb) override;
+        void STHUX(u32 rs, u32 ra, u32 rb) override;
+        void OR(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void DIVDU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void MTSPR(u32 spr, u32 rs) override;
+        //DCBI
+        void NAND(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void STVXL(u32 vs, u32 ra, u32 rb) override;
+        void DIVD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) override;
+        void LVLX(u32 vd, u32 ra, u32 rb) override;
+        void LDBRX(u32 rd, u32 ra, u32 rb) override;
+        void LSWX(u32 rd, u32 ra, u32 rb) override;
+        void LWBRX(u32 rd, u32 ra, u32 rb) override;
+        void LFSX(u32 frd, u32 ra, u32 rb) override;
+        void SRW(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void SRD(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void LVRX(u32 vd, u32 ra, u32 rb) override;
+        void LSWI(u32 rd, u32 ra, u32 nb) override;
+        void LFSUX(u32 frd, u32 ra, u32 rb) override;
+        void SYNC(u32 l) override;
+        void LFDX(u32 frd, u32 ra, u32 rb) override;
+        void LFDUX(u32 frd, u32 ra, u32 rb) override;
+        void STVLX(u32 vs, u32 ra, u32 rb) override;
+        void STSWX(u32 rs, u32 ra, u32 rb) override;
+        void STWBRX(u32 rs, u32 ra, u32 rb) override;
+        void STFSX(u32 frs, u32 ra, u32 rb) override;
+        void STVRX(u32 vs, u32 ra, u32 rb) override;
+        void STFSUX(u32 frs, u32 ra, u32 rb) override;
+        void STSWI(u32 rd, u32 ra, u32 nb) override;
+        void STFDX(u32 frs, u32 ra, u32 rb) override;
+        void STFDUX(u32 frs, u32 ra, u32 rb) override;
+        void LVLXL(u32 vd, u32 ra, u32 rb) override;
+        void LHBRX(u32 rd, u32 ra, u32 rb) override;
+        void SRAW(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void SRAD(u32 ra, u32 rs, u32 rb, bool rc) override;
+        void LVRXL(u32 vd, u32 ra, u32 rb) override;
+        void DSS(u32 strm, u32 a) override;
+        void SRAWI(u32 ra, u32 rs, u32 sh, bool rc) override;
+        void SRADI1(u32 ra, u32 rs, u32 sh, bool rc) override;
+        void SRADI2(u32 ra, u32 rs, u32 sh, bool rc) override;
+        void EIEIO() override;
+        void STVLXL(u32 vs, u32 ra, u32 rb) override;
+        void STHBRX(u32 rs, u32 ra, u32 rb) override;
+        void EXTSH(u32 ra, u32 rs, bool rc) override;
+        void STVRXL(u32 sd, u32 ra, u32 rb) override;
+        void EXTSB(u32 ra, u32 rs, bool rc) override;
+        void STFIWX(u32 frs, u32 ra, u32 rb) override;
+        void EXTSW(u32 ra, u32 rs, bool rc) override;
+        void ICBI(u32 ra, u32 rb) override;
+        void DCBZ(u32 ra, u32 rb) override;
+        void LWZ(u32 rd, u32 ra, s32 d) override;
+        void LWZU(u32 rd, u32 ra, s32 d) override;
+        void LBZ(u32 rd, u32 ra, s32 d) override;
+        void LBZU(u32 rd, u32 ra, s32 d) override;
+        void STW(u32 rs, u32 ra, s32 d) override;
+        void STWU(u32 rs, u32 ra, s32 d) override;
+        void STB(u32 rs, u32 ra, s32 d) override;
+        void STBU(u32 rs, u32 ra, s32 d) override;
+        void LHZ(u32 rd, u32 ra, s32 d) override;
+        void LHZU(u32 rd, u32 ra, s32 d) override;
+        void LHA(u32 rs, u32 ra, s32 d) override;
+        void LHAU(u32 rs, u32 ra, s32 d) override;
+        void STH(u32 rs, u32 ra, s32 d) override;
+        void STHU(u32 rs, u32 ra, s32 d) override;
+        void LMW(u32 rd, u32 ra, s32 d) override;
+        void STMW(u32 rs, u32 ra, s32 d) override;
+        void LFS(u32 frd, u32 ra, s32 d) override;
+        void LFSU(u32 frd, u32 ra, s32 d) override;
+        void LFD(u32 frd, u32 ra, s32 d) override;
+        void LFDU(u32 frd, u32 ra, s32 d) override;
+        void STFS(u32 frs, u32 ra, s32 d) override;
+        void STFSU(u32 frs, u32 ra, s32 d) override;
+        void STFD(u32 frs, u32 ra, s32 d) override;
+        void STFDU(u32 frs, u32 ra, s32 d) override;
+        void LD(u32 rd, u32 ra, s32 ds) override;
+        void LDU(u32 rd, u32 ra, s32 ds) override;
+        void LWA(u32 rd, u32 ra, s32 ds) override;
+        void FDIVS(u32 frd, u32 fra, u32 frb, bool rc) override;
+        void FSUBS(u32 frd, u32 fra, u32 frb, bool rc) override;
+        void FADDS(u32 frd, u32 fra, u32 frb, bool rc) override;
+        void FSQRTS(u32 frd, u32 frb, bool rc) override;
+        void FRES(u32 frd, u32 frb, bool rc) override;
+        void FMULS(u32 frd, u32 fra, u32 frc, bool rc) override;
+        void FMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FNMSUBS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FNMADDS(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void STD(u32 rs, u32 ra, s32 ds) override;
+        void STDU(u32 rs, u32 ra, s32 ds) override;
+        void MTFSB1(u32 bt, bool rc) override;
+        void MCRFS(u32 bf, u32 bfa) override;
+        void MTFSB0(u32 bt, bool rc) override;
+        void MTFSFI(u32 crfd, u32 i, bool rc) override;
+        void MFFS(u32 frd, bool rc) override;
+        void MTFSF(u32 flm, u32 frb, bool rc) override;
+
+        void FCMPU(u32 bf, u32 fra, u32 frb) override;
+        void FRSP(u32 frd, u32 frb, bool rc) override;
+        void FCTIW(u32 frd, u32 frb, bool rc) override;
+        void FCTIWZ(u32 frd, u32 frb, bool rc) override;
+        void FDIV(u32 frd, u32 fra, u32 frb, bool rc) override;
+        void FSUB(u32 frd, u32 fra, u32 frb, bool rc) override;
+        void FADD(u32 frd, u32 fra, u32 frb, bool rc) override;
+        void FSQRT(u32 frd, u32 frb, bool rc) override;
+        void FSEL(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FMUL(u32 frd, u32 fra, u32 frc, bool rc) override;
+        void FRSQRTE(u32 frd, u32 frb, bool rc) override;
+        void FMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FNMSUB(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FNMADD(u32 frd, u32 fra, u32 frc, u32 frb, bool rc) override;
+        void FCMPO(u32 crfd, u32 fra, u32 frb) override;
+        void FNEG(u32 frd, u32 frb, bool rc) override;
+        void FMR(u32 frd, u32 frb, bool rc) override;
+        void FNABS(u32 frd, u32 frb, bool rc) override;
+        void FABS(u32 frd, u32 frb, bool rc) override;
+        void FCTID(u32 frd, u32 frb, bool rc) override;
+        void FCTIDZ(u32 frd, u32 frb, bool rc) override;
+        void FCFID(u32 frd, u32 frb, bool rc) override;
+
+        void UNK(const u32 code, const u32 opcode, const u32 gcode) override;
+
+    private:
+        /// Map from compiled code fragment to the LLVM function for the code fragment
+        std::map<CompiledCodeFragment, llvm::Function *> m_compiled;
+
+        /// LLVM context
+        llvm::LLVMContext * m_llvm_context;
+
+        /// LLVM IR builder
+        llvm::IRBuilder<> * m_ir_builder;
+
+        /// Module to which all generated code is output to
+        llvm::Module * m_module;
+
+        /// JIT execution engine
+        llvm::ExecutionEngine * m_execution_engine;
+
+        /// Function pass manager
+        llvm::FunctionPassManager * m_fpm;
+
+        /// A flag used to detect branch instructions.
+        /// This is set to false at the start of compilation of a block.
+        /// When a branch instruction is encountered, this is set to true by the decode function.
+        bool m_hit_branch_instruction;
+
+        /// The function being compiled
+        llvm::Function * m_current_function;
+
+        /// The list of next blocks for the current block
+        const std::vector<BlockId> * m_current_block_next_blocks;
+
+        /// Address of the current instruction
+        u32 m_current_instruction_address;
+
+        /// Compiler stats
+        Stats m_stats;
+
+        /// Get the name of the basic block for the specified address
+        std::string GetBasicBlockNameFromAddress(u32 address);
+
+        /// Get the basic block in for the specified address.
+        llvm::BasicBlock * GetBasicBlockFromAddress(u32 address, llvm::Function * function, bool create_if_not_exist = false);
+
+        /// Get PPU state pointer argument
+        llvm::Value * GetPPUStateArg();
+
+        /// Get interpreter pointer argument
+        llvm::Value * GetInterpreterArg();
+
+        /// Get tracer pointer argument
+        llvm::Value * GetTracerArg();
+
+        /// Get a bit
+        llvm::Value * GetBit(llvm::Value * val, u32 n);
+
+        /// Clear a bit
+        llvm::Value * ClrBit(llvm::Value * val, u32 n);
+
+        /// Set a bit
+        llvm::Value * SetBit(llvm::Value * val, u32 n, llvm::Value * bit, bool doClear = true);
+
+        /// Get a nibble
+        llvm::Value * GetNibble(llvm::Value * val, u32 n);
+
+        /// Clear a nibble
+        llvm::Value * ClrNibble(llvm::Value * val, u32 n);
+
+        /// Set a nibble
+        llvm::Value * SetNibble(llvm::Value * val, u32 n, llvm::Value * nibble, bool doClear = true);
+
+        /// Set a nibble
+        llvm::Value * SetNibble(llvm::Value * val, u32 n, llvm::Value * b0, llvm::Value * b1, llvm::Value * b2, llvm::Value * b3, bool doClear = true);
+
+        /// Load PC
+        llvm::Value * GetPc();
+
+        /// Set PC
+        void SetPc(llvm::Value * val_ix);
+
+        /// Load GPR
+        llvm::Value * GetGpr(u32 r, u32 num_bits = 64);
+
+        /// Set GPR
+        void SetGpr(u32 r, llvm::Value * val_x64);
+
+        /// Load CR
+        llvm::Value * GetCr();
+
+        /// Load CR and get field CRn
+        llvm::Value * GetCrField(u32 n);
+
+        /// Set CR
+        void SetCr(llvm::Value * val_x32);
+
+        /// Set CR field
+        void SetCrField(u32 n, llvm::Value * field);
+
+        /// Set CR field
+        void SetCrField(u32 n, llvm::Value * b0, llvm::Value * b1, llvm::Value * b2, llvm::Value * b3);
+
+        /// Set CR field based on signed comparison
+        void SetCrFieldSignedCmp(u32 n, llvm::Value * a, llvm::Value * b);
+
+        /// Set CR field based on unsigned comparison
+        void SetCrFieldUnsignedCmp(u32 n, llvm::Value * a, llvm::Value * b);
+
+        /// Set CR6 based on the result of the vector compare instruction
+        void SetCr6AfterVectorCompare(u32 vr);
+
+        /// Get LR
+        llvm::Value * GetLr();
+
+        /// Set LR
+        void SetLr(llvm::Value * val_x64);
+
+        /// Get CTR
+        llvm::Value * GetCtr();
+
+        /// Set CTR
+        void SetCtr(llvm::Value * val_x64);
+
+        /// Load XER and convert it to an i64
+        llvm::Value * GetXer();
+
+        /// Load XER and return the CA bit
+        llvm::Value * GetXerCa();
+
+        /// Load XER and return the SO bit
+        llvm::Value * GetXerSo();
+
+        /// Set XER
+        void SetXer(llvm::Value * val_x64);
+
+        /// Set the CA bit of XER
+        void SetXerCa(llvm::Value * ca);
+
+        /// Set the SO bit of XER
+        void SetXerSo(llvm::Value * so);
+
+        /// Get USPRG0
+        llvm::Value * GetUsprg0();
+
+        /// Set USPRG0
+        void SetUsprg0(llvm::Value * val_x64);
+
+        /// Get FPR
+        llvm::Value * GetFpr(u32 r, u32 bits = 64, bool as_int = false);
+
+        /// Set FPR
+        void SetFpr(u32 r, llvm::Value * val);
+
+        /// Load VSCR
+        llvm::Value * GetVscr();
+
+        /// Set VSCR
+        void SetVscr(llvm::Value * val_x32);
+
+        /// Load VR
+        llvm::Value * GetVr(u32 vr);
+
+        /// Load VR and convert it to an integer vector
+        llvm::Value * GetVrAsIntVec(u32 vr, u32 vec_elt_num_bits);
+
+        /// Load VR and convert it to a float vector with 4 elements
+        llvm::Value * GetVrAsFloatVec(u32 vr);
+
+        /// Load VR and convert it to a double vector with 2 elements
+        llvm::Value * GetVrAsDoubleVec(u32 vr);
+
+        /// Set VR to the specified value
+        void SetVr(u32 vr, llvm::Value * val_x128);
+
+        /// Check condition for branch instructions
+        llvm::Value * CheckBranchCondition(u32 bo, u32 bi);
+
+        /// Create IR for a branch instruction
+        void CreateBranch(llvm::Value * cmp_i1, llvm::Value * target_i64, bool lk, bool target_is_lr = false);
+
+        /// Read from memory
+        llvm::Value * ReadMemory(llvm::Value * addr_i64, u32 bits, u32 alignment = 0, bool bswap = true, bool could_be_mmio = true);
+
+        /// Write to memory
+        void WriteMemory(llvm::Value * addr_i64, llvm::Value * val_ix, u32 alignment = 0, bool bswap = true, bool could_be_mmio = true);
+
+        /// Call an interpreter function
+        template<class Func, class... Args>
+        llvm::Value * InterpreterCall(const char * name, Func function, Args... args);
+
+        /// Convert a C++ type to an LLVM type
+        template<class T>
+        llvm::Type * CppToLlvmType();
+
+        /// Call a function
+        template<class ReturnType, class Func, class... Args>
+        llvm::Value * Call(const char * name, Func function, Args... args);
+
+        /// Tests if the instruction is a branch instruction or not
+        bool IsBranchInstruction(u32 instruction);
+
+        /// Test an instruction against the interpreter
+        template <class PPULLVMRecompilerFn, class PPUInterpreterFn, class... Args>
+        void VerifyInstructionAgainstInterpreter(const char * name, PPULLVMRecompilerFn recomp_fn, PPUInterpreterFn interp_fn, PPUState & input_state, Args... args);
+
+        /// Excute a test
+        void RunTest(const char * name, std::function<void()> test_case, std::function<void()> input, std::function<bool(std::string & msg)> check_result);
+
+        /// A mask used in rotate instructions
+        static u64 s_rotate_mask[64][64];
+
+        /// A flag indicating whether s_rotate_mask has been initialised or not
+        static bool s_rotate_mask_inited;
+
+        /// Initialse s_rotate_mask
+        static void InitRotateMask();
+    };
+
+    /// Analyses execution traces and finds hot paths
+    class Profiler {
+
+    };
+
+    class RecompilationEngine {
+    public:
+        virtual ~RecompilationEngine() = default;
+
+        /// Get the compiled code fragment for the specified address
+        CompiledCodeFragment GetCompiledCodeFragment(u32 address);
+
+        /// Release a compiled code fragment earlier obtained through GetCompiledCodeFragment
+        void ReleaseCompiledCodeFragment(CompiledCodeFragment compiled_code_fragment);
+
+        /// Get the current revision
+        u32 GetCurrentRevision();
+
+        /// Get a pointer to the instance of this class
+        static std::shared_ptr<RecompilationEngine> GetInstance();
+
+    private:
+        RecompilationEngine() = default;
+
+        RecompilationEngine(const RecompilationEngine & other) = delete;
+        RecompilationEngine(RecompilationEngine && other) = delete;
+
+        RecompilationEngine & operator = (const RecompilationEngine & other) = delete;
+        RecompilationEngine & operator = (RecompilationEngine && other) = delete;
+
+        /// Mutex used to prevent multiple creation
+        static std::mutex s_mutex;
+
+        /// The instance
+        static std::shared_ptr<RecompilationEngine> s_the_instance;
+    };
+
+    /// Finds interesting execution sequences
+    class Tracer {
+    public:
+        Tracer();
+
+        Tracer(const Tracer & other) = delete;
+        Tracer(Tracer && other) = delete;
+
+        virtual ~Tracer();
+
+        Tracer & operator = (const Tracer & other) = delete;
+        Tracer & operator = (Tracer && other) = delete;
+
+        /// Notify the tracer that a branch was encountered
+        void Trace(BranchType branch_type, u32 address);
+
+        /// Notify the tracer that the execution sequence is being terminated.
+        void Terminate();
+
+    private:
+        /// Current execution trace
+        std::vector<BlockId> m_trace;
+
+        /// Call stack
+        std::vector<u32> m_stack;
+    };
+
+    /// PPU execution engine
+    class ExecutionEngine : public CPUDecoder {
+    public:
+        ExecutionEngine(PPUThread & ppu);
+        ExecutionEngine() = delete;
+
+        ExecutionEngine(const ExecutionEngine & other) = delete;
+        ExecutionEngine(ExecutionEngine && other) = delete;
+
+        virtual ~ExecutionEngine();
+
+        ExecutionEngine & operator = (const ExecutionEngine & other) = delete;
+        ExecutionEngine & operator = (ExecutionEngine && other) = delete;
+
+        u8 DecodeMemory(const u32 address) override;
+
+    private:
+        /// PPU processor context
+        PPUThread & m_ppu;
+
+        /// PPU Interpreter
+        PPUInterpreter * m_interpreter;
+
+        /// PPU instruction Decoder
+        PPUDecoder m_decoder;
+
+        /// Execution tracer
+        Tracer m_tracer;
+
+        /// Set to true if the last executed instruction was a branch
+        BranchType m_last_branch_type;
+
+        /// The time at which the m_address_to_compiled_code_fragment cache was last cleared
+        std::chrono::high_resolution_clock::time_point m_last_cache_clear_time;
+
+        /// The revision of the recompiler to which this thread is synced
+        u32 m_recompiler_revision;
+
+        /// Address to compiled code fragmnet lookup. Key is address. Data is the pair (compiled code fragment, times hit).
+        std::unordered_map<u32, std::pair<CompiledCodeFragment, u32>> m_address_to_compiled_code_fragment;
+
+        /// Recompilation engine
+        std::shared_ptr<RecompilationEngine> m_recompilation_engine;
+    };
+
+    // Get the branch type from a branch instruction
+    BranchType GetBranchTypeFromInstruction(u32 instruction);
+}
 
 #endif // PPU_LLVM_RECOMPILER_H
diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters
index e164e1c531..8f1cc2407c 100644
--- a/rpcs3/emucore.vcxproj.filters
+++ b/rpcs3/emucore.vcxproj.filters
@@ -630,7 +630,7 @@
       <Filter>Emu\Cell</Filter>
     </ClCompile>
     <ClCompile Include="Emu\Cell\PPULLVMRecompilerTests.cpp">
-      <Filter>Source Files</Filter>
+      <Filter>Emu\Cell</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>