From 8ca33bcb94617c8caf64a7cd7a31b4ad0a5952a3 Mon Sep 17 00:00:00 2001
From: Nekotekina <nekotekina@gmail.com>
Date: Mon, 9 Apr 2018 17:45:37 +0300
Subject: [PATCH] SPU ASMJIT v2.0

Use X86Assembler and blocks
---
 Utilities/sysinfo.cpp                  |    6 +
 Utilities/sysinfo.h                    |    2 +
 rpcs3/Emu/CPU/CPUDisAsm.h              |    4 +-
 rpcs3/Emu/Cell/RawSPUThread.cpp        |    2 +-
 rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp | 2011 ++++++++++++------------
 rpcs3/Emu/Cell/SPUASMJITRecompiler.h   |   90 +-
 rpcs3/Emu/Cell/SPUAnalyser.cpp         |  101 +-
 rpcs3/Emu/Cell/SPUAnalyser.h           |   26 +-
 rpcs3/Emu/Cell/SPURecompiler.cpp       |  211 ++-
 rpcs3/Emu/Cell/SPURecompiler.h         |   31 +-
 rpcs3/Emu/Cell/SPUThread.cpp           |   35 +-
 rpcs3/Emu/Cell/SPUThread.h             |   31 +-
 12 files changed, 1363 insertions(+), 1187 deletions(-)

diff --git a/Utilities/sysinfo.cpp b/Utilities/sysinfo.cpp
index 00075a5ec7..921dc7c2f0 100644
--- a/Utilities/sysinfo.cpp
+++ b/Utilities/sysinfo.cpp
@@ -13,6 +13,12 @@ bool utils::has_ssse3()
 	return g_value;
 }
 
+bool utils::has_sse41()
+{
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x80000;
+	return g_value;
+}
+
 bool utils::has_avx()
 {
 	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x10000000 && (get_cpuid(1, 0)[2] & 0x0C000000) == 0x0C000000 && (get_xgetbv(0) & 0x6) == 0x6;
diff --git a/Utilities/sysinfo.h b/Utilities/sysinfo.h
index ad55ba724e..1fbdd9e5f9 100644
--- a/Utilities/sysinfo.h
+++ b/Utilities/sysinfo.h
@@ -29,6 +29,8 @@ namespace utils
 
 	bool has_ssse3();
 
+	bool has_sse41();
+
 	bool has_avx();
 
 	bool has_avx2();
diff --git a/rpcs3/Emu/CPU/CPUDisAsm.h b/rpcs3/Emu/CPU/CPUDisAsm.h
index 8991f55c84..f64d20d356 100644
--- a/rpcs3/Emu/CPU/CPUDisAsm.h
+++ b/rpcs3/Emu/CPU/CPUDisAsm.h
@@ -42,10 +42,10 @@ protected:
 public:
 	std::string last_opcode;
 	u32 dump_pc;
-	u8* offset;
+	const u8* offset;
 
 protected:
-	CPUDisAsm(CPUDisAsmMode mode) 
+	CPUDisAsm(CPUDisAsmMode mode)
 		: m_mode(mode)
 		, offset(0)
 	{
diff --git a/rpcs3/Emu/Cell/RawSPUThread.cpp b/rpcs3/Emu/Cell/RawSPUThread.cpp
index 448dc198b9..cffcdc7661 100644
--- a/rpcs3/Emu/Cell/RawSPUThread.cpp
+++ b/rpcs3/Emu/Cell/RawSPUThread.cpp
@@ -37,7 +37,7 @@ void RawSPUThread::on_init(const std::shared_ptr<void>& _this)
 }
 
 RawSPUThread::RawSPUThread(const std::string& name)
-	: SPUThread(name)
+	: SPUThread(name, 0, nullptr)
 {
 }
 
diff --git a/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp b/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
index ad673f95a2..81c70f11d0 100644
--- a/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
@@ -1,19 +1,17 @@
 #include "stdafx.h"
 #include "Emu/Memory/Memory.h"
 #include "Emu/System.h"
+#include "Emu/IdManager.h"
 
 #include "SPUDisAsm.h"
 #include "SPUThread.h"
 #include "SPUInterpreter.h"
-#include "SPUASMJITRecompiler.h"
 #include "Utilities/sysinfo.h"
 
 #include <cmath>
+#include <mutex>
 
-#define ASMJIT_STATIC
-#define ASMJIT_DEBUG
-
-#include "asmjit.h"
+#include "SPUASMJITRecompiler.h"
 
 #define SPU_OFF_128(x, ...) asmjit::x86::oword_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
 #define SPU_OFF_64(x, ...) asmjit::x86::qword_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
@@ -24,37 +22,51 @@
 extern const spu_decoder<spu_interpreter_fast> g_spu_interpreter_fast; // TODO: avoid
 const spu_decoder<spu_recompiler> s_spu_decoder;
 
-spu_recompiler::spu_recompiler()
-	: m_jit(std::make_shared<asmjit::JitRuntime>())
-{
-	LOG_SUCCESS(SPU, "SPU Recompiler (ASMJIT) created...");
+extern u64 get_timebased_time();
 
+std::unique_ptr<spu_recompiler_base> spu_recompiler_base::make_asmjit_recompiler(SPUThread& spu)
+{
+	return std::make_unique<spu_recompiler>(spu);
+}
+
+spu_runtime::spu_runtime()
+{
 	if (g_cfg.core.spu_debug)
 	{
 		fs::file log(Emu.GetCachePath() + "SPUJIT.log", fs::rewrite);
-		log.write(fmt::format("SPU JIT initialization...\n\nTitle: %s\nTitle ID: %s\n\n", Emu.GetTitle().c_str(), Emu.GetTitleID().c_str()));
+		log.write(fmt::format("SPU JIT Log...\n\nTitle: %s\nTitle ID: %s\n\n", Emu.GetTitle().c_str(), Emu.GetTitleID().c_str()));
 	}
+
+	LOG_SUCCESS(SPU, "SPU Recompiler Runtime (ASMJIT) initialized...");
+
+	// Initialize lookup table
+	for (auto& v : m_dispatcher)
+	{
+		v.raw() = &spu_recompiler_base::dispatch;
+	}
+
+	// Initialize "empty" block
+	m_map[std::vector<u32>()] = &spu_recompiler_base::dispatch;
 }
 
-void spu_recompiler::compile(spu_function_t& f)
+spu_recompiler::spu_recompiler(SPUThread& spu)
+	: spu_recompiler_base(spu)
+	, m_rt(std::make_shared<asmjit::JitRuntime>())
 {
-	std::lock_guard<std::mutex> lock(m_mutex);
+}
 
-	if (f.compiled)
+spu_function_t spu_recompiler::compile(const std::vector<u32>& func)
+{
+	// Initialize if necessary
+	if (!m_spurt)
 	{
-		// return if function already compiled
-		return;
-	}
-
-	if (f.addr >= 0x40000 || f.addr % 4 || f.size == 0 || f.size > 0x40000 - f.addr || f.size % 4)
-	{
-		fmt::throw_exception("Invalid SPU function (addr=0x%05x, size=0x%x)" HERE, f.addr, f.size);
+		m_spurt = fxm::get_always<spu_runtime>();
 	}
 
 	using namespace asmjit;
 
 	SPUDisAsm dis_asm(CPUDisAsm_InterpreterMode);
-	dis_asm.offset = reinterpret_cast<u8*>(f.data.data()) - f.addr;
+	dis_asm.offset = reinterpret_cast<const u8*>(func.data() + 1) - func[0];
 
 	StringLogger logger;
 	logger.addOptions(Logger::kOptionBinaryForm);
@@ -63,121 +75,505 @@ void spu_recompiler::compile(spu_function_t& f)
 
 	if (g_cfg.core.spu_debug)
 	{
-		fmt::append(log, "========== SPU FUNCTION 0x%05x - 0x%05x ==========\n\n", f.addr, f.addr + f.size);
+		fmt::append(log, "========== SPU BLOCK 0x%05x (size %u) ==========\n\n", func[0], func.size() - 1);
 	}
 
-	this->m_func = &f;
-
 	asmjit::CodeHolder code;
-	code.init(m_jit->getCodeInfo());
-	this->codeHolder = &code;
+	code.init(m_rt->getCodeInfo());
 
-	X86Compiler compiler(&code);
+	X86Assembler compiler(&code);
 	this->c = &compiler;
 
 	if (g_cfg.core.spu_debug)
 	{
 		// Set logger
-		codeHolder->setLogger(&logger);
+		code.setLogger(&logger);
 	}
 
-	compiler.addFunc(FuncSignature2<u32, void*, void*>(asmjit::CallConv::kIdHost));
-
 	// Initialize variables
-	X86Gp cpu_var = compiler.newIntPtr("cpu");
-	compiler.setArg(0, cpu_var);
-	compiler.alloc(cpu_var, asmjit::x86::rbp); // ASMJIT bug workaround
-	this->cpu = &cpu_var;
+#ifdef _WIN32
+	this->cpu = &x86::rcx;
+	this->ls = &x86::rdx;
+#else
+	this->cpu = &x86::rdi;
+	this->ls = &x86::rsi;
+#endif
 
-	X86Gp ls_var = compiler.newIntPtr("ls");
-	compiler.setArg(1, ls_var);
-	compiler.alloc(ls_var, asmjit::x86::rbx); // ASMJIT bug workaround
-	this->ls = &ls_var;
+	this->addr = &x86::eax;
+#ifdef _WIN32
+	this->qw0 = &x86::r8;
+	this->qw1 = &x86::r9;
+#else
+	this->qw0 = &x86::rdx;
+	this->qw1 = &x86::rcx;
+#endif
 
-	X86Gp addr_var = compiler.newUInt32("addr");
-	this->addr = &addr_var;
-	X86Gp qw0_var = compiler.newUInt64("qw0");
-	this->qw0 = &qw0_var;
-	X86Gp qw1_var = compiler.newUInt64("qw1");
-	this->qw1 = &qw1_var;
-	X86Gp qw2_var = compiler.newUInt64("qw2");
-	this->qw2 = &qw2_var;
-	X86Gp qw3_var = compiler.newUInt64("qw3");
-	this->qw3 = &qw3_var;
-
-	std::array<X86Xmm, 6> vec_vars;
+	const std::array<const X86Xmm*, 6> vec_vars
+	{
+		&x86::xmm0,
+		&x86::xmm1,
+		&x86::xmm2,
+		&x86::xmm3,
+		&x86::xmm4,
+		&x86::xmm5,
+	};
 
 	for (u32 i = 0; i < vec_vars.size(); i++)
 	{
-		vec_vars[i] = compiler.newXmm(fmt::format("vec%d", i).c_str());
-		vec.at(i) = vec_vars.data() + i;
+		vec[i] = vec_vars[i];
 	}
 
-	compiler.alloc(vec_vars[0], asmjit::x86::xmm0);
-	compiler.alloc(vec_vars[1], asmjit::x86::xmm1);
-	compiler.alloc(vec_vars[2], asmjit::x86::xmm2);
-	compiler.alloc(vec_vars[3], asmjit::x86::xmm3);
-	compiler.alloc(vec_vars[4], asmjit::x86::xmm4);
-	compiler.alloc(vec_vars[5], asmjit::x86::xmm5);
-
-	// Initialize labels
-	std::vector<Label> pos_labels{ 0x10000 };
-	this->labels = pos_labels.data();
-
-	// Register labels for block entries
-	for (const u32 addr : f.blocks)
-	{
-		if (addr < f.addr || addr >= f.addr + f.size || addr % 4)
-		{
-			fmt::throw_exception("Invalid function block entry (0x%05x)" HERE, addr);
-		}
-
-		pos_labels[addr / 4] = compiler.newLabel();
-	}
-
-	// Register label for post-the-end address
-	pos_labels[(f.addr + f.size) / 4 % 0x10000] = compiler.newLabel();
-
-	// Register label for jump table resolver
-	Label jt_label = compiler.newLabel();
-	this->jt = &jt_label;
-
-	for (const u32 addr : f.jtable)
-	{
-		if (addr < f.addr || addr >= f.addr + f.size || addr % 4)
-		{
-			fmt::throw_exception("Invalid jump table entry (0x%05x)" HERE, addr);
-		}
-	}
-
-	// Register label for the function return
-	Label end_label = compiler.newLabel();
-	this->end = &end_label;
+	Label label_stop = c->newLabel();
+	Label label_diff = c->newLabel();
+	Label label_code = c->newLabel();
+	std::vector<u32> words;
+	u32 words_align = 8;
 
 	// Start compilation
-	m_pos = f.addr;
+	m_pos = func[0];
+
+	// Set PC and check status
+	c->mov(SPU_OFF_32(pc), m_pos);
+	c->cmp(SPU_OFF_32(state), 0);
+	c->jnz(label_stop);
 
 	if (utils::has_avx())
 	{
-		compiler.vzeroupper();
-		//compiler.pxor(asmjit::x86::xmm0, asmjit::x86::xmm0);
-		//compiler.vptest(asmjit::x86::ymm0, asmjit::x86::ymm0);
-		//compiler.jnz(end_label);
+		// How to check dirty AVX state
+		//c->pxor(x86::xmm0, x86::xmm0);
+		//c->vptest(x86::ymm0, x86::ymm0);
+		//c->jnz(label_stop);
 	}
 
-	for (const u32 op : f.data)
+	// Check code
+	if (false)
 	{
-		// Bind label if initialized
-		if (pos_labels[m_pos / 4].isValid())
-		{
-			compiler.bind(pos_labels[m_pos / 4]);
+		// Disable check (not available)
+	}
+	else if (func.size() - 1 == 1)
+	{
+		c->cmp(x86::dword_ptr(*ls, m_pos), func[1]);
+		c->jnz(label_diff);
+	}
+	else if (func.size() - 1 == 2)
+	{
+		c->mov(*qw1, static_cast<u64>(func[2]) << 32 | func[1]);
+		c->cmp(*qw1, x86::qword_ptr(*ls, m_pos));
+		c->jnz(label_diff);
+	}
+	else if (utils::has_512() && false)
+	{
+		// AVX-512 optimized check using 512-bit registers (disabled)
+		words_align = 64;
 
-			if (f.blocks.find(m_pos) != f.blocks.end())
+		const u32 starta = m_pos & -64;
+		const u32 end = m_pos + (func.size() - 1) * 4;
+		const u32 enda = ::align(end, 64);
+		const u32 sizea = (enda - starta) / 64;
+		verify(HERE), sizea;
+
+		// Load masks
+		if (m_pos != starta || sizea == 1)
+		{
+			Label label = c->newLabel();
+			c->kmovw(x86::k1, x86::word_ptr(label));
+			const u16 mask = (0xffff << (m_pos - starta) / 4) & (0xffff >> (sizea == 1 ? enda - end : 0) / 4);
+
+			consts.emplace_back([=]
 			{
-				compiler.comment("Block:");
+				c->bind(label);
+				c->dw(mask);
+			});
+		}
+
+		if (sizea > 1 && end != enda && end + 32 != enda)
+		{
+			Label label = c->newLabel();
+			c->kmovw(x86::k2, x86::word_ptr(label));
+			const u16 mask = 0xffff >> (enda - end) / 4;
+
+			consts.emplace_back([=]
+			{
+				c->bind(label);
+				c->dw(mask);
+			});
+		}
+
+		// Initialize pointers
+		c->lea(x86::rax, x86::qword_ptr(label_code));
+		c->lea(*qw1, x86::qword_ptr(*ls, starta));
+
+		for (u32 j = starta; j < enda; j += 64)
+		{
+			// Small offset for disp8*N
+			const u32 off = (j - starta) % 8192;
+
+			if (j != starta && off == 0)
+			{
+				// Almost unexpected: update pointers
+				c->lea(x86::rax, x86::qword_ptr(label_code, j));
+				c->lea(*qw1, x86::qword_ptr(*ls, j));
+			}
+
+			if (j < m_pos || j + 64 > end)
+			{
+				c->setExtraReg(j < m_pos || sizea == 1 ? x86::k1 : x86::k2);
+				c->z().vmovdqa32(x86::zmm0, x86::zword_ptr(*qw1, off));
+			}
+			else
+			{
+				c->vmovdqa32(x86::zmm0, x86::zword_ptr(*qw1, off));
+			}
+
+			if (j == starta)
+			{
+				c->vpcmpud(x86::k1, x86::zmm0, x86::zword_ptr(x86::rax, off), 4);
+			}
+			else
+			{
+				c->vpcmpud(x86::k3, x86::zmm0, x86::zword_ptr(x86::rax, off), 4);
+				c->korw(x86::k1, x86::k3, x86::k1);
 			}
 		}
 
+		c->ktestw(x86::k1, x86::k1);
+		c->jnz(label_diff);
+
+		for (u32 i = starta; i < enda; i += 4)
+		{
+			words.push_back(i >= m_pos && i < end ? func[(i - m_pos) / 4 + 1] : 0);
+		}
+	}
+	else if (utils::has_512())
+	{
+		// AVX-512 optimized check using 256-bit registers
+		words_align = 32;
+
+		const u32 starta = m_pos & -32;
+		const u32 end = m_pos + (func.size() - 1) * 4;
+		const u32 enda = ::align(end, 32);
+		const u32 sizea = (enda - starta) / 32;
+		verify(HERE), sizea;
+
+		if (sizea == 1)
+		{
+			if (starta == m_pos && enda == end)
+			{
+				c->vmovdqa(x86::ymm0, x86::yword_ptr(*ls, starta));
+			}
+			else
+			{
+				c->vpxor(x86::ymm0, x86::ymm0, x86::ymm0);
+				c->vpblendd(x86::ymm0, x86::ymm0, x86::yword_ptr(*ls, starta), (0xff << (m_pos - starta) / 4) & (0xff >> (enda - end) / 4));
+			}
+
+			c->vpxor(x86::ymm0, x86::ymm0, x86::yword_ptr(label_code));
+			c->vptest(x86::ymm0, x86::ymm0);
+			c->jnz(label_diff);
+
+			for (u32 i = starta; i < enda; i += 4)
+			{
+				words.push_back(i >= m_pos && i < end ? func[(i - m_pos) / 4 + 1] : 0);
+			}
+		}
+		else if (sizea == 2 && (end - m_pos) <= 32)
+		{
+			c->vpxor(x86::ymm0, x86::ymm0, x86::ymm0);
+			c->vpblendd(x86::ymm0, x86::ymm0, x86::yword_ptr(*ls, starta), 0xff & (0xff << (m_pos - starta) / 4));
+			c->vpblendd(x86::ymm0, x86::ymm0, x86::yword_ptr(*ls, starta + 32), 0xff & (0xff >> (enda - end) / 4));
+			c->vpxor(x86::ymm0, x86::ymm0, x86::yword_ptr(label_code));
+			c->vptest(x86::ymm0, x86::ymm0);
+			c->jnz(label_diff);
+
+			for (u32 i = starta; i < starta + 32; i += 4)
+			{
+				words.push_back(i >= m_pos ? func[(i - m_pos) / 4 + 1] : i + 32 < end ? func[(i + 32 - m_pos) / 4 + 1] : 0);
+			}
+		}
+		else
+		{
+			if (starta < m_pos || enda > end)
+			{
+				c->vpxor(x86::xmm2, x86::xmm2, x86::xmm2);
+			}
+
+			// Initialize pointers
+			c->lea(x86::rax, x86::qword_ptr(label_code));
+			c->lea(*qw1, x86::qword_ptr(*ls, starta));
+
+			for (u32 j = starta; j < enda; j += 32)
+			{
+				// Small offset for disp8*N
+				const u32 off = (j - starta) % 4096;
+
+				if (j != starta && off == 0)
+				{
+					// Almost unexpected: update pointers
+					c->lea(x86::rax, x86::qword_ptr(label_code, j - starta));
+					c->lea(*qw1, x86::qword_ptr(*ls, j));
+				}
+
+				// Load aligned code block from LS, mask if necessary (at the end or the beginning)
+				if (j < m_pos)
+				{
+					c->vpblendd(x86::ymm1, x86::ymm2, x86::yword_ptr(*qw1, off), 0xff & (0xff << (m_pos - starta) / 4));
+				}
+				else if (j + 32 > end)
+				{
+					c->vpblendd(x86::ymm1, x86::ymm2, x86::yword_ptr(*qw1, off), 0xff & (0xff >> (enda - end) / 4));
+				}
+				else
+				{
+					c->vmovdqa32(x86::ymm1, x86::yword_ptr(*qw1, off));
+				}
+
+				// Perform bitwise comparison and accumulate
+				if (j == starta)
+				{
+					c->vpxor(x86::ymm0, x86::ymm1, x86::yword_ptr(x86::rax, off));
+				}
+				else
+				{
+					c->vpternlogd(x86::ymm0, x86::ymm1, x86::yword_ptr(x86::rax, off), 0xf6 /* orAxorBC */);
+				}
+			}
+
+			c->vptest(x86::ymm0, x86::ymm0);
+			c->jnz(label_diff);
+
+			for (u32 i = starta; i < enda; i += 4)
+			{
+				words.push_back(i >= m_pos && i < end ? func[(i - m_pos) / 4 + 1] : 0);
+			}
+		}
+	}
+	else if (utils::has_avx())
+	{
+		// Mainstream AVX
+		words_align = 32;
+
+		const u32 starta = m_pos & -32;
+		const u32 end = m_pos + (func.size() - 1) * 4;
+		const u32 enda = ::align(end, 32);
+		const u32 sizea = (enda - starta) / 32;
+		verify(HERE), sizea;
+
+		if (sizea == 1)
+		{
+			if (starta == m_pos && enda == end)
+			{
+				c->vmovaps(x86::ymm0, x86::yword_ptr(*ls, starta));
+			}
+			else
+			{
+				c->vxorps(x86::ymm0, x86::ymm0, x86::ymm0);
+				c->vblendps(x86::ymm0, x86::ymm0, x86::yword_ptr(*ls, starta), (0xff << (m_pos - starta) / 4) & (0xff >> (enda - end) / 4));
+			}
+
+			c->vxorps(x86::ymm0, x86::ymm0, x86::yword_ptr(label_code));
+			c->vptest(x86::ymm0, x86::ymm0);
+			c->jnz(label_diff);
+
+			for (u32 i = starta; i < enda; i += 4)
+			{
+				words.push_back(i >= m_pos && i < end ? func[(i - m_pos) / 4 + 1] : 0);
+			}
+		}
+		else if (sizea == 2 && (end - m_pos) <= 32)
+		{
+			c->vxorps(x86::ymm0, x86::ymm0, x86::ymm0);
+			c->vblendps(x86::ymm0, x86::ymm0, x86::yword_ptr(*ls, starta), 0xff & (0xff << (m_pos - starta) / 4));
+			c->vblendps(x86::ymm0, x86::ymm0, x86::yword_ptr(*ls, starta + 32), 0xff & (0xff >> (enda - end) / 4));
+			c->vxorps(x86::ymm0, x86::ymm0, x86::yword_ptr(label_code));
+			c->vptest(x86::ymm0, x86::ymm0);
+			c->jnz(label_diff);
+
+			for (u32 i = starta; i < starta + 32; i += 4)
+			{
+				words.push_back(i >= m_pos ? func[(i - m_pos) / 4 + 1] : i + 32 < end ? func[(i + 32 - m_pos) / 4 + 1] : 0);
+			}
+		}
+		else
+		{
+			if (starta < m_pos || enda > end)
+			{
+				c->vxorps(x86::xmm2, x86::xmm2, x86::xmm2);
+			}
+
+			// Initialize pointers
+			c->add(*ls, starta);
+			c->lea(x86::rax, x86::qword_ptr(label_code));
+			u32 ls_off = starta;
+
+			for (u32 j = starta; j < enda; j += 32)
+			{
+				// Small offset
+				const u32 off = (j - starta) % 128;
+
+				// Interleave two threads
+				const auto& reg0 = off % 64 ? x86::ymm3 : x86::ymm0;
+				const auto& reg1 = off % 64 ? x86::ymm4 : x86::ymm1;
+
+				if (j != starta && off == 0)
+				{
+					ls_off += 128;
+					c->sub(*ls, -128);
+					c->sub(x86::rax, -128);
+				}
+
+				// Load aligned code block from LS, mask if necessary (at the end or the beginning)
+				if (j < m_pos)
+				{
+					c->vblendps(reg1, x86::ymm2, x86::yword_ptr(*ls, off), 0xff & (0xff << (m_pos - starta) / 4));
+				}
+				else if (j + 32 > end)
+				{
+					c->vblendps(reg1, x86::ymm2, x86::yword_ptr(*ls, off), 0xff & (0xff >> (enda - end) / 4));
+				}
+				else
+				{
+					c->vmovaps(reg1, x86::yword_ptr(*ls, off));
+				}
+
+				// Perform bitwise comparison and accumulate
+				if (j == starta || j == starta + 32)
+				{
+					c->vxorps(reg0, reg1, x86::yword_ptr(x86::rax, off));
+				}
+				else
+				{
+					c->vxorps(reg1, reg1, x86::yword_ptr(x86::rax, off));
+					c->vorps(reg0, reg1, reg0);
+				}
+			}
+
+			c->sub(*ls, ls_off);
+			c->vorps(x86::ymm0, x86::ymm3, x86::ymm0);
+			c->vptest(x86::ymm0, x86::ymm0);
+			c->jnz(label_diff);
+
+			for (u32 i = starta; i < enda; i += 4)
+			{
+				words.push_back(i >= m_pos && i < end ? func[(i - m_pos) / 4 + 1] : 0);
+			}
+		}
+	}
+	else if (true)
+	{
+		// Compatible SSE2
+		words_align = 16;
+
+		const u32 starta = m_pos & -16;
+		const u32 end = m_pos + (func.size() - 1) * 4;
+		const u32 enda = ::align(end, 16);
+		const u32 sizea = (enda - starta) / 16;
+		verify(HERE), sizea;
+
+		// Initialize pointers
+		c->add(*ls, starta);
+		c->lea(x86::rax, x86::qword_ptr(label_code));
+		u32 ls_off = starta;
+
+		for (u32 j = starta; j < enda; j += 16)
+		{
+			// Small offset
+			const u32 off = (j - starta) % 128;
+
+			// Interleave two threads
+			const auto& reg0 = off % 32 ? x86::xmm3 : x86::xmm0;
+			const auto& reg1 = off % 32 ? x86::xmm4 : x86::xmm1;
+			const auto& dest = j == starta || j == starta + 16 ? reg0 : reg1;
+
+			if (j != starta && off == 0)
+			{
+				ls_off += 128;
+				c->sub(*ls, -128);
+				c->sub(x86::rax, -128);
+			}
+
+			// Load aligned code block from LS
+			if (j < m_pos)
+			{
+				static constexpr u8 s_masks[4]{0b11100100, 0b11100101, 0b11101010, 0b11111111};
+				c->pshufd(dest, x86::dqword_ptr(*ls, off), s_masks[(m_pos - starta) / 4]);
+			}
+			else if (j + 16 > end)
+			{
+				static constexpr u8 s_masks[4]{0b11100100, 0b10100100, 0b01010100, 0b00000000};
+				c->pshufd(dest, x86::dqword_ptr(*ls, off), s_masks[(enda - end) / 4]);
+			}
+			else
+			{
+				c->movaps(dest, x86::dqword_ptr(*ls, off));
+			}
+
+			// Perform bitwise comparison and accumulate
+			c->xorps(dest, x86::dqword_ptr(x86::rax, off));
+
+			if (j != starta && j != starta + 16)
+			{
+				c->orps(reg0, dest);
+			}
+		}
+
+		for (u32 i = starta; i < enda; i += 4)
+		{
+			// Fill alignment holes with first or last elements
+			words.push_back(func[(i < m_pos ? 0 : i >= end ? end - 4 - m_pos : i - m_pos) / 4 + 1]);
+		}
+
+		if (sizea != 1)
+		{
+			c->orps(x86::xmm0, x86::xmm3);
+		}
+
+		c->sub(*ls, ls_off);
+
+		if (utils::has_sse41())
+		{
+			c->ptest(x86::xmm0, x86::xmm0);
+			c->jnz(label_diff);
+		}
+		else
+		{
+			c->packssdw(x86::xmm0, x86::xmm0);
+			c->movq(x86::rax, x86::xmm0);
+			c->test(x86::rax, x86::rax);
+			c->jne(label_diff);
+		}
+	}
+	else
+	{
+		// Legacy (slow, disabled)
+		save_rcx();
+		c->mov(x86::r9, x86::rdi);
+		c->mov(x86::r10, x86::rsi);
+		c->lea(x86::rsi, x86::qword_ptr(*ls, m_pos));
+		c->lea(x86::rdi, x86::qword_ptr(label_code));
+		c->mov(x86::ecx, (func.size() - 1) / 2);
+		if ((func.size() - 1) % 2)
+			c->cmpsd();
+		c->repe().cmpsq();
+		load_rcx();
+		c->mov(x86::rdi, x86::r9);
+		c->mov(x86::rsi, x86::r10);
+		c->jnz(label_diff);
+
+		for (u32 i = 1; i < func.size(); i++)
+		{
+			words.push_back(func[i]);
+		}
+	}
+
+	if (utils::has_avx())
+	{
+		c->vzeroupper();
+	}
+
+	c->inc(SPU_OFF_64(block_counter));
+
+	for (u32 i = 1; i < func.size(); i++)
+	{
 		if (g_cfg.core.spu_debug)
 		{
 			// Disasm
@@ -188,17 +584,22 @@ void spu_recompiler::compile(spu_function_t& f)
 			log += '\n';
 		}
 
-		// Recompiler function
-		(this->*s_spu_decoder.decode(op))({ op });
+		// Get opcode
+		const u32 op = se_storage<u32>::swap(func[i]);
+
+		// Execute recompiler function
+		(this->*s_spu_decoder.decode(op))({op});
 
 		// Collect allocated xmm vars
 		for (u32 i = 0; i < vec_vars.size(); i++)
 		{
-			if (!vec[i])
-			{
-				compiler.unuse(vec_vars[i]);
-				vec[i] = vec_vars.data() + i;
-			}
+			vec[i] = vec_vars[i];
+		}
+
+		// Check if block was terminated
+		if (m_pos == -1)
+		{
+			break;
 		}
 
 		// Set next position
@@ -210,60 +611,60 @@ void spu_recompiler::compile(spu_function_t& f)
 		log += '\n';
 	}
 
-	// Generate default function end (go to the next address)
-	compiler.bind(pos_labels[m_pos / 4 % 0x10000]);
-	compiler.comment("Fallthrough:");
-	compiler.mov(addr_var, spu_branch_target(m_pos));
-	compiler.jmp(end_label);
-
-	// Generate jump table resolver (uses addr_var)
-	compiler.bind(jt_label);
-
-	if (f.jtable.size())
+	// Make fallthrough if necessary
+	if (m_pos != -1)
 	{
-		compiler.comment("Jump table resolver:");
+		branch_fixed(spu_branch_target(m_pos));
 	}
 
-	for (const u32 addr : f.jtable)
+	// Simply return
+	c->align(kAlignCode, 16);
+	c->bind(label_stop);
+	c->ret();
+
+	// Dispatch
+	c->align(kAlignCode, 16);
+	c->bind(label_diff);
+	c->inc(SPU_OFF_64(block_failure));
+	c->jmp(asmjit::imm_ptr(&spu_recompiler_base::dispatch));
+
+	for (auto&& work : decltype(after)(std::move(after)))
 	{
-		if ((addr % 4) == 0 && addr < 0x40000 && pos_labels[addr / 4].isValid())
-		{
-			// It could be binary search or something
-			compiler.cmp(addr_var, addr);
-			compiler.je(pos_labels[addr / 4]);
-		}
-		else
-		{
-			LOG_ERROR(SPU, "Unable to add jump table entry (0x%05x)", addr);
-		}
+		work();
 	}
 
-	// Generate function end (returns addr_var)
-	compiler.bind(end_label);
-	compiler.unuse(cpu_var);
-	compiler.unuse(ls_var);
-	compiler.ret(addr_var);
+	c->align(kAlignData, words_align);
+	c->bind(label_code);
+	for (u32 d : words)
+		c->dd(d);
 
-	// Finalization
-	compiler.endFunc();
-	compiler.finalize();
+	for (auto&& work : decltype(consts)(std::move(consts)))
+	{
+		work();
+	}
 
-	// Compile and store function address
-	typedef u32 (*Func)(void* x, void* y);
-	Func fn;
-	m_jit->add(&fn, codeHolder);
+	xmm_consts.clear();
 
-	f.compiled = asmjit::Internal::ptr_cast<decltype(f.compiled)>(fn);
+	// Compile and get function address
+	spu_function_t fn;
+
+	if (m_rt->add(&fn, &code))
+	{
+		LOG_FATAL(SPU, "Failed to build a function");
+	}
 
 	if (g_cfg.core.spu_debug)
 	{
 		// Add ASMJIT logs
+		fmt::append(log, "{%s} Address: %p\n\n", m_spu.get_name(), fn);
 		log += logger.getString();
 		log += "\n\n\n";
 
 		// Append log file
 		fs::file(Emu.GetCachePath() + "SPUJIT.log", fs::write + fs::append).write(log);
 	}
+
+	return fn;
 }
 
 spu_recompiler::XmmLink spu_recompiler::XmmAlloc() // get empty xmm register
@@ -293,7 +694,23 @@ spu_recompiler::XmmLink spu_recompiler::XmmGet(s8 reg, XmmType type) // get xmm
 
 inline asmjit::X86Mem spu_recompiler::XmmConst(v128 data)
 {
-	return c->newXmmConst(asmjit::kConstScopeLocal, asmjit::Data128::fromU64(data._u64[0], data._u64[1]));
+	// Find existing const
+	auto& xmm_label = xmm_consts[std::make_pair(data._u64[0], data._u64[1])];
+
+	if (!xmm_label.isValid())
+	{
+		xmm_label = c->newLabel();
+
+		consts.emplace_back([=]
+		{
+			c->align(asmjit::kAlignData, 16);
+			c->bind(xmm_label);
+			c->dq(data._u64[0]);
+			c->dq(data._u64[1]);
+		});
+	}
+
+	return asmjit::x86::oword_ptr(xmm_label);
 }
 
 inline asmjit::X86Mem spu_recompiler::XmmConst(__m128 data)
@@ -306,151 +723,163 @@ inline asmjit::X86Mem spu_recompiler::XmmConst(__m128i data)
 	return XmmConst(v128::fromV(data));
 }
 
-void spu_recompiler::CheckInterruptStatus(spu_opcode_t op)
+void spu_recompiler::branch_fixed(u32 target)
 {
+	using namespace asmjit;
+
+	// Set patch address as a third argument and fallback to it
+	Label patch_point = c->newLabel();
+	c->lea(*qw0, x86::qword_ptr(patch_point));
+	c->mov(SPU_OFF_32(pc), target);
+	c->align(kAlignCode, 16);
+	c->bind(patch_point);
+
+	const auto result = m_spu.jit_map.emplace(block(m_spu, target), nullptr);
+
+	if (result.second || !result.first->second)
+	{
+		if (result.first->first.size())
+		{
+			// Target block hasn't been compiled yet, record overwriting position
+			c->mov(*ls, imm_ptr(&*result.first));
+			c->jmp(imm_ptr(&spu_recompiler_base::branch));
+		}
+		else
+		{
+			// SPURS Workload entry point or similar thing
+			c->mov(x86::r10, x86::qword_ptr(*cpu, offset32(&SPUThread::jit_dispatcher) + target * 2));
+			c->xor_(qw0->r32(), qw0->r32());
+			c->jmp(x86::r10);
+		}
+	}
+	else
+	{
+		c->jmp(imm_ptr(result.first->second));
+	}
+
+	c->align(kAlignCode, 16);
+}
+
+void spu_recompiler::branch_indirect(spu_opcode_t op)
+{
+	using namespace asmjit;
+
+	// Load indirect jump address
+	c->mov(x86::r10, x86::qword_ptr(*cpu, addr->r64(), 1, offset32(&SPUThread::jit_dispatcher)));
+	c->xor_(qw0->r32(), qw0->r32());
+
 	if (op.d)
+	{
 		c->lock().btr(SPU_OFF_8(interrupts_enabled), 0);
+	}
 	else if (op.e)
 	{
 		c->lock().bts(SPU_OFF_8(interrupts_enabled), 0);
-		c->mov(*qw0, SPU_OFF_32(ch_event_stat));
-		c->and_(*qw0, SPU_OFF_32(ch_event_mask));
-		c->and_(*qw0, SPU_EVENT_INTR_TEST);
-		c->cmp(*qw0, 0);
+		c->mov(x86::r9d, SPU_OFF_32(ch_event_stat));
+		c->and_(x86::r9d, SPU_OFF_32(ch_event_mask));
+		c->and_(x86::r9d, SPU_EVENT_INTR_TEST);
+		c->cmp(x86::r9d, 0);
 
-		asmjit::Label noInterrupt = c->newLabel();
+		Label noInterrupt = c->newLabel();
 		c->je(noInterrupt);
 		c->lock().btr(SPU_OFF_8(interrupts_enabled), 0);
 		c->mov(SPU_OFF_32(srr0), *addr);
-		c->mov(SPU_OFF_32(pc), 0);
-
-		FunctionCall();
-
-		c->mov(*addr, SPU_OFF_32(srr0));
+		branch_fixed(0);
+		c->align(kAlignCode, 16);
 		c->bind(noInterrupt);
-		c->unuse(*qw0);
 	}
+
+	c->mov(SPU_OFF_32(pc), *addr);
+	c->jmp(x86::r10);
 }
 
-void spu_recompiler::InterpreterCall(spu_opcode_t op)
+asmjit::Label spu_recompiler::halt(u32 pos)
 {
-	auto gate = [](SPUThread* _spu, u32 opcode, spu_inter_func_t _func) noexcept -> u32
+	auto gate = [](SPUThread* _spu)
 	{
-		try
+		_spu->halt();
+	};
+
+	asmjit::Label label = c->newLabel();
+
+	after.emplace_back([=]
+	{
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(label);
+		c->mov(SPU_OFF_32(pc), pos);
+		c->jmp(asmjit::imm_ptr<void(*)(SPUThread*)>(gate));
+	});
+
+	return label;
+}
+
+void spu_recompiler::fall(spu_opcode_t op)
+{
+	auto gate = [](SPUThread* _spu, u32 opcode, spu_inter_func_t _func, spu_function_t _ret)
+	{
+		if (!_func(*_spu, {opcode}))
 		{
-			// TODO: check correctness
-
-			if (test(_spu->state) && _spu->check_state())
-			{
-				return 0x2000000 | _spu->pc;
-			}
-
-			if (UNLIKELY(!_func(*_spu, {opcode})))
-			{
-				return 0x2000000 | _spu->pc;
-			}
-
-			_spu->pc += 4;
-			return 0;
-		}
-		catch (...)
-		{
-			_spu->pending_exception = std::current_exception();
-			return 0x1000000 | _spu->pc;
+			// Workaround for MSVC (TCO)
+			fmt::raw_error("spu_recompiler::fall(): unexpected interpreter call");
 		}
+
+		// Restore arguments and return to the next instruction
+		_ret(*_spu, _spu->_ptr<u8>(0), nullptr);
+	};
+
+	asmjit::Label next = c->newLabel();
+	c->mov(SPU_OFF_32(pc), m_pos);
+	c->mov(*ls, op.opcode);
+	c->mov(*qw0, asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*>(g_spu_interpreter_fast.decode(op.opcode))));
+	c->lea(*qw1, asmjit::x86::qword_ptr(next));
+	c->jmp(asmjit::imm_ptr<void(*)(SPUThread*, u32, spu_inter_func_t, spu_function_t)>(gate));
+	c->align(asmjit::kAlignCode, 16);
+	c->bind(next);
+}
+
+void spu_recompiler::save_rcx()
+{
+#ifdef _WIN32
+	c->mov(asmjit::x86::r11, *cpu);
+	cpu = &asmjit::x86::r11;
+#endif
+}
+
+void spu_recompiler::load_rcx()
+{
+#ifdef _WIN32
+	cpu = &asmjit::x86::rcx;
+	c->mov(*cpu, asmjit::x86::r11);
+#endif
+}
+
+void spu_recompiler::UNK(spu_opcode_t op)
+{
+	auto gate = [](SPUThread* _spu, u32 op)
+	{
+		fmt::throw_exception("Unknown/Illegal instruction (0x%08x)" HERE, op);
 	};
 
 	c->mov(SPU_OFF_32(pc), m_pos);
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, u32(SPUThread*, u32, spu_inter_func_t)>(gate)), asmjit::FuncSignature3<u32, void*, u32, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *cpu);
-	call->setArg(1, asmjit::imm_u(op.opcode));
-	call->setArg(2, asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*>(g_spu_interpreter_fast.decode(op.opcode))));
-	call->setRet(0, *addr);
-
-	// return immediately if an error occured
-	c->test(*addr, *addr);
-	c->jnz(*end);
-	c->unuse(*addr);
-}
-
-void spu_recompiler::FunctionCall()
-{
-	auto gate = [](SPUThread* _spu, u32 link) noexcept -> u32
-	{
-		_spu->recursion_level++;
-
-		try
-		{
-			// TODO: check correctness
-
-			if (_spu->pc & 0x4000000)
-			{
-				if (_spu->pc & 0x8000000)
-				{
-					fmt::throw_exception("Undefined behaviour" HERE);
-				}
-
-				_spu->interrupts_enabled = true;
-				_spu->pc &= ~0x4000000;
-			}
-			else if (_spu->pc & 0x8000000)
-			{
-				_spu->interrupts_enabled = false;
-				_spu->pc &= ~0x8000000;
-			}
-
-			if (_spu->pc == link)
-			{
-				LOG_ERROR(SPU, "Branch-to-next");
-			}
-			else if (_spu->pc == link - 4)
-			{
-				LOG_ERROR(SPU, "Branch-to-self");
-			}
-
-			while (!test(_spu->state) || !_spu->check_state())
-			{
-				// Proceed recursively
-				spu_recompiler_base::enter(*_spu);
-
-				if (test(_spu->state & cpu_flag::ret))
-				{
-					break;
-				}
-
-				if (_spu->pc == link)
-				{
-					_spu->recursion_level--;
-					return 0; // Successfully returned
-				}
-			}
-
-			_spu->recursion_level--;
-			return 0x2000000 | _spu->pc;
-		}
-		catch (...)
-		{
-			_spu->pending_exception = std::current_exception();
-
-			_spu->recursion_level--;
-			return 0x1000000 | _spu->pc;
-		}
-	};
-
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, u32(SPUThread*, u32)>(gate)), asmjit::FuncSignature2<u32, SPUThread*, u32>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *cpu);
-	call->setArg(1, asmjit::imm_u(spu_branch_target(m_pos + 4)));
-	call->setRet(0, *addr);
-
-	// return immediately if an error occured
-	c->test(*addr, *addr);
-	c->jnz(*end);
-	c->unuse(*addr);
+	c->mov(*ls, op.opcode);
+	c->jmp(asmjit::imm_ptr<void(*)(SPUThread*, u32)>(gate));
+	m_pos = -1;
 }
 
 void spu_recompiler::STOP(spu_opcode_t op)
 {
-	InterpreterCall(op); // TODO
+	auto gate = [](SPUThread* _spu, u32 code)
+	{
+		if (_spu->stop_and_signal(code))
+		{
+			_spu->pc += 4;
+		}
+	};
+
+	c->mov(SPU_OFF_32(pc), m_pos);
+	c->mov(*ls, op.opcode);
+	c->jmp(asmjit::imm_ptr<void(*)(SPUThread*, u32)>(gate));
+	m_pos = -1;
 }
 
 void spu_recompiler::LNOP(spu_opcode_t op)
@@ -471,11 +900,25 @@ void spu_recompiler::DSYNC(spu_opcode_t op)
 
 void spu_recompiler::MFSPR(spu_opcode_t op)
 {
-	InterpreterCall(op);
+	// Check SPUInterpreter for notes.
+	const XmmLink& vr = XmmAlloc();
+	c->pxor(vr, vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::RDCH(spu_opcode_t op)
 {
+	auto gate = [](SPUThread* _spu, u32 ch, v128* out)
+	{
+		u32 value;
+
+		if (_spu->get_ch_value(ch, value))
+		{
+			*out = v128::from32r(value);
+			_spu->pc += 4;
+		}
+	};
+
 	switch (op.ra)
 	{
 	case SPU_RdSRR0:
@@ -502,16 +945,28 @@ void spu_recompiler::RDCH(spu_opcode_t op)
 		c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 		return;
 	}
-	default:
-	{
-		InterpreterCall(op); // TODO
-	}
 	}
+
+	c->mov(SPU_OFF_32(pc), m_pos);
+	c->mov(*ls, op.ra);
+	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
+	c->jmp(asmjit::imm_ptr<void(*)(SPUThread*, u32, v128*)>(gate));
+	m_pos = -1;
 }
 
 void spu_recompiler::RCHCNT(spu_opcode_t op)
 {
-	InterpreterCall(op); // TODO
+	auto gate = [](SPUThread* _spu, u32 ch, v128* out)
+	{
+		*out = v128::from32r(_spu->get_ch_count(ch));
+		_spu->pc += 4;
+	};
+
+	c->mov(SPU_OFF_32(pc), m_pos);
+	c->mov(*ls, op.ra);
+	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
+	c->jmp(asmjit::imm_ptr<void(*)(SPUThread*, u32, v128*)>(gate));
+	m_pos = -1;
 }
 
 void spu_recompiler::SF(spu_opcode_t op)
@@ -628,29 +1083,17 @@ void spu_recompiler::ROT(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](u32* t, const u32* a, const s32* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 4; i++)
-		{
-			t[i] = rol32(a[i], b[i]);
-		}
-	};
+		c->mov(qw0->r32(), SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->mov(asmjit::x86::ecx, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
+		c->rol(qw0->r32(), asmjit::x86::cl);
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u32*, const u32*, const s32*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 4; i++) // unrolled loop
-	//{
-	//	c->mov(qw0->r32(), SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
-	//	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
-	//	c->rol(qw0->r32(), *addr);
-	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::ROTM(spu_opcode_t op)
@@ -683,30 +1126,18 @@ void spu_recompiler::ROTM(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](u32* t, const u32* a, const u32* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 4; i++)
-		{
-			t[i] = static_cast<u32>(static_cast<u64>(a[i]) >> ((0 - b[i]) & 0x3f));
-		}
-	};
+		c->mov(qw0->r32(), SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->mov(asmjit::x86::ecx, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
+		c->neg(asmjit::x86::ecx);
+		c->shr(*qw0, asmjit::x86::cl);
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 4; i++) // unrolled loop
-	//{
-	//	c->mov(qw0->r32(), SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
-	//	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
-	//	c->neg(*addr);
-	//	c->shr(*qw0, *addr);
-	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::ROTMA(spu_opcode_t op)
@@ -738,30 +1169,18 @@ void spu_recompiler::ROTMA(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](s32* t, const s32* a, const u32* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 4; i++)
-		{
-			t[i] = static_cast<s32>(static_cast<s64>(a[i]) >> ((0 - b[i]) & 0x3f));
-		}
-	};
+		c->movsxd(*qw0, SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->mov(asmjit::x86::ecx, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
+		c->neg(asmjit::x86::ecx);
+		c->sar(*qw0, asmjit::x86::cl);
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(s32*, const s32*, const u32*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 4; i++) // unrolled loop
-	//{
-	//	c->movsxd(*qw0, SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
-	//	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
-	//	c->neg(*addr);
-	//	c->sar(*qw0, *addr);
-	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::SHL(spu_opcode_t op)
@@ -790,29 +1209,17 @@ void spu_recompiler::SHL(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](u32* t, const u32* a, const u32* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 4; i++)
-		{
-			t[i] = static_cast<u32>(static_cast<u64>(a[i]) << (b[i] & 0x3f));
-		}
-	};
+		c->mov(qw0->r32(), SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->mov(asmjit::x86::ecx, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
+		c->shl(*qw0, asmjit::x86::cl);
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 4; i++) // unrolled loop
-	//{
-	//	c->mov(qw0->r32(), SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
-	//	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
-	//	c->shl(*qw0, *addr);
-	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::ROTH(spu_opcode_t op) //nf
@@ -845,29 +1252,17 @@ void spu_recompiler::ROTH(spu_opcode_t op) //nf
 		return;
 	}
 
-	auto body = [](u16* t, const u16* a, const u16* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 8; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 8; i++)
-		{
-			t[i] = rol16(a[i], b[i]);
-		}
-	};
+		c->movzx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
+		c->movzx(asmjit::x86::ecx, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
+		c->rol(qw0->r16(), asmjit::x86::cl);
+		c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u16*, const u16*, const u16*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 8; i++) // unrolled loop
-	//{
-	//	c->movzx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
-	//	c->movzx(*addr, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
-	//	c->rol(qw0->r16(), *addr);
-	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::ROTHM(spu_opcode_t op)
@@ -920,30 +1315,18 @@ void spu_recompiler::ROTHM(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](u16* t, const u16* a, const u16* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 8; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 8; i++)
-		{
-			t[i] = static_cast<u16>(static_cast<u32>(a[i]) >> ((0 - b[i]) & 0x1f));
-		}
-	};
+		c->movzx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
+		c->movzx(asmjit::x86::ecx, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
+		c->neg(asmjit::x86::ecx);
+		c->shr(qw0->r32(), asmjit::x86::cl);
+		c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u16*, const u16*, const u16*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 8; i++) // unrolled loop
-	//{
-	//	c->movzx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
-	//	c->movzx(*addr, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
-	//	c->neg(*addr);
-	//	c->shr(qw0->r32(), *addr);
-	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::ROTMAH(spu_opcode_t op)
@@ -997,30 +1380,18 @@ void spu_recompiler::ROTMAH(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](s16* t, const s16* a, const u16* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 8; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 8; i++)
-		{
-			t[i] = static_cast<s16>(static_cast<s32>(a[i]) >> ((0 - b[i]) & 0x1f));
-		}
-	};
+		c->movsx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
+		c->movzx(asmjit::x86::ecx, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
+		c->neg(asmjit::x86::ecx);
+		c->sar(qw0->r32(), asmjit::x86::cl);
+		c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(s16*, const s16*, const u16*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 8; i++) // unrolled loop
-	//{
-	//	c->movsx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
-	//	c->movzx(*addr, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
-	//	c->neg(*addr);
-	//	c->sar(qw0->r32(), *addr);
-	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::SHLH(spu_opcode_t op)
@@ -1068,29 +1439,17 @@ void spu_recompiler::SHLH(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](u16* t, const u16* a, const u16* b) noexcept
+	save_rcx();
+
+	for (u32 i = 0; i < 8; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 8; i++)
-		{
-			t[i] = static_cast<u16>(static_cast<u32>(a[i]) << (b[i] & 0x1f));
-		}
-	};
+		c->movzx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
+		c->movzx(asmjit::x86::ecx, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
+		c->shl(qw0->r32(), asmjit::x86::cl);
+		c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
+	}
 
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u16*, const u16*, const u16*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
-
-	//for (u32 i = 0; i < 8; i++) // unrolled loop
-	//{
-	//	c->movzx(qw0->r32(), SPU_OFF_16(gpr, op.ra, &v128::_u16, i));
-	//	c->movzx(*addr, SPU_OFF_16(gpr, op.rb, &v128::_u16, i));
-	//	c->shl(qw0->r32(), *addr);
-	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
-	//}
+	load_rcx();
 }
 
 void spu_recompiler::ROTI(spu_opcode_t op)
@@ -1262,109 +1621,137 @@ void spu_recompiler::AVGB(spu_opcode_t op)
 
 void spu_recompiler::MTSPR(spu_opcode_t op)
 {
-	InterpreterCall(op);
+	// Check SPUInterpreter for notes.
 }
 
 void spu_recompiler::WRCH(spu_opcode_t op)
 {
+	auto gate = [](SPUThread* _spu, u32 ch, u32 value)
+	{
+		if (_spu->set_ch_value(ch, value))
+		{
+			_spu->pc += 4;
+		}
+	};
+
 	switch (op.ra)
 	{
 	case SPU_WrSRR0:
 	{
 		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_32(srr0), *addr);
-		c->unuse(*addr);
 		return;
 	}
 	case MFC_LSA:
 	{
 		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_32(ch_mfc_cmd, &spu_mfc_cmd::lsa), *addr);
-		c->unuse(*addr);
 		return;
 	}
 	case MFC_EAH:
 	{
 		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_32(ch_mfc_cmd, &spu_mfc_cmd::eah), *addr);
-		c->unuse(*addr);
 		return;
 	}
 	case MFC_EAL:
 	{
 		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_32(ch_mfc_cmd, &spu_mfc_cmd::eal), *addr);
-		c->unuse(*addr);
 		return;
 	}
 	case MFC_Size:
 	{
 		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_16(ch_mfc_cmd, &spu_mfc_cmd::size), addr->r16());
-		c->unuse(*addr);
 		return;
 	}
 	case MFC_TagID:
 	{
 		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_8(ch_mfc_cmd, &spu_mfc_cmd::tag), addr->r8());
-		c->unuse(*addr);
 		return;
 	}
 	case 69:
 	{
 		return;
 	}
-	default:
-	{
-		InterpreterCall(op); // TODO
-	}
 	}
+
+	c->mov(SPU_OFF_32(pc), m_pos);
+	c->mov(*ls, op.ra);
+	c->mov(qw0->r32(), SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
+	c->jmp(asmjit::imm_ptr<void(*)(SPUThread*, u32, u32)>(gate));
+	m_pos = -1;
 }
 
 void spu_recompiler::BIZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
-	c->and_(*addr, 0x3fffc);
-	if (op.d || op.e) c->or_(*addr, op.e << 26 | op.d << 27); // interrupt flags neutralize jump table
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
-	c->je(*jt);
-	c->unuse(*addr);
+	c->je(branch_label);
+
+	after.emplace_back([=]
+	{
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+		c->and_(*addr, 0x3fffc);
+		branch_indirect(op);
+	});
 }
 
 void spu_recompiler::BINZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
-	c->and_(*addr, 0x3fffc);
-	if (op.d || op.e) c->or_(*addr, op.e << 26 | op.d << 27); // interrupt flags neutralize jump table
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
-	c->jne(*jt);
-	c->unuse(*addr);
+	c->jne(branch_label);
+
+	after.emplace_back([=]
+	{
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+		c->and_(*addr, 0x3fffc);
+		branch_indirect(op);
+	});
 }
 
 void spu_recompiler::BIHZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
-	c->and_(*addr, 0x3fffc);
-	if (op.d || op.e) c->or_(*addr, op.e << 26 | op.d << 27); // interrupt flags neutralize jump table
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
-	c->je(*jt);
-	c->unuse(*addr);
+	c->je(branch_label);
+
+	after.emplace_back([=]
+	{
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+		c->and_(*addr, 0x3fffc);
+		branch_indirect(op);
+	});
 }
 
 void spu_recompiler::BIHNZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
-	c->and_(*addr, 0x3fffc);
-	if (op.d || op.e) c->or_(*addr, op.e << 26 | op.d << 27); // interrupt flags neutralize jump table
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
-	c->jne(*jt);
-	c->unuse(*addr);
+	c->jne(branch_label);
+
+	after.emplace_back([=]
+	{
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+		c->and_(*addr, 0x3fffc);
+		branch_indirect(op);
+	});
 }
 
 void spu_recompiler::STOPD(spu_opcode_t op)
 {
-	InterpreterCall(op);
+	fall(op);
 }
 
 void spu_recompiler::STQX(spu_opcode_t op)
@@ -1377,7 +1764,7 @@ void spu_recompiler::STQX(spu_opcode_t op)
 	{
 		const XmmLink& vt = XmmGet(op.rt, XmmType::Int);
 		c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
-		c->movdqa(asmjit::x86::oword_ptr(*ls, *addr), vt);
+		c->movdqa(asmjit::x86::oword_ptr(*ls, addr->r64()), vt);
 	}
 	else
 	{
@@ -1385,45 +1772,36 @@ void spu_recompiler::STQX(spu_opcode_t op)
 		c->mov(*qw1, SPU_OFF_64(gpr, op.rt, &v128::_u64, 1));
 		c->bswap(*qw0);
 		c->bswap(*qw1);
-		c->mov(asmjit::x86::qword_ptr(*ls, *addr, 0, 0), *qw1);
-		c->mov(asmjit::x86::qword_ptr(*ls, *addr, 0, 8), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
+		c->mov(asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 0), *qw1);
+		c->mov(asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 8), *qw0);
 	}
-
-	c->unuse(*addr);
 }
 
 void spu_recompiler::BI(spu_opcode_t op)
 {
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0x3fffc);
-	CheckInterruptStatus(op);
-	c->jmp(*jt);
+	branch_indirect(op);
+	m_pos = -1;
 }
 
 void spu_recompiler::BISL(spu_opcode_t op)
 {
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0x3fffc);
-	if (op.d || op.e) c->or_(*addr, op.e << 26 | op.d << 27); // interrupt flags stored to PC
-	c->mov(SPU_OFF_32(pc), *addr);
-	c->unuse(*addr);
-
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(spu_branch_target(m_pos + 4), 0, 0, 0)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->unuse(vr);
-
-	FunctionCall();
+	branch_indirect(op);
+	m_pos = -1;
 }
 
 void spu_recompiler::IRET(spu_opcode_t op)
 {
 	c->mov(*addr, SPU_OFF_32(srr0));
 	c->and_(*addr, 0x3fffc);
-	CheckInterruptStatus(op);
-	c->jmp(*jt);
+	branch_indirect(op);
+	m_pos = -1;
 }
 
 void spu_recompiler::BISLED(spu_opcode_t op)
@@ -1443,7 +1821,6 @@ void spu_recompiler::GB(spu_opcode_t op)
 	c->pxor(va, va);
 	c->pinsrw(va, *addr, 6);
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
 }
 
 void spu_recompiler::GBH(spu_opcode_t op)
@@ -1455,7 +1832,6 @@ void spu_recompiler::GBH(spu_opcode_t op)
 	c->pxor(va, va);
 	c->pinsrw(va, *addr, 6);
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
 }
 
 void spu_recompiler::GBB(spu_opcode_t op)
@@ -1466,7 +1842,6 @@ void spu_recompiler::GBB(spu_opcode_t op)
 	c->pxor(va, va);
 	c->pinsrw(va, *addr, 6);
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
 }
 
 void spu_recompiler::FSM(spu_opcode_t op)
@@ -1476,10 +1851,8 @@ void spu_recompiler::FSM(spu_opcode_t op)
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0xf);
 	c->shl(*addr, 4);
-	c->movdqa(vr, asmjit::x86::oword_ptr(*qw0, *addr));
+	c->movdqa(vr, asmjit::x86::oword_ptr(*qw0, addr->r64()));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::FSMH(spu_opcode_t op)
@@ -1489,10 +1862,8 @@ void spu_recompiler::FSMH(spu_opcode_t op)
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0xff);
 	c->shl(*addr, 4);
-	c->movdqa(vr, asmjit::x86::oword_ptr(*qw0, *addr));
+	c->movdqa(vr, asmjit::x86::oword_ptr(*qw0, addr->r64()));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::FSMB(spu_opcode_t op)
@@ -1502,10 +1873,8 @@ void spu_recompiler::FSMB(spu_opcode_t op)
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0xffff);
 	c->shl(*addr, 4);
-	c->movdqa(vr, asmjit::x86::oword_ptr(*qw0, *addr));
+	c->movdqa(vr, asmjit::x86::oword_ptr(*qw0, addr->r64()));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::FREST(spu_opcode_t op)
@@ -1532,116 +1901,64 @@ void spu_recompiler::LQX(spu_opcode_t op)
 	if (utils::has_ssse3())
 	{
 		const XmmLink& vt = XmmAlloc();
-		c->movdqa(vt, asmjit::x86::oword_ptr(*ls, *addr));
+		c->movdqa(vt, asmjit::x86::oword_ptr(*ls, addr->r64()));
 		c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
 		c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 	}
 	else
 	{
-		c->mov(*qw0, asmjit::x86::qword_ptr(*ls, *addr, 0, 0));
-		c->mov(*qw1, asmjit::x86::qword_ptr(*ls, *addr, 0, 8));
+		c->mov(*qw0, asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 0));
+		c->mov(*qw1, asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 8));
 		c->bswap(*qw0);
 		c->bswap(*qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
 	}
-
-	c->unuse(*addr);
 }
 
 void spu_recompiler::ROTQBYBI(spu_opcode_t op)
 {
-	auto body = [](u8* t, const u8* _a, u32 v) noexcept
-	{
-		const auto a = *(__m128i*)_a;
-		alignas(32) const __m128i buf[2]{a, a};
-		*(__m128i*)t = _mm_loadu_si128((__m128i*)((u8*)buf + (16 - (v >> 3 & 0xf))));
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, u32)>(body)), asmjit::FuncSignature3<void, void*, void*, u32>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *addr);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.rldq_pshufb));
 	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0xf << 3);
-	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, *addr, 1));
+	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::ROTQMBYBI(spu_opcode_t op)
 {
-	auto body = [](u8* t, const u8* _a, u32 v) noexcept
-	{
-		const auto a = *(__m128i*)_a;
-		alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()};
-		*(__m128i*)t = _mm_loadu_si128((__m128i*)((u8*)buf + ((0 - (v >> 3)) & 0x1f)));
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, u32)>(body)), asmjit::FuncSignature3<void, void*, void*, u32>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *addr);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.srdq_pshufb));
 	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x1f << 3);
-	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, *addr, 1));
+	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::SHLQBYBI(spu_opcode_t op)
 {
-	auto body = [](u8* t, const u8* _a, u32 v) noexcept
-	{
-		const auto a = *(__m128i*)_a;
-		alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a};
-		*(__m128i*)t = _mm_loadu_si128((__m128i*)((u8*)buf + (32 - (v >> 3 & 0x1f))));
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, u32)>(body)), asmjit::FuncSignature3<void, void*, void*, u32>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *addr);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.sldq_pshufb));
 	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x1f << 3);
-	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, *addr, 1));
+	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::CBX(spu_opcode_t op)
@@ -1654,8 +1971,7 @@ void spu_recompiler::CBX(spu_opcode_t op)
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->mov(asmjit::x86::byte_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x03);
-	c->unuse(*addr);
+	c->mov(asmjit::x86::byte_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), 0x03);
 }
 
 void spu_recompiler::CHX(spu_opcode_t op)
@@ -1668,8 +1984,7 @@ void spu_recompiler::CHX(spu_opcode_t op)
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->mov(asmjit::x86::word_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x0203);
-	c->unuse(*addr);
+	c->mov(asmjit::x86::word_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), 0x0203);
 }
 
 void spu_recompiler::CWX(spu_opcode_t op)
@@ -1682,8 +1997,7 @@ void spu_recompiler::CWX(spu_opcode_t op)
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->mov(asmjit::x86::dword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x00010203);
-	c->unuse(*addr);
+	c->mov(asmjit::x86::dword_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), 0x00010203);
 }
 
 void spu_recompiler::CDX(spu_opcode_t op)
@@ -1697,9 +2011,7 @@ void spu_recompiler::CDX(spu_opcode_t op)
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->mov(*qw0, asmjit::imm_u(0x0001020304050607));
-	c->mov(asmjit::x86::qword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), *qw0);
-	c->unuse(*addr);
-	c->unuse(*qw0);
+	c->mov(asmjit::x86::qword_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), *qw0);
 }
 
 void spu_recompiler::ROTQBI(spu_opcode_t op)
@@ -1759,23 +2071,9 @@ void spu_recompiler::SHLQBI(spu_opcode_t op)
 
 void spu_recompiler::ROTQBY(spu_opcode_t op)
 {
-	auto body = [](u8* t, const u8* _a, u32 v) noexcept
-	{
-		const auto a = *(__m128i*)_a;
-		alignas(32) const __m128i buf[2]{a, a};
-		*(__m128i*)t = _mm_loadu_si128((__m128i*)((u8*)buf + (16 - (v & 0xf))));
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, u32)>(body)), asmjit::FuncSignature3<void, void*, void*, u32>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *addr);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
@@ -1783,31 +2081,15 @@ void spu_recompiler::ROTQBY(spu_opcode_t op)
 	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0xf);
 	c->shl(*addr, 4);
-	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, *addr));
+	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64()));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::ROTQMBY(spu_opcode_t op)
 {
-	auto body = [](u8* t, const u8* _a, u32 v) noexcept
-	{
-		const auto a = *(__m128i*)_a;
-		alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()};
-		*(__m128i*)t = _mm_loadu_si128((__m128i*)((u8*)buf + ((0 - v) & 0x1f)));
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, u32)>(body)), asmjit::FuncSignature3<void, void*, void*, u32>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *addr);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
@@ -1815,31 +2097,15 @@ void spu_recompiler::ROTQMBY(spu_opcode_t op)
 	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x1f);
 	c->shl(*addr, 4);
-	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, *addr));
+	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64()));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::SHLQBY(spu_opcode_t op)
 {
-	auto body = [](u8* t, const u8* _a, u32 v) noexcept
-	{
-		const auto a = *(__m128i*)_a;
-		alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a};
-		*(__m128i*)t = _mm_loadu_si128((__m128i*)((u8*)buf + (32 - (v & 0x1f))));
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, u32)>(body)), asmjit::FuncSignature3<void, void*, void*, u32>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *addr);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
@@ -1847,10 +2113,8 @@ void spu_recompiler::SHLQBY(spu_opcode_t op)
 	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x1f);
 	c->shl(*addr, 4);
-	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, *addr));
+	c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64()));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
-	c->unuse(*addr);
-	c->unuse(*qw0);
 }
 
 void spu_recompiler::ORX(spu_opcode_t op)
@@ -1886,8 +2150,7 @@ void spu_recompiler::CBD(spu_opcode_t op)
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->mov(asmjit::x86::byte_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x03);
-	c->unuse(*addr);
+	c->mov(asmjit::x86::byte_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), 0x03);
 }
 
 void spu_recompiler::CHD(spu_opcode_t op)
@@ -1911,8 +2174,7 @@ void spu_recompiler::CHD(spu_opcode_t op)
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->mov(asmjit::x86::word_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x0203);
-	c->unuse(*addr);
+	c->mov(asmjit::x86::word_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), 0x0203);
 }
 
 void spu_recompiler::CWD(spu_opcode_t op)
@@ -1936,8 +2198,7 @@ void spu_recompiler::CWD(spu_opcode_t op)
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->mov(asmjit::x86::dword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x00010203);
-	c->unuse(*addr);
+	c->mov(asmjit::x86::dword_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), 0x00010203);
 }
 
 void spu_recompiler::CDD(spu_opcode_t op)
@@ -1962,9 +2223,7 @@ void spu_recompiler::CDD(spu_opcode_t op)
 	c->movdqa(vr, XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->mov(*qw0, asmjit::imm_u(0x0001020304050607));
-	c->mov(asmjit::x86::qword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), *qw0);
-	c->unuse(*addr);
-	c->unuse(*qw0);
+	c->mov(asmjit::x86::qword_ptr(*cpu, addr->r64(), 0, offset32(&SPUThread::gpr, op.rt)), *qw0);
 }
 
 void spu_recompiler::ROTQBII(spu_opcode_t op)
@@ -2126,10 +2385,7 @@ void spu_recompiler::HGT(spu_opcode_t op)
 {
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_s32, 3));
 	c->cmp(*addr, SPU_OFF_32(gpr, op.rb, &v128::_s32, 3));
-
-	c->mov(*addr, m_pos | 0x1000000);
-	c->jg(*end);
-	c->unuse(*addr);
+	c->jg(halt(m_pos));
 }
 
 void spu_recompiler::CLZ(spu_opcode_t op)
@@ -2143,28 +2399,14 @@ void spu_recompiler::CLZ(spu_opcode_t op)
 		return;
 	}
 
-	auto body = [](u32* t, const u32* a) noexcept
+	c->mov(qw0->r32(), 32 + 31);
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (u32 i = 0; i < 4; i++)
-		{
-			t[i] = cntlz32(a[i]);
-		}
-	};
-
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u32*, const u32*)>(body)), asmjit::FuncSignature2<void, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-
-	//c->mov(*qw0, 32 + 31);
-	//for (u32 i = 0; i < 4; i++) // unrolled loop
-	//{
-	//	c->bsr(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
-	//	c->cmovz(*addr, qw0->r32());
-	//	c->xor_(*addr, 31);
-	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), *addr);
-	//}
+		c->bsr(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->cmovz(*addr, qw0->r32());
+		c->xor_(*addr, 31);
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), *addr);
+	}
 }
 
 void spu_recompiler::XSWD(spu_opcode_t op)
@@ -2173,8 +2415,6 @@ void spu_recompiler::XSWD(spu_opcode_t op)
 	c->movsxd(*qw1, SPU_OFF_32(gpr, op.ra, &v128::_s32, 2));
 	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_s64, 0), *qw0);
 	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_s64, 1), *qw1);
-	c->unuse(*qw0);
-	c->unuse(*qw1);
 }
 
 void spu_recompiler::XSHW(spu_opcode_t op)
@@ -2480,10 +2720,7 @@ void spu_recompiler::HLGT(spu_opcode_t op)
 {
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->cmp(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
-
-	c->mov(*addr, m_pos | 0x1000000);
-	c->ja(*end);
-	c->unuse(*addr);
+	c->ja(halt(m_pos));
 }
 
 void spu_recompiler::DFMA(spu_opcode_t op)
@@ -2566,41 +2803,29 @@ void spu_recompiler::SFX(spu_opcode_t op)
 
 void spu_recompiler::CGX(spu_opcode_t op) //nf
 {
-	auto body = [](u32* t, const u32* a, const u32* b) noexcept
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (s32 i = 0; i < 4; i++)
-		{
-			t[i] = (static_cast<u64>(t[i] & 1) + a[i] + b[i]) >> 32;
-		}
-	};
-
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
+		c->bt(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), 0);
+		c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->adc(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
+		c->setc(addr->r8());
+		c->movzx(*addr, addr->r8());
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), *addr);
+	}
 }
 
 void spu_recompiler::BGX(spu_opcode_t op) //nf
 {
-	auto body = [](u32* t, const u32* a, const u32* b) noexcept
+	for (u32 i = 0; i < 4; i++) // unrolled loop
 	{
-		for (s32 i = 0; i < 4; i++)
-		{
-			const s64 result = (u64)b[i] - (u64)a[i] - (u64)(1 - (t[i] & 1));
-			t[i] = result >= 0;
-		}
-	};
-
-	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
-	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-	c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-	asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::FuncSignature3<void, void*, void*, void*>(asmjit::CallConv::kIdHost));
-	call->setArg(0, *qw0);
-	call->setArg(1, *qw1);
-	call->setArg(2, *qw2);
+		c->bt(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), 0);
+		c->cmc();
+		c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, i));
+		c->sbb(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, i));
+		c->setnc(addr->r8());
+		c->movzx(*addr, addr->r8());
+		c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), *addr);
+	}
 }
 
 void spu_recompiler::MPYHHA(spu_opcode_t op)
@@ -2775,10 +3000,7 @@ void spu_recompiler::HEQ(spu_opcode_t op)
 {
 	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_s32, 3));
 	c->cmp(*addr, SPU_OFF_32(gpr, op.rb, &v128::_s32, 3));
-
-	c->mov(*addr, m_pos | 0x1000000);
-	c->je(*end);
-	c->unuse(*addr);
+	c->je(halt(m_pos));
 }
 
 void spu_recompiler::CFLTS(spu_opcode_t op)
@@ -2862,25 +3084,21 @@ void spu_recompiler::BRZ(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(m_pos, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
+	if (target == m_pos + 4)
+	{
+		return;
+	}
 
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
+	c->je(branch_label);
 
-	if (labels[target / 4].isValid())
+	after.emplace_back([=]
 	{
-		c->je(labels[target / 4]);
-	}
-	else
-	{
-		if (target >= m_func->addr && target < m_func->addr + m_func->size)
-		{
-			LOG_ERROR(SPU, "Local block not registered (brz 0x%x)", target);
-		}
-
-		c->mov(*addr, target);
-		c->je(*end);
-		c->unuse(*addr);
-	}
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		branch_fixed(target);
+	});
 }
 
 void spu_recompiler::STQA(spu_opcode_t op)
@@ -2899,8 +3117,6 @@ void spu_recompiler::STQA(spu_opcode_t op)
 		c->bswap(*qw1);
 		c->mov(asmjit::x86::qword_ptr(*ls, spu_ls_target(0, op.i16) + 0), *qw1);
 		c->mov(asmjit::x86::qword_ptr(*ls, spu_ls_target(0, op.i16) + 8), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
 	}
 }
 
@@ -2908,75 +3124,63 @@ void spu_recompiler::BRNZ(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(m_pos, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
+	if (target == m_pos + 4)
+	{
+		return;
+	}
 
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
+	c->jne(branch_label);
 
-	if (labels[target / 4].isValid())
+	after.emplace_back([=]
 	{
-		c->jne(labels[target / 4]);
-	}
-	else
-	{
-		if (target >= m_func->addr && target < m_func->addr + m_func->size)
-		{
-			LOG_ERROR(SPU, "Local block not registered (brnz 0x%x)", target);
-		}
-
-		c->mov(*addr, target);
-		c->jne(*end);
-		c->unuse(*addr);
-	}
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		branch_fixed(target);
+	});
 }
 
 void spu_recompiler::BRHZ(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(m_pos, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
+	if (target == m_pos + 4)
+	{
+		return;
+	}
 
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
+	c->je(branch_label);
 
-	if (labels[target / 4].isValid())
+	after.emplace_back([=]
 	{
-		c->je(labels[target / 4]);
-	}
-	else
-	{
-		if (target >= m_func->addr && target < m_func->addr + m_func->size)
-		{
-			LOG_ERROR(SPU, "Local block not registered (brhz 0x%x)", target);
-		}
-
-		c->mov(*addr, target);
-		c->je(*end);
-		c->unuse(*addr);
-	}
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		branch_fixed(target);
+	});
 }
 
 void spu_recompiler::BRHNZ(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(m_pos, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
+	if (target == m_pos + 4)
+	{
+		return;
+	}
 
+	asmjit::Label branch_label = c->newLabel();
 	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
+	c->jne(branch_label);
 
-	if (labels[target / 4].isValid())
+	after.emplace_back([=]
 	{
-		c->jne(labels[target / 4]);
-	}
-	else
-	{
-		if (target >= m_func->addr && target < m_func->addr + m_func->size)
-		{
-			LOG_ERROR(SPU, "Local block not registered (brhnz 0x%x)", target);
-		}
-
-		c->mov(*addr, target);
-		c->jne(*end);
-		c->unuse(*addr);
-	}
+		c->align(asmjit::kAlignCode, 16);
+		c->bind(branch_label);
+		branch_fixed(target);
+	});
 }
 
 void spu_recompiler::STQR(spu_opcode_t op)
@@ -2995,8 +3199,6 @@ void spu_recompiler::STQR(spu_opcode_t op)
 		c->bswap(*qw1);
 		c->mov(asmjit::x86::qword_ptr(*ls, spu_ls_target(m_pos, op.i16) + 0), *qw1);
 		c->mov(asmjit::x86::qword_ptr(*ls, spu_ls_target(m_pos, op.i16) + 8), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
 	}
 }
 
@@ -3004,22 +3206,10 @@ void spu_recompiler::BRA(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(0, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
-
-	if (labels[target / 4].isValid())
+	if (target != m_pos + 4)
 	{
-		c->jmp(labels[target / 4]);
-	}
-	else
-	{
-		if (target >= m_func->addr && target < m_func->addr + m_func->size)
-		{
-			LOG_ERROR(SPU, "Local block not registered (bra 0x%x)", target);
-		}
-
-		c->mov(*addr, target);
-		c->jmp(*end);
-		c->unuse(*addr);
+		branch_fixed(target);
+		m_pos = -1;
 	}
 }
 
@@ -3040,8 +3230,6 @@ void spu_recompiler::LQA(spu_opcode_t op)
 		c->bswap(*qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
 	}
 }
 
@@ -3049,47 +3237,25 @@ void spu_recompiler::BRASL(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(0, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
-
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(spu_branch_target(m_pos + 4), 0, 0, 0)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->unuse(vr);
 
-	c->mov(SPU_OFF_32(pc), target);
-
-	FunctionCall();
+	if (target != m_pos + 4)
+	{
+		branch_fixed(target);
+		m_pos = -1;
+	}
 }
 
 void spu_recompiler::BR(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(m_pos, op.i16);
 
-	if (target == m_pos)
+	if (target != m_pos + 4)
 	{
-		c->mov(*addr, target | 0x2000000);
-		//c->cmp(asmjit::x86::dword_ptr(*ls, m_pos), 0x32); // compare instruction opcode with BR-to-self
-		//c->je(labels[target / 4]);
-		c->lock().or_(SPU_OFF_32(state), static_cast<u32>(cpu_flag::stop + cpu_flag::ret));
-		c->jmp(*end);
-		c->unuse(*addr);
-		return;
-	}
-
-	if (labels[target / 4].isValid())
-	{
-		c->jmp(labels[target / 4]);
-	}
-	else
-	{
-		if (target >= m_func->addr && target < m_func->addr + m_func->size)
-		{
-			LOG_ERROR(SPU, "Local block not registered (brz 0x%x)", target);
-		}
-
-		c->mov(*addr, target);
-		c->jmp(*end);
-		c->unuse(*addr);
+		branch_fixed(target);
+		m_pos = -1;
 	}
 }
 
@@ -3104,22 +3270,15 @@ void spu_recompiler::BRSL(spu_opcode_t op)
 {
 	const u32 target = spu_branch_target(m_pos, op.i16);
 
-	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
-
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set_epi32(spu_branch_target(m_pos + 4), 0, 0, 0)));
 	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
-	c->unuse(vr);
 
-	if (target == spu_branch_target(m_pos + 4))
+	if (target != m_pos + 4)
 	{
-		// branch-to-next
-		return;
+		branch_fixed(target);
+		m_pos = -1;
 	}
-
-	c->mov(SPU_OFF_32(pc), target);
-
-	FunctionCall();
 }
 
 void spu_recompiler::LQR(spu_opcode_t op)
@@ -3139,8 +3298,6 @@ void spu_recompiler::LQR(spu_opcode_t op)
 		c->bswap(*qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
 	}
 }
 
@@ -3256,7 +3413,7 @@ void spu_recompiler::STQD(spu_opcode_t op)
 	{
 		const XmmLink& vt = XmmGet(op.rt, XmmType::Int);
 		c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
-		c->movdqa(asmjit::x86::oword_ptr(*ls, *addr), vt);
+		c->movdqa(asmjit::x86::oword_ptr(*ls, addr->r64()), vt);
 	}
 	else
 	{
@@ -3264,13 +3421,9 @@ void spu_recompiler::STQD(spu_opcode_t op)
 		c->mov(*qw1, SPU_OFF_64(gpr, op.rt, &v128::_u64, 1));
 		c->bswap(*qw0);
 		c->bswap(*qw1);
-		c->mov(asmjit::x86::qword_ptr(*ls, *addr, 0, 0), *qw1);
-		c->mov(asmjit::x86::qword_ptr(*ls, *addr, 0, 8), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
+		c->mov(asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 0), *qw1);
+		c->mov(asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 8), *qw0);
 	}
-
-	c->unuse(*addr);
 }
 
 void spu_recompiler::LQD(spu_opcode_t op)
@@ -3282,23 +3435,19 @@ void spu_recompiler::LQD(spu_opcode_t op)
 	if (utils::has_ssse3())
 	{
 		const XmmLink& vt = XmmAlloc();
-		c->movdqa(vt, asmjit::x86::oword_ptr(*ls, *addr));
+		c->movdqa(vt, asmjit::x86::oword_ptr(*ls, addr->r64()));
 		c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
 		c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 	}
 	else
 	{
-		c->mov(*qw0, asmjit::x86::qword_ptr(*ls, *addr, 0, 0));
-		c->mov(*qw1, asmjit::x86::qword_ptr(*ls, *addr, 0, 8));
+		c->mov(*qw0, asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 0));
+		c->mov(*qw1, asmjit::x86::qword_ptr(*ls, addr->r64(), 0, 8));
 		c->bswap(*qw0);
 		c->bswap(*qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw1);
 		c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw0);
-		c->unuse(*qw0);
-		c->unuse(*qw1);
 	}
-
-	c->unuse(*addr);
 }
 
 void spu_recompiler::XORI(spu_opcode_t op)
@@ -3345,12 +3494,8 @@ void spu_recompiler::CGTBI(spu_opcode_t op)
 
 void spu_recompiler::HGTI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_s32, 3));
-	c->cmp(*addr, op.si10);
-
-	c->mov(*addr, m_pos | 0x1000000);
-	c->jg(*end);
-	c->unuse(*addr);
+	c->cmp(SPU_OFF_32(gpr, op.ra, &v128::_s32, 3), op.si10);
+	c->jg(halt(m_pos));
 }
 
 void spu_recompiler::CLGTI(spu_opcode_t op)
@@ -3379,12 +3524,8 @@ void spu_recompiler::CLGTBI(spu_opcode_t op)
 
 void spu_recompiler::HLGTI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
-	c->cmp(*addr, op.si10);
-
-	c->mov(*addr, m_pos | 0x1000000);
-	c->ja(*end);
-	c->unuse(*addr);
+	c->cmp(SPU_OFF_32(gpr, op.ra, &v128::_u32, 3), op.si10);
+	c->ja(halt(m_pos));
 }
 
 void spu_recompiler::MPYI(spu_opcode_t op)
@@ -3431,12 +3572,8 @@ void spu_recompiler::CEQBI(spu_opcode_t op)
 
 void spu_recompiler::HEQI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
-	c->cmp(*addr, op.si10);
-
-	c->mov(*addr, m_pos | 0x1000000);
-	c->je(*end);
-	c->unuse(*addr);
+	c->cmp(SPU_OFF_32(gpr, op.ra, &v128::_u32, 3), op.si10);
+	c->je(halt(m_pos));
 }
 
 void spu_recompiler::HBRA(spu_opcode_t op)
@@ -3505,59 +3642,9 @@ void spu_recompiler::SHUFB(spu_opcode_t op)
 		return;
 	}
 
-	alignas(16) static thread_local u8 s_lut[256]
-	{
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-		0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-		0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-	};
-
-	auto body = [](u8* t, const u8* a, const u8* b, const u8* c) noexcept
-	{
-		__m128i _a = *(__m128i*)a;
-		__m128i _b = *(__m128i*)b;
-		_mm_store_si128((__m128i*)(s_lut + 0x00), _a);
-		_mm_store_si128((__m128i*)(s_lut + 0x10), _b);
-		_mm_store_si128((__m128i*)(s_lut + 0x20), _a);
-		_mm_store_si128((__m128i*)(s_lut + 0x30), _b);
-		_mm_store_si128((__m128i*)(s_lut + 0x40), _a);
-		_mm_store_si128((__m128i*)(s_lut + 0x50), _b);
-		_mm_store_si128((__m128i*)(s_lut + 0x60), _a);
-		_mm_store_si128((__m128i*)(s_lut + 0x70), _b);
-		v128 mask = v128::fromV(_mm_xor_si128(*(__m128i*)c, _mm_set1_epi8(0xf)));
-
-		for (int i = 0; i < 16; i++)
-		{
-			t[i] = s_lut[mask._u8[i]];
-		}
-	};
-
 	if (!utils::has_ssse3())
 	{
-		c->lea(*qw0, SPU_OFF_128(gpr, op.rt4));
-		c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
-		c->lea(*qw2, SPU_OFF_128(gpr, op.rb));
-		c->lea(*qw3, SPU_OFF_128(gpr, op.rc));
-		asmjit::CCFuncCall* call = c->call(asmjit::imm_ptr(asmjit::Internal::ptr_cast<void*, void(u8*, const u8*, const u8*, const u8*)>(body)), asmjit::FuncSignature4<void, void*, void*, void*, void*>(asmjit::CallConv::kIdHost));
-		call->setArg(0, *qw0);
-		call->setArg(1, *qw1);
-		call->setArg(2, *qw2);
-		call->setArg(3, *qw3);
-		return;
+		return fall(op);
 	}
 
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
@@ -3627,67 +3714,67 @@ void spu_recompiler::MPYA(spu_opcode_t op)
 
 void spu_recompiler::FNMS(spu_opcode_t op)
 {
-	const XmmLink& vc = XmmGet(op.rc, XmmType::Float);
-	const auto mask = XmmConst(_mm_set1_epi32(0x7f800000));
-	const XmmLink& tmp_a = XmmAlloc();
-	const XmmLink& tmp_b = XmmAlloc();
+	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
+	const XmmLink& vb = XmmGet(op.rb, XmmType::Float);
+	const XmmLink& mask = XmmAlloc();
+	const XmmLink& v1 = XmmAlloc();
+	const XmmLink& v2 = XmmAlloc();
+	c->movaps(mask, XmmConst(_mm_set1_epi32(0x7f800000)));
+	c->movaps(v1, va);
+	c->movaps(v2, vb);
+	c->andps(va, mask);
+	c->andps(vb, mask);
+	c->cmpps(va, mask, 4); // va = ra == extended
+	c->cmpps(vb, mask, 4); // vb = rb == extended
+	c->andps(va, v1); // va = ra & ~ra_extended
+	c->andps(vb, v2); // vb = rb & ~rb_extended
 
-	c->movaps(tmp_a, SPU_OFF_128(gpr, op.ra));
-	c->movaps(tmp_b, SPU_OFF_128(gpr, op.rb));
-	c->andps(tmp_a, mask);
-	c->andps(tmp_b, mask);
-	c->cmpps(tmp_a, mask, 4);                 //tmp_a = ra == extended
-	c->cmpps(tmp_b, mask, 4);                 //tmp_b = rb == extended
-	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra)); //tmp_a = mask_a & ~ra_extended
-	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb)); //tmp_b = mask_b & ~rb_extended
-
-	c->mulps(tmp_a, tmp_b);
-	c->subps(vc, tmp_a);
-	c->movaps(SPU_OFF_128(gpr, op.rt4), vc);
+	c->mulps(va, vb);
+	c->movaps(vb, SPU_OFF_128(gpr, op.rc));
+	c->subps(vb, va);
+	c->movaps(SPU_OFF_128(gpr, op.rt4), vb);
 }
 
 void spu_recompiler::FMA(spu_opcode_t op)
 {
-	const auto mask = XmmConst(_mm_set1_epi32(0x7f800000));
-	const XmmLink& tmp_a = XmmAlloc();
-	const XmmLink& tmp_b = XmmAlloc();
+	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
+	const XmmLink& vb = XmmGet(op.rb, XmmType::Float);
+	const XmmLink& mask = XmmAlloc();
+	const XmmLink& v1 = XmmAlloc();
+	const XmmLink& v2 = XmmAlloc();
+	c->movaps(mask, XmmConst(_mm_set1_epi32(0x7f800000)));
+	c->movaps(v1, va);
+	c->movaps(v2, vb);
+	c->andps(va, mask);
+	c->andps(vb, mask);
+	c->cmpps(va, mask, 4); // va = ra == extended
+	c->cmpps(vb, mask, 4); // vb = rb == extended
+	c->andps(va, v1); // va = ra & ~ra_extended
+	c->andps(vb, v2); // vb = rb & ~rb_extended
 
-	c->movaps(tmp_a, SPU_OFF_128(gpr, op.ra));
-	c->movaps(tmp_b, SPU_OFF_128(gpr, op.rb));
-	c->andps(tmp_a, mask);
-	c->andps(tmp_b, mask);
-	c->cmpps(tmp_a, mask, 4);                 //tmp_a = ra == extended
-	c->cmpps(tmp_b, mask, 4);                 //tmp_b = rb == extended
-	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra)); //tmp_a = mask_a & ~ra_extended
-	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb)); //tmp_b = mask_b & ~rb_extended
-
-	c->mulps(tmp_a, tmp_b);
-	c->addps(tmp_a, SPU_OFF_128(gpr, op.rc));
-	c->movaps(SPU_OFF_128(gpr, op.rt4), tmp_a);
+	c->mulps(va, vb);
+	c->addps(va, SPU_OFF_128(gpr, op.rc));
+	c->movaps(SPU_OFF_128(gpr, op.rt4), va);
 }
 
 void spu_recompiler::FMS(spu_opcode_t op)
 {
-	const auto mask = XmmConst(_mm_set1_epi32(0x7f800000));
-	const XmmLink& tmp_a = XmmAlloc();
-	const XmmLink& tmp_b = XmmAlloc();
+	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
+	const XmmLink& vb = XmmGet(op.rb, XmmType::Float);
+	const XmmLink& mask = XmmAlloc();
+	const XmmLink& v1 = XmmAlloc();
+	const XmmLink& v2 = XmmAlloc();
+	c->movaps(mask, XmmConst(_mm_set1_epi32(0x7f800000)));
+	c->movaps(v1, va);
+	c->movaps(v2, vb);
+	c->andps(va, mask);
+	c->andps(vb, mask);
+	c->cmpps(va, mask, 4); // va = ra == extended
+	c->cmpps(vb, mask, 4); // vb = rb == extended
+	c->andps(va, v1); // va = ra & ~ra_extended
+	c->andps(vb, v2); // vb = rb & ~rb_extended
 
-	c->movaps(tmp_a, SPU_OFF_128(gpr, op.ra));
-	c->movaps(tmp_b, SPU_OFF_128(gpr, op.rb));
-	c->andps(tmp_a, mask);
-	c->andps(tmp_b, mask);
-	c->cmpps(tmp_a, mask, 4);                 //tmp_a = ra == extended
-	c->cmpps(tmp_b, mask, 4);                 //tmp_b = rb == extended
-	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra)); //tmp_a = mask_a & ~ra_extended
-	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb)); //tmp_b = mask_b & ~rb_extended
-
-	c->mulps(tmp_a, tmp_b);
-	c->subps(tmp_a, SPU_OFF_128(gpr, op.rc));
-	c->movaps(SPU_OFF_128(gpr, op.rt4), tmp_a);
-}
-
-void spu_recompiler::UNK(spu_opcode_t op)
-{
-	LOG_ERROR(SPU, "0x%05x: Unknown/Illegal opcode (0x%08x)", m_pos, op.opcode);
-	c->int3();
+	c->mulps(va, vb);
+	c->subps(va, SPU_OFF_128(gpr, op.rc));
+	c->movaps(SPU_OFF_128(gpr, op.rt4), va);
 }
diff --git a/rpcs3/Emu/Cell/SPUASMJITRecompiler.h b/rpcs3/Emu/Cell/SPUASMJITRecompiler.h
index d79d5c1360..330dac9798 100644
--- a/rpcs3/Emu/Cell/SPUASMJITRecompiler.h
+++ b/rpcs3/Emu/Cell/SPUASMJITRecompiler.h
@@ -1,56 +1,73 @@
 #pragma once
 
+#include "Utilities/mutex.h"
 #include "SPURecompiler.h"
 
-namespace asmjit
+#include <functional>
+
+#define ASMJIT_STATIC
+#define ASMJIT_DEBUG
+
+#include "asmjit.h"
+
+// SPU ASMJIT Runtime object (global)
+class spu_runtime
 {
-	struct JitRuntime;
-	struct CodeHolder;
-	struct X86Compiler;
-	struct X86Gp;
-	struct X86Xmm;
-	struct X86Mem;
-	struct Label;
-}
+	shared_mutex m_mutex;
+
+	asmjit::JitRuntime m_jitrt;
+
+	// All functions
+	std::map<std::vector<u32>, spu_function_t> m_map;
+
+	// TODO
+	std::array<atomic_t<spu_function_t>, 0x10000> m_dispatcher;
+
+	friend class spu_recompiler;
+
+public:
+	spu_runtime();
+};
 
 // SPU ASMJIT Recompiler
 class spu_recompiler : public spu_recompiler_base
 {
-	const std::shared_ptr<asmjit::JitRuntime> m_jit;
+	const std::shared_ptr<asmjit::JitRuntime> m_rt;
+
+	std::shared_ptr<spu_runtime> m_spurt;
 
 public:
-	spu_recompiler();
+	spu_recompiler(class SPUThread& spu);
 
-	virtual void compile(spu_function_t& f) override;
+	virtual spu_function_t compile(const std::vector<u32>& func) override;
 
 private:
 	// emitter:
-	asmjit::X86Compiler* c;
-	asmjit::CodeHolder* codeHolder;
+	asmjit::X86Assembler* c;
 
-	// input:
-	asmjit::X86Gp* cpu;
-	asmjit::X86Gp* ls;
+	// arguments:
+	const asmjit::X86Gp* cpu;
+	const asmjit::X86Gp* ls;
+	const asmjit::X86Gp* qw0;
+	const asmjit::X86Gp* qw1;
 
 	// temporary:
-	asmjit::X86Gp* addr;
-	asmjit::X86Gp* qw0;
-	asmjit::X86Gp* qw1;
-	asmjit::X86Gp* qw2;
-	asmjit::X86Gp* qw3;
-	std::array<asmjit::X86Xmm*, 6> vec;
+	const asmjit::X86Gp* addr;
+	std::array<const asmjit::X86Xmm*, 6> vec;
 
-	// labels:
-	asmjit::Label* labels; // array[0x10000]
-	asmjit::Label* jt; // jump table resolver (uses *addr)
-	asmjit::Label* end; // function end (return *addr)
+	// workload for the end of function:
+	std::vector<std::function<void()>> after;
+	std::vector<std::function<void()>> consts;
+
+	// All emitted 128-bit consts
+	std::map<std::pair<u64, u64>, asmjit::Label> xmm_consts;
 
 	class XmmLink
 	{
-		asmjit::X86Xmm* m_var;
+		const asmjit::X86Xmm* m_var;
 
 	public:
-		XmmLink(asmjit::X86Xmm*& xmm_var)
+		XmmLink(const asmjit::X86Xmm*& xmm_var)
 			: m_var(xmm_var)
 		{
 			xmm_var = nullptr;
@@ -58,7 +75,7 @@ private:
 
 		XmmLink(XmmLink&&) = default; // MoveConstructible + delete copy constructor and copy/move operators
 
-		operator asmjit::X86Xmm&() const
+		operator const asmjit::X86Xmm&() const
 		{
 			return *m_var;
 		}
@@ -78,10 +95,15 @@ private:
 	asmjit::X86Mem XmmConst(__m128 data);
 	asmjit::X86Mem XmmConst(__m128i data);
 
+	void branch_fixed(u32 target);
+	void branch_indirect(spu_opcode_t op);
+	asmjit::Label halt(u32 pos);
+	void fall(spu_opcode_t op);
+	void save_rcx();
+	void load_rcx();
+
 public:
-	void CheckInterruptStatus(spu_opcode_t op);
-	void InterpreterCall(spu_opcode_t op);
-	void FunctionCall();
+	void UNK(spu_opcode_t op);
 
 	void STOP(spu_opcode_t op);
 	void LNOP(spu_opcode_t op);
@@ -282,6 +304,4 @@ public:
 	void FNMS(spu_opcode_t op);
 	void FMA(spu_opcode_t op);
 	void FMS(spu_opcode_t op);
-
-	void UNK(spu_opcode_t op);
 };
diff --git a/rpcs3/Emu/Cell/SPUAnalyser.cpp b/rpcs3/Emu/Cell/SPUAnalyser.cpp
index 61d24593d1..c594383469 100644
--- a/rpcs3/Emu/Cell/SPUAnalyser.cpp
+++ b/rpcs3/Emu/Cell/SPUAnalyser.cpp
@@ -1,39 +1,12 @@
 #include "stdafx.h"
+#include "Emu/Memory/vm.h"
 #include "SPUAnalyser.h"
 #include "SPURecompiler.h"
 #include "SPUOpcodes.h"
 
 const spu_decoder<spu_itype> s_spu_itype;
 
-spu_function_t* SPUDatabase::find(const be_t<u32>* data, u64 key, u32 max_size)
-{
-	for (auto found = m_db.equal_range(key); found.first != found.second; found.first++)
-	{
-		const auto& func = found.first->second;
-
-		// Compare binary data explicitly (TODO: optimize)
-		if (LIKELY(func->size <= max_size) && std::memcmp(func->data.data(), data, func->size) == 0)
-		{
-			return func.get();
-		}
-	}
-
-	return nullptr;
-}
-
-SPUDatabase::SPUDatabase()
-{
-	// TODO: load existing database associated with currently running executable
-
-	LOG_SUCCESS(SPU, "SPU Database initialized...");
-}
-
-SPUDatabase::~SPUDatabase()
-{
-	// TODO: serialize database
-}
-
-spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_limit)
+std::shared_ptr<spu_function> spu_analyse(const be_t<u32>* ls, u32 entry, u32 max_limit)
 {
 	// Check arguments (bounds and alignment)
 	if (max_limit > 0x40000 || entry >= max_limit || entry % 4 || max_limit % 4)
@@ -47,23 +20,23 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 	const u32 block_sz = max_limit - entry;
 
 	{
-		reader_lock lock(m_mutex);
+		//reader_lock lock(m_mutex);
 
 		// Try to find existing function in the database
-		if (auto func = find(base, key, block_sz))
-		{
-			return func;
-		}
+		// if (auto func = find(base, key, block_sz))
+		// {
+		// 	return func;
+		// }
 	}
 
 	{
-		writer_lock lock(m_mutex);
+		//writer_lock lock(m_mutex);
 
 		// Double-check
-		if (auto func = find(base, key, block_sz))
-		{
-			return func;
-		}
+		// if (auto func = find(base, key, block_sz))
+		// {
+		// 	return func;
+		// }
 	}
 
 	// Initialize block entries with the function entry point
@@ -89,14 +62,14 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 		const auto type = s_spu_itype.decode(op.opcode);
 
 		{
-			reader_lock lock(m_mutex);
+			//reader_lock lock(m_mutex);
 
 			// Find existing function
-			if (pos != entry && find(ls + pos / 4, pos | u64{ op.opcode } << 32, limit - pos))
-			{
-				limit = pos;
-				break;
-			}
+			// if (pos != entry && find(ls + pos / 4, pos | u64{ op.opcode } << 32, limit - pos))
+			// {
+			// 	limit = pos;
+			// 	break;
+			// }
 		}
 
 		// Additional analysis at the beginning of the block
@@ -156,7 +129,7 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 
 				// Fix pos value
 				start = pos; pos = pos - 4;
-				
+
 				continue;
 			}
 
@@ -179,10 +152,10 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 
 		// if upcoming instruction is not BI, reset the pigeonhole optimization
 		// todo: can constant propogation somewhere get rid of this check?
-		if ((type != BI))
+		if ((type != spu_itype::BI))
 			ila_r2_addr = 0; // reset
-		
-		if (type == BI || type == IRET) // Branch Indirect
+
+		if (type == spu_itype::BI || type == spu_itype::IRET) // Branch Indirect
 		{
 			blocks.emplace(start);
 			start = pos + 4;
@@ -190,9 +163,9 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 			if (op.ra == 2 && ila_r2_addr > entry)
 				blocks.emplace(ila_r2_addr);
 		}
-		else if (type == BR || type == BRA) // Branch Relative/Absolute
+		else if (type == spu_itype::BR || type == spu_itype::BRA) // Branch Relative/Absolute
 		{
-			const u32 target = spu_branch_target(type == BR ? pos : 0, op.i16);
+			const u32 target = spu_branch_target(type == spu_itype::BR ? pos : 0, op.i16);
 
 			// Add adjacent function because it always could be
 			adjacent.emplace(target);
@@ -205,9 +178,9 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 			blocks.emplace(start);
 			start = pos + 4;
 		}
-		else if (type == BRSL || type == BRASL) // Branch Relative/Absolute and Set Link
+		else if (type == spu_itype::BRSL || type == spu_itype::BRASL) // Branch Relative/Absolute and Set Link
 		{
-			const u32 target = spu_branch_target(type == BRSL ? pos : 0, op.i16);
+			const u32 target = spu_branch_target(type == spu_itype::BRSL ? pos : 0, op.i16);
 
 			if (target == pos + 4)
 			{
@@ -228,11 +201,11 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 				if (op.rt != 0) LOG_ERROR(SPU, "[0x%05x] Function call without $LR", pos);
 			}
 		}
-		else if (type == BISL || type == BISLED) // Branch Indirect and Set Link
+		else if (type == spu_itype::BISL || type == spu_itype::BISLED) // Branch Indirect and Set Link
 		{
 			if (op.rt != 0) LOG_ERROR(SPU, "[0x%05x] Indirect function call without $LR", pos);
 		}
-		else if (type == BRNZ || type == BRZ || type == BRHNZ || type == BRHZ) // Branch Relative if (Not) Zero (Half)word
+		else if (type == spu_itype::BRNZ || type == spu_itype::BRZ || type == spu_itype::BRHNZ || type == spu_itype::BRHZ) // Branch Relative if (Not) Zero (Half)word
 		{
 			const u32 target = spu_branch_target(pos, op.i16);
 
@@ -244,7 +217,7 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 				blocks.emplace(target);
 			}
 		}
-		else if (type == LNOP || type == NOP) {
+		else if (type == spu_itype::LNOP || type == spu_itype::NOP) {
 			// theres a chance that theres some random lnops/nops after the end of a function
 			// havent found a definite pattern, but, is an easy optimization to check for, just push start down if lnop is tagged as a start
 			// todo: remove the last added start pos as its probly unnecessary
@@ -262,7 +235,7 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 			// Analyse stack pointer access
 			else if (rt == 1)
 			{
-				if (type == ILA && pos < ila_sp_pos)
+				if (type == spu_itype::ILA && pos < ila_sp_pos)
 				{
 					// set minimal ila $SP,* instruction position
 					ila_sp_pos = pos;
@@ -272,7 +245,7 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 			// ila r2, addr
 			// bi r2
 			else if (rt == 2) {
-				if (type == ILA)
+				if (type == spu_itype::ILA)
 					ila_r2_addr = spu_branch_target(op.i18);
 			}
 		}
@@ -285,9 +258,9 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 
 		const auto type = s_spu_itype.decode(op.opcode);
 
-		if (type == BRSL || type == BRASL) // Branch Relative/Absolute and Set Link
+		if (type == spu_itype::BRSL || type == spu_itype::BRASL) // Branch Relative/Absolute and Set Link
 		{
-			const u32 target = spu_branch_target(type == BRSL ? pos : 0, op.i16);
+			const u32 target = spu_branch_target(type == spu_itype::BRSL ? pos : 0, op.i16);
 
 			if (target != pos + 4 && target > entry && limit > target)
 			{
@@ -308,7 +281,7 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 	}
 
 	// Prepare new function (set addr and size)
-	auto func = std::make_shared<spu_function_t>(entry, limit - entry);
+	auto func = std::make_shared<spu_function>(entry, limit - entry);
 
 	// Copy function contents
 	func->data = { ls + entry / 4, ls + limit / 4 };
@@ -346,13 +319,13 @@ spu_function_t* SPUDatabase::analyse(const be_t<u32>* ls, u32 entry, u32 max_lim
 	// Lock here just before we write to the db
 	// Its is unlikely that the second check will pass anyway so we delay this step since compiling functions is very fast
 	{
-		writer_lock lock(m_mutex);
+		//writer_lock lock(m_mutex);
 
 		// Add function to the database
-		m_db.emplace(key, func);
+		//m_db.emplace(key, func);
 	}
 
 	LOG_NOTICE(SPU, "Function detected [0x%05x-0x%05x] (size=0x%x)", func->addr, func->addr + func->size, func->size);
 
-	return func.get();
+	return func;
 }
diff --git a/rpcs3/Emu/Cell/SPUAnalyser.h b/rpcs3/Emu/Cell/SPUAnalyser.h
index dfd29f9181..62121e251d 100644
--- a/rpcs3/Emu/Cell/SPUAnalyser.h
+++ b/rpcs3/Emu/Cell/SPUAnalyser.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include "Utilities/mutex.h"
-
+#include <vector>
 #include <set>
 
 // SPU Instruction Type
@@ -247,7 +246,7 @@ struct spu_itype
 class SPUThread;
 
 // SPU basic function information structure
-struct spu_function_t
+struct spu_function
 {
 	// Entry point (LS address)
 	const u32 addr;
@@ -273,28 +272,9 @@ struct spu_function_t
 	// Pointer to the compiled function
 	u32(*compiled)(SPUThread* _spu, be_t<u32>* _ls) = nullptr;
 
-	spu_function_t(u32 addr, u32 size)
+	spu_function(u32 addr, u32 size)
 		: addr(addr)
 		, size(size)
 	{
 	}
 };
-
-// SPU Function Database (must be global or PS3 process-local)
-class SPUDatabase final : spu_itype
-{
-	shared_mutex m_mutex;
-
-	// All registered functions (uses addr and first instruction as a key)
-	std::unordered_multimap<u64, std::shared_ptr<spu_function_t>> m_db;
-
-	// For internal use
-	spu_function_t* find(const be_t<u32>* data, u64 key, u32 max_size);
-
-public:
-	SPUDatabase();
-	~SPUDatabase();
-
-	// Try to retrieve SPU function information
-	spu_function_t* analyse(const be_t<u32>* ls, u32 entry, u32 limit = 0x40000);
-};
diff --git a/rpcs3/Emu/Cell/SPURecompiler.cpp b/rpcs3/Emu/Cell/SPURecompiler.cpp
index 3d5fa04ce9..72c54c6257 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPURecompiler.cpp
@@ -3,92 +3,183 @@
 #include "Emu/Memory/Memory.h"
 
 #include "SPUThread.h"
+#include "SPUAnalyser.h"
 #include "SPURecompiler.h"
-#include "SPUASMJITRecompiler.h"
 #include <algorithm>
 
 extern u64 get_system_time();
 
+const spu_decoder<spu_itype> s_spu_itype;
+
+spu_recompiler_base::spu_recompiler_base(SPUThread& spu)
+	: m_spu(spu)
+{
+	// Initialize lookup table
+	spu.jit_dispatcher.fill(&dispatch);
+
+	// Initialize "empty" block
+	spu.jit_map[std::vector<u32>()] = &dispatch;
+}
+
 spu_recompiler_base::~spu_recompiler_base()
 {
 }
 
-void spu_recompiler_base::enter(SPUThread& spu)
+void spu_recompiler_base::dispatch(SPUThread& spu, void*, u8* rip)
 {
-	if (spu.pc >= 0x40000 || spu.pc % 4)
+	const auto result = spu.jit_map.emplace(block(spu, spu.pc), nullptr);
+
+	if (result.second || !result.first->second)
 	{
-		fmt::throw_exception("Invalid PC: 0x%05x", spu.pc);
+		result.first->second = spu.jit->compile(result.first->first);
 	}
 
-	// Get SPU LS pointer
-	const auto _ls = vm::_ptr<u32>(spu.offset);
+	spu.jit_dispatcher[spu.pc / 4] = result.first->second;
+}
 
-	// Search if cached data matches
-	auto func = spu.compiled_cache[spu.pc / 4];
+void spu_recompiler_base::branch(SPUThread& spu, std::pair<const std::vector<u32>, spu_function_t>* pair, u8* rip)
+{
+	spu.pc = pair->first[0];
 
-	// Check shared db if we dont have a match
-	if (!func || !std::equal(func->data.begin(), func->data.end(), _ls + spu.pc / 4, [](const be_t<u32>& l, const be_t<u32>& r) { return *(u32*)(u8*)&l == *(u32*)(u8*)&r; }))
+	if (!pair->second)
 	{
-		func = spu.spu_db->analyse(_ls, spu.pc);
-		spu.compiled_cache[spu.pc / 4] = func;
+		pair->second = spu.jit->compile(pair->first);
 	}
 
-	// Reset callstack if necessary
-	if ((func->does_reset_stack && spu.recursion_level) || spu.recursion_level >= 128)
-	{
-		spu.state += cpu_flag::ret;
-		return;
-	}
+	spu.jit_dispatcher[spu.pc / 4] = pair->second;
 
-	// Compile if needed
-	if (!func->compiled)
+	// Overwrite jump to this function with jump to the compiled function
+	const s64 rel = reinterpret_cast<u64>(pair->second) - reinterpret_cast<u64>(rip) - 5;
+
+	if (rel >= INT32_MIN && rel <= INT32_MAX)
 	{
-		if (!spu.spu_rec)
+		const s64 rel8 = (rel + 5) - 2;
+
+		alignas(8) u8 bytes[8];
+
+		if (rel8 >= INT8_MIN && rel8 <= INT8_MAX)
 		{
-			spu.spu_rec = fxm::get_always<spu_recompiler>();
+			bytes[0] = 0xeb; // jmp rel8
+			bytes[1] = static_cast<s8>(rel8);
+			std::memset(bytes + 2, 0x90, 5);
+			bytes[7] = 0x48;
+		}
+		else
+		{
+			bytes[0] = 0xe9; // jmp rel32
+			std::memcpy(bytes + 1, &rel, 4);
+			std::memset(bytes + 5, 0x90, 2);
+			bytes[7] = 0x48;
 		}
 
-		spu.spu_rec->compile(*func);
-
-		if (!func->compiled) fmt::throw_exception("Compilation failed" HERE);
+#ifdef _MSC_VER
+		*(volatile u64*)(rip) = *reinterpret_cast<u64*>(+bytes);
+#else
+		__atomic_store_n(reinterpret_cast<u64*>(rip), *reinterpret_cast<u64*>(+bytes), __ATOMIC_RELAXED);
+#endif
 	}
-
-	const u32 res = func->compiled(&spu, _ls);
-
-	if (const auto exception = spu.pending_exception)
+	else
 	{
-		spu.pending_exception = nullptr;
-		std::rethrow_exception(exception);
-	}
+		alignas(16) u8 bytes[16];
 
-	if (res & 0x1000000)
-	{
-		spu.halt();
-	}
+		bytes[0] = 0xff; // jmp [rip+2]
+		bytes[1] = 0x25;
+		bytes[2] = 0x02;
+		bytes[3] = 0x00;
+		bytes[4] = 0x00;
+		bytes[5] = 0x00;
+		bytes[6] = 0x48; // mov rax, imm64 (not executed)
+		bytes[7] = 0xb8;
+		std::memcpy(bytes + 8, &pair->second, 8);
 
-	if (res & 0x2000000)
-	{
-	}
-
-	if (res & 0x4000000)
-	{
-		if (res & 0x8000000)
-		{
-			fmt::throw_exception("Invalid interrupt status set (0x%x)" HERE, res);
-		}
-
-		spu.set_interrupt_status(true);
-	}
-	else if (res & 0x8000000)
-	{
-		spu.set_interrupt_status(false);
-	}
-
-	spu.pc = res & 0x3fffc;
-
-	if (spu.interrupts_enabled && (spu.ch_event_mask & spu.ch_event_stat & SPU_EVENT_INTR_IMPLEMENTED) > 0)
-	{
-		spu.interrupts_enabled = false;
-		spu.srr0 = std::exchange(spu.pc, 0);
+		reinterpret_cast<atomic_t<u128>*>(rip)->store(*reinterpret_cast<u128*>(+bytes));
 	}
 }
+
+std::vector<u32> spu_recompiler_base::block(SPUThread& spu, u32 lsa)
+{
+	u32 addr = lsa;
+
+	std::vector<u32> result;
+
+	while (addr < 0x40000)
+	{
+		const u32 data = spu._ref<u32>(addr);
+
+		if (data == 0 && addr == lsa)
+		{
+			break;
+		}
+
+		addr += 4;
+
+		if (result.empty())
+		{
+			result.emplace_back(lsa);
+		}
+
+		result.emplace_back(se_storage<u32>::swap(data));
+
+		const auto type = s_spu_itype.decode(data);
+
+		switch (type)
+		{
+		case spu_itype::UNK:
+		case spu_itype::STOP:
+		case spu_itype::STOPD:
+		case spu_itype::SYNC:
+		case spu_itype::DSYNC:
+		case spu_itype::DFCEQ:
+		case spu_itype::DFCMEQ:
+		case spu_itype::DFCGT:
+		//case spu_itype::DFCMGT:
+		case spu_itype::DFTSV:
+		case spu_itype::BI:
+		case spu_itype::IRET:
+		case spu_itype::BISL:
+		{
+			break;
+		}
+		case spu_itype::BRA:
+		case spu_itype::BRASL:
+		{
+			if (spu_branch_target(0, spu_opcode_t{data}.i16) == addr)
+			{
+				continue;
+			}
+
+			break;
+		}
+		case spu_itype::BR:
+		case spu_itype::BRSL:
+		{
+			if (spu_branch_target(addr - 4, spu_opcode_t{data}.i16) == addr)
+			{
+				continue;
+			}
+
+			break;
+		}
+		case spu_itype::BRZ:
+		case spu_itype::BRNZ:
+		case spu_itype::BRHZ:
+		case spu_itype::BRHNZ:
+		{
+			if (spu_branch_target(addr - 4, spu_opcode_t{data}.i16) >= addr)
+			{
+				continue;
+			}
+
+			break;
+		}
+		default:
+		{
+			continue;
+		}
+		}
+
+		break;
+	}
+
+	return result;
+}
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 3b400c1e73..b687c4645b 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -1,25 +1,32 @@
 #pragma once
 
-#include "SPUAnalyser.h"
+#include "SPUThread.h"
 
-#include <mutex>
-
-// SPU Recompiler instance base (must be global or PS3 process-local)
+// SPU Recompiler instance base class
 class spu_recompiler_base
 {
 protected:
-	std::mutex m_mutex; // must be locked in compile()
+	SPUThread& m_spu;
 
-	const spu_function_t* m_func; // current function
-
-	u32 m_pos; // current position
+	u32 m_pos;
 
 public:
+	spu_recompiler_base(SPUThread& spu);
+
 	virtual ~spu_recompiler_base();
 
-	// Compile specified function
-	virtual void compile(spu_function_t& f) = 0;
+	// Compile function
+	virtual spu_function_t compile(const std::vector<u32>& func) = 0;
 
-	// Run
-	static void enter(class SPUThread&);
+	// Default dispatch function fallback (second pointer is unused)
+	static void dispatch(SPUThread&, void*, u8*);
+
+	// Direct branch fallback for non-compiled destination
+	static void branch(SPUThread&, std::pair<const std::vector<u32>, spu_function_t>*, u8* rip);
+
+	// Get the block at specified address
+	static std::vector<u32> block(SPUThread&, u32 lsa);
+
+	// Create recompiler instance (ASMJIT)
+	static std::unique_ptr<spu_recompiler_base> make_asmjit_recompiler(SPUThread& spu);
 };
diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp
index 6c8febfdd5..be2a05fd6f 100644
--- a/rpcs3/Emu/Cell/SPUThread.cpp
+++ b/rpcs3/Emu/Cell/SPUThread.cpp
@@ -314,7 +314,7 @@ std::string SPUThread::dump() const
 
 	// Print some transaction statistics
 	fmt::append(ret, "\nTX: %u; Fail: %u (0x%x)", tx_success, tx_failure, tx_status);
-	fmt::append(ret, "\nRaddr: 0x%08x; R: 0x%x", raddr, raddr ? +vm::reservation_acquire(raddr, 128) : 0);
+	fmt::append(ret, "\nBlocks: %u; Fail: %u", block_counter, block_failure);
 	fmt::append(ret, "\nTag Mask: 0x%08x", ch_tag_mask);
 	fmt::append(ret, "\nMFC Stall: 0x%08x", ch_stall_mask);
 	fmt::append(ret, "\nMFC Queue Size: %u", mfc_size);
@@ -397,12 +397,6 @@ void SPUThread::cpu_task()
 {
 	std::fesetround(FE_TOWARDZERO);
 
-	if (g_cfg.core.spu_decoder == spu_decoder_type::asmjit)
-	{
-		if (!spu_db) spu_db = fxm::get_always<SPUDatabase>();
-		return spu_recompiler_base::enter(*this);
-	}
-
 	g_tls_log_prefix = []
 	{
 		const auto cpu = static_cast<SPUThread*>(get_current_cpu_thread());
@@ -410,6 +404,16 @@ void SPUThread::cpu_task()
 		return fmt::format("%s [0x%05x]", cpu->get_name(), cpu->pc);
 	};
 
+	if (jit)
+	{
+		while (LIKELY(!test(state) || !check_state()))
+		{
+			jit_dispatcher[pc / 4](*this, vm::_ptr<u8>(offset), nullptr);
+		}
+
+		return;
+	}
+
 	// Select opcode table
 	const auto& table = *(
 		g_cfg.core.spu_decoder == spu_decoder_type::precise ? &g_spu_interpreter_precise.get_table() :
@@ -502,15 +506,6 @@ SPUThread::~SPUThread()
 	vm::dealloc_verbose_nothrow(offset);
 }
 
-SPUThread::SPUThread(const std::string& name)
-	: cpu_thread(idm::last_id())
-	, m_name(name)
-	, index(0)
-	, offset(0)
-	, group(nullptr)
-{
-}
-
 SPUThread::SPUThread(const std::string& name, u32 index, lv2_spu_group* group)
 	: cpu_thread(idm::last_id())
 	, m_name(name)
@@ -518,6 +513,14 @@ SPUThread::SPUThread(const std::string& name, u32 index, lv2_spu_group* group)
 	, offset(0)
 	, group(group)
 {
+	if (g_cfg.core.spu_decoder == spu_decoder_type::asmjit)
+	{
+		jit = spu_recompiler_base::make_asmjit_recompiler(*this);
+	}
+
+	if (g_cfg.core.spu_decoder == spu_decoder_type::llvm)
+	{
+	}
 }
 
 void SPUThread::push_snr(u32 number, u32 value)
diff --git a/rpcs3/Emu/Cell/SPUThread.h b/rpcs3/Emu/Cell/SPUThread.h
index adb2f8c614..deb0d6b9d9 100644
--- a/rpcs3/Emu/Cell/SPUThread.h
+++ b/rpcs3/Emu/Cell/SPUThread.h
@@ -5,10 +5,17 @@
 #include "Emu/Cell/SPUInterpreter.h"
 #include "MFC.h"
 
+#include <map>
+
 struct lv2_event_queue;
 struct lv2_spu_group;
 struct lv2_int_tag;
 
+class SPUThread;
+
+// JIT Block
+using spu_function_t = void(*)(SPUThread&, void*, u8*);
+
 // SPU Channels
 enum : u32
 {
@@ -514,16 +521,14 @@ public:
 	virtual ~SPUThread() override;
 	void cpu_init();
 
-protected:
-	SPUThread(const std::string& name);
-
-public:
 	static const u32 id_base = 0x02000000; // TODO (used to determine thread type)
 	static const u32 id_step = 1;
 	static const u32 id_count = 2048;
 
 	SPUThread(const std::string& name, u32 index, lv2_spu_group* group);
 
+	u32 pc = 0;
+
 	// General-Purpose Registers
 	std::array<v128, 128> gpr;
 	SPU_FPSCR fpscr;
@@ -577,24 +582,26 @@ public:
 	std::array<std::pair<u32, std::weak_ptr<lv2_event_queue>>, 32> spuq; // Event Queue Keys for SPU Thread
 	std::weak_ptr<lv2_event_queue> spup[64]; // SPU Ports
 
-	u32 pc = 0; //
 	const u32 index; // SPU index
 	const u32 offset; // SPU LS offset
 	lv2_spu_group* const group; // SPU Thread Group
 
 	const std::string m_name; // Thread name
 
-	std::exception_ptr pending_exception;
-
-	std::array<struct spu_function_t*, 65536> compiled_cache{};
-	std::shared_ptr<class SPUDatabase> spu_db;
-	std::shared_ptr<class spu_recompiler_base> spu_rec;
-	u32 recursion_level = 0;
-
 	u64 tx_success = 0;
 	u64 tx_failure = 0;
 	uint tx_status = 0;
 
+	std::unique_ptr<class spu_recompiler_base> jit; // Recompiler instance
+
+	std::map<std::vector<u32>, spu_function_t> jit_map; // All compiled blocks (first u32 is addr)
+
+	u64 block_counter = 0;
+	u64 block_recover = 0;
+	u64 block_failure = 0;
+
+	std::array<spu_function_t, 0x10000> jit_dispatcher; // Dispatch table for indirect calls
+
 	void push_snr(u32 number, u32 value);
 	void do_dma_transfer(const spu_mfc_cmd& args);
 	bool do_dma_check(const spu_mfc_cmd& args);