diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index 4cba394db8..54caf465e5 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -301,6 +301,16 @@ union alignas(16) v128
 	}
 };
 
+template <typename T, std::size_t N, std::size_t M>
+struct offset32_array<v128::masked_array_t<T, N, M>>
+{
+	template <typename Arg>
+	static inline u32 index32(const Arg& arg)
+	{
+		return SIZE_32(T) * (static_cast<u32>(arg) ^ static_cast<u32>(M));
+	}
+};
+
 inline v128 operator|(const v128& left, const v128& right)
 {
 	return v128::fromV(_mm_or_si128(left.vi, right.vi));
diff --git a/Utilities/types.h b/Utilities/types.h
index 218f0b235d..b88e0dfb41 100644
--- a/Utilities/types.h
+++ b/Utilities/types.h
@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <utility>
 #include <chrono>
+#include <array>
 
 // Assume little-endian
 #define IS_LE_MACHINE 1
@@ -45,9 +46,6 @@
 // Return 32 bit alignof() to avoid widening/narrowing conversions with size_t
 #define ALIGN_32(...) static_cast<u32>(alignof(__VA_ARGS__))
 
-// Return 32 bit offsetof()
-#define OFFSET_32(type, x) static_cast<u32>(reinterpret_cast<std::uintptr_t>(&reinterpret_cast<const volatile char&>(reinterpret_cast<type*>(0ull)->x)))
-
 #define CONCATENATE_DETAIL(x, y) x ## y
 #define CONCATENATE(x, y) CONCATENATE_DETAIL(x, y)
 
@@ -450,6 +448,71 @@ constexpr T align(const T& value, ullong align)
 	return static_cast<T>((value + (align - 1)) & ~(align - 1));
 }
 
+template <typename T, typename T2>
+inline u32 offset32(T T2::*const mptr)
+{
+#ifdef _MSC_VER
+	static_assert(sizeof(mptr) == sizeof(u32), "Invalid pointer-to-member size");
+	return reinterpret_cast<const u32&>(mptr);
+#elif __GNUG__
+	static_assert(sizeof(mptr) == sizeof(std::size_t), "Invalid pointer-to-member size");
+	return static_cast<u32>(reinterpret_cast<const std::size_t&>(mptr));
+#else
+	static_assert(sizeof(mptr) == 0, "Invalid pointer-to-member size");
+#endif
+}
+
+template <typename T>
+struct offset32_array
+{
+	static_assert(std::is_array<T>::value, "Invalid pointer-to-member type (array expected)");
+
+	template <typename Arg>
+	static inline u32 index32(const Arg& arg)
+	{
+		return SIZE_32(std::remove_extent_t<T>) * static_cast<u32>(arg);
+	}
+};
+
+template <typename T, std::size_t N>
+struct offset32_array<std::array<T, N>>
+{
+	template <typename Arg>
+	static inline u32 index32(const Arg& arg)
+	{
+		return SIZE_32(T) * static_cast<u32>(arg);
+	}
+};
+
+template <typename Arg>
+struct offset32_detail;
+
+template <typename T, typename T2, typename Arg, typename... Args>
+inline u32 offset32(T T2::*const mptr, const Arg& arg, const Args&... args)
+{
+	return offset32_detail<Arg>::offset32(mptr, arg, args...);
+}
+
+template <typename Arg>
+struct offset32_detail
+{
+	template <typename T, typename T2, typename... Args>
+	static inline u32 offset32(T T2::*const mptr, const Arg& arg, const Args&... args)
+	{
+		return ::offset32(mptr, args...) + offset32_array<T>::index32(arg);
+	}
+};
+
+template <typename T3, typename T4>
+struct offset32_detail<T3 T4::*>
+{
+	template <typename T, typename T2, typename... Args>
+	static inline u32 offset32(T T2::*const mptr, T3 T4::*const mptr2, const Args&... args)
+	{
+		return ::offset32(mptr) + ::offset32(mptr2, args...);
+	}
+};
+
 inline u32 cntlz32(u32 arg, bool nonzero = false)
 {
 #ifdef _MSC_VER
diff --git a/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp b/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
index 0ed4bcb057..a188a93fae 100644
--- a/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
@@ -1217,7 +1217,7 @@ void spursSysServiceTraceUpdate(SPUThread& spu, SpursKernelContext* ctxt, u32 ar
 	if (((sysSrvMsgUpdateTrace & (1 << ctxt->spuNum)) != 0) || (arg3 != 0))
 	{
 		//vm::reservation_acquire(vm::base(spu.offset + 0x80), ctxt->spurs.ptr(&CellSpurs::traceBuffer).addr(), 128);
-		auto spurs = vm::_ptr<CellSpurs>(spu.offset + 0x80 - OFFSET_32(CellSpurs, traceBuffer));
+		auto spurs = vm::_ptr<CellSpurs>(spu.offset + 0x80 - offset32(&CellSpurs::traceBuffer));
 
 		if (ctxt->traceMsgCount != 0xFF || spurs->traceBuffer.addr() == 0)
 		{
@@ -1240,7 +1240,7 @@ void spursSysServiceTraceUpdate(SPUThread& spu, SpursKernelContext* ctxt, u32 ar
 
 	if (notify)
 	{
-		auto spurs = vm::_ptr<CellSpurs>(spu.offset + 0x2D80 - OFFSET_32(CellSpurs, wklState1));
+		auto spurs = vm::_ptr<CellSpurs>(spu.offset + 0x2D80 - offset32(&CellSpurs::wklState1));
 		sys_spu_thread_send_event(spu, spurs->spuPort, 2, 0);
 	}
 }
diff --git a/rpcs3/Emu/Cell/PPUTranslator.cpp b/rpcs3/Emu/Cell/PPUTranslator.cpp
index b5aba67784..857b62ba6a 100644
--- a/rpcs3/Emu/Cell/PPUTranslator.cpp
+++ b/rpcs3/Emu/Cell/PPUTranslator.cpp
@@ -74,8 +74,8 @@ PPUTranslator::PPUTranslator(LLVMContext& context, Module* module, u64 base)
 	m_base = new GlobalVariable(*module, ArrayType::get(GetType<char>(), 0x100000000)->getPointerTo(), true, GlobalValue::ExternalLinkage, 0, "__mptr");
 
 	// Thread context struct (TODO: safer member access)
-	const auto off0 = OFFSET_32(ppu_thread, state);
-	const auto off1 = OFFSET_32(ppu_thread, gpr);
+	const u32 off0 = offset32(&ppu_thread::state);
+	const u32 off1 = offset32(&ppu_thread::gpr);
 	std::vector<Type*> thread_struct;
 	thread_struct.emplace_back(ArrayType::get(GetType<char>(), off0));
 	thread_struct.emplace_back(GetType<u32>()); // state
diff --git a/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp b/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
index 98a5288f62..3e1e251698 100644
--- a/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
@@ -14,11 +14,11 @@
 
 #include "asmjit.h"
 
-#define SPU_OFF_128(x) asmjit::host::oword_ptr(*cpu, (std::conditional_t<sizeof(SPUThread::x) == 16, u32, void>)OFFSET_32(SPUThread, x))
-#define SPU_OFF_64(x) asmjit::host::qword_ptr(*cpu, (std::conditional_t<sizeof(SPUThread::x) == 8, u32, void>)OFFSET_32(SPUThread, x))
-#define SPU_OFF_32(x) asmjit::host::dword_ptr(*cpu, (std::conditional_t<sizeof(SPUThread::x) == 4, u32, void>)OFFSET_32(SPUThread, x))
-#define SPU_OFF_16(x) asmjit::host::word_ptr(*cpu, (std::conditional_t<sizeof(SPUThread::x) == 2, u32, void>)OFFSET_32(SPUThread, x))
-#define SPU_OFF_8(x) asmjit::host::byte_ptr(*cpu, (std::conditional_t<sizeof(SPUThread::x) == 1, u32, void>)OFFSET_32(SPUThread, x))
+#define SPU_OFF_128(x, ...) asmjit::host::oword_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
+#define SPU_OFF_64(x, ...) asmjit::host::qword_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
+#define SPU_OFF_32(x, ...) asmjit::host::dword_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
+#define SPU_OFF_16(x, ...) asmjit::host::word_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
+#define SPU_OFF_8(x, ...) asmjit::host::byte_ptr(*cpu, offset32(&SPUThread::x, ##__VA_ARGS__))
 
 const spu_decoder<spu_interpreter_fast> s_spu_interpreter; // TODO: remove
 const spu_decoder<spu_recompiler> s_spu_decoder;
@@ -235,9 +235,9 @@ spu_recompiler::XmmLink spu_recompiler::XmmGet(s8 reg, XmmType type) // get xmm
 
 	switch (type)
 	{
-	case XmmType::Int: c->movdqa(result, SPU_OFF_128(gpr[reg])); break;
-	case XmmType::Float: c->movaps(result, SPU_OFF_128(gpr[reg])); break;
-	case XmmType::Double: c->movapd(result, SPU_OFF_128(gpr[reg])); break;
+	case XmmType::Int: c->movdqa(result, SPU_OFF_128(gpr, reg)); break;
+	case XmmType::Float: c->movaps(result, SPU_OFF_128(gpr, reg)); break;
+	case XmmType::Double: c->movapd(result, SPU_OFF_128(gpr, reg)); break;
 	default: fmt::throw_exception("Invalid XmmType" HERE);
 	}
 
@@ -415,7 +415,7 @@ void spu_recompiler::RDCH(spu_opcode_t op)
 		const XmmLink& vr = XmmAlloc();
 		c->movd(vr, SPU_OFF_32(srr0));
 		c->pslldq(vr, 12);
-		c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+		c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 		return;
 	}
 	case MFC_RdTagMask:
@@ -423,7 +423,7 @@ void spu_recompiler::RDCH(spu_opcode_t op)
 		const XmmLink& vr = XmmAlloc();
 		c->movd(vr, SPU_OFF_32(ch_tag_mask));
 		c->pslldq(vr, 12);
-		c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+		c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 		return;
 	}
 	case SPU_RdEventMask:
@@ -431,7 +431,7 @@ void spu_recompiler::RDCH(spu_opcode_t op)
 		const XmmLink& vr = XmmAlloc();
 		c->movd(vr, SPU_OFF_32(ch_event_mask));
 		c->pslldq(vr, 12);
-		c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+		c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 		return;
 	}
 	default:
@@ -450,15 +450,15 @@ void spu_recompiler::SF(spu_opcode_t op)
 {
 	// sub from
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->psubd(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->psubd(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::OR(spu_opcode_t op)
 {
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->por(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->por(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::BG(spu_opcode_t op)
@@ -468,26 +468,26 @@ void spu_recompiler::BG(spu_opcode_t op)
 	const XmmLink& vi = XmmAlloc();
 	c->movdqa(vi, XmmConst(_mm_set1_epi32(0x80000000)));
 	c->pxor(va, vi);
-	c->pxor(vi, SPU_OFF_128(gpr[op.rb]));
+	c->pxor(vi, SPU_OFF_128(gpr, op.rb));
 	c->pcmpgtd(va, vi);
 	c->paddd(va, XmmConst(_mm_set1_epi32(1)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::SFH(spu_opcode_t op)
 {
 	// sub from (halfword)
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->psubw(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->psubw(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::NOR(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->por(va, SPU_OFF_128(gpr[op.rb]));
+	c->por(va, SPU_OFF_128(gpr, op.rb));
 	c->pxor(va, XmmConst(_mm_set1_epi32(0xffffffff)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ABSDB(spu_opcode_t op)
@@ -499,7 +499,7 @@ void spu_recompiler::ABSDB(spu_opcode_t op)
 	c->pmaxub(va, vb);
 	c->pminub(vb, vm);
 	c->psubb(va, vb);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROT(spu_opcode_t op)
@@ -512,9 +512,9 @@ void spu_recompiler::ROT(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u32*, const u32*, const s32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -522,10 +522,10 @@ void spu_recompiler::ROT(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 4; i++) // unrolled loop
 	//{
-	//	c->mov(qw0->r32(), SPU_OFF_32(gpr[op.ra]._u32[i]));
-	//	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[i]));
+	//	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]._u32[i]), qw0->r32());
+	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
 	//}
 }
 
@@ -539,9 +539,9 @@ void spu_recompiler::ROTM(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -549,11 +549,11 @@ void spu_recompiler::ROTM(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 4; i++) // unrolled loop
 	//{
-	//	c->mov(qw0->r32(), SPU_OFF_32(gpr[op.ra]._u32[i]));
-	//	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[i]));
+	//	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]._u32[i]), qw0->r32());
+	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
 	//}
 }
 
@@ -567,9 +567,9 @@ void spu_recompiler::ROTMA(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(s32*, const s32*, const u32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -577,11 +577,11 @@ void spu_recompiler::ROTMA(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 4; i++) // unrolled loop
 	//{
-	//	c->movsxd(*qw0, SPU_OFF_32(gpr[op.ra]._u32[i]));
-	//	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[i]));
+	//	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]._u32[i]), qw0->r32());
+	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
 	//}
 }
 
@@ -595,9 +595,9 @@ void spu_recompiler::SHL(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -605,10 +605,10 @@ void spu_recompiler::SHL(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 4; i++) // unrolled loop
 	//{
-	//	c->mov(qw0->r32(), SPU_OFF_32(gpr[op.ra]._u32[i]));
-	//	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[i]));
+	//	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]._u32[i]), qw0->r32());
+	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), qw0->r32());
 	//}
 }
 
@@ -622,9 +622,9 @@ void spu_recompiler::ROTH(spu_opcode_t op) //nf
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u16*, const u16*, const s16*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -632,10 +632,10 @@ void spu_recompiler::ROTH(spu_opcode_t op) //nf
 
 	//for (u32 i = 0; i < 8; i++) // unrolled loop
 	//{
-	//	c->movzx(qw0->r32(), SPU_OFF_16(gpr[op.ra]._u16[i]));
-	//	c->movzx(*addr, SPU_OFF_16(gpr[op.rb]._u16[i]));
+	//	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]._u16[i]), qw0->r16());
+	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
 	//}
 }
 
@@ -649,9 +649,9 @@ void spu_recompiler::ROTHM(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u16*, const u16*, const u16*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -659,11 +659,11 @@ void spu_recompiler::ROTHM(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 8; i++) // unrolled loop
 	//{
-	//	c->movzx(qw0->r32(), SPU_OFF_16(gpr[op.ra]._u16[i]));
-	//	c->movzx(*addr, SPU_OFF_16(gpr[op.rb]._u16[i]));
+	//	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]._u16[i]), qw0->r16());
+	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
 	//}
 }
 
@@ -677,9 +677,9 @@ void spu_recompiler::ROTMAH(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(s16*, const s16*, const u16*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -687,11 +687,11 @@ void spu_recompiler::ROTMAH(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 8; i++) // unrolled loop
 	//{
-	//	c->movsx(qw0->r32(), SPU_OFF_16(gpr[op.ra]._u16[i]));
-	//	c->movzx(*addr, SPU_OFF_16(gpr[op.rb]._u16[i]));
+	//	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]._u16[i]), qw0->r16());
+	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
 	//}
 }
 
@@ -705,9 +705,9 @@ void spu_recompiler::SHLH(spu_opcode_t op)
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u16*, const u16*, const u16*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -715,10 +715,10 @@ void spu_recompiler::SHLH(spu_opcode_t op)
 
 	//for (u32 i = 0; i < 8; i++) // unrolled loop
 	//{
-	//	c->movzx(qw0->r32(), SPU_OFF_16(gpr[op.ra]._u16[i]));
-	//	c->movzx(*addr, SPU_OFF_16(gpr[op.rb]._u16[i]));
+	//	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]._u16[i]), qw0->r16());
+	//	c->mov(SPU_OFF_16(gpr, op.rt, &v128::_u16, i), qw0->r16());
 	//}
 }
 
@@ -732,7 +732,7 @@ void spu_recompiler::ROTI(spu_opcode_t op)
 	c->pslld(va, s);
 	c->psrld(v1, 32 - s);
 	c->por(va, v1);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROTMI(spu_opcode_t op)
@@ -741,7 +741,7 @@ void spu_recompiler::ROTMI(spu_opcode_t op)
 	const int s = 0-op.i7 & 0x3f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psrld(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROTMAI(spu_opcode_t op)
@@ -750,7 +750,7 @@ void spu_recompiler::ROTMAI(spu_opcode_t op)
 	const int s = 0-op.i7 & 0x3f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psrad(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::SHLI(spu_opcode_t op)
@@ -759,7 +759,7 @@ void spu_recompiler::SHLI(spu_opcode_t op)
 	const int s = op.i7 & 0x3f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pslld(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROTHI(spu_opcode_t op)
@@ -772,7 +772,7 @@ void spu_recompiler::ROTHI(spu_opcode_t op)
 	c->psllw(va, s);
 	c->psrlw(v1, 16 - s);
 	c->por(va, v1);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROTHMI(spu_opcode_t op)
@@ -781,7 +781,7 @@ void spu_recompiler::ROTHMI(spu_opcode_t op)
 	const int s = 0-op.i7 & 0x1f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psrlw(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROTMAHI(spu_opcode_t op)
@@ -790,7 +790,7 @@ void spu_recompiler::ROTMAHI(spu_opcode_t op)
 	const int s = 0-op.i7 & 0x1f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psraw(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::SHLHI(spu_opcode_t op)
@@ -799,22 +799,22 @@ void spu_recompiler::SHLHI(spu_opcode_t op)
 	const int s = op.i7 & 0x1f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psllw(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::A(spu_opcode_t op)
 {
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->paddd(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->paddd(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::AND(spu_opcode_t op)
 {
 	// and
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->pand(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->pand(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::CG(spu_opcode_t op)
@@ -828,30 +828,30 @@ void spu_recompiler::CG(spu_opcode_t op)
 	c->pxor(vb, vi);
 	c->pcmpgtd(va, vb);
 	c->psrld(va, 31);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::AH(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->paddw(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->paddw(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::NAND(spu_opcode_t op)
 {
 	// nand
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pand(va, SPU_OFF_128(gpr[op.rb]));
+	c->pand(va, SPU_OFF_128(gpr, op.rb));
 	c->pxor(va, XmmConst(_mm_set1_epi32(0xffffffff)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::AVGB(spu_opcode_t op)
 {
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->pavgb(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->pavgb(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::MTSPR(spu_opcode_t op)
@@ -865,50 +865,50 @@ void spu_recompiler::WRCH(spu_opcode_t op)
 	{
 	case SPU_WrSRR0:
 	{
-		c->mov(*addr, SPU_OFF_32(gpr[op.rt]._u32[3]));
+		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_WrTagMask:
 	{
-		c->mov(*addr, SPU_OFF_32(gpr[op.rt]._u32[3]));
+		c->mov(*addr, SPU_OFF_32(gpr, op.rt, &v128::_u32, 3));
 		c->mov(SPU_OFF_32(ch_tag_mask), *addr);
 		c->unuse(*addr);
 		return;
 	}
 	case MFC_LSA:
 	{
-		c->mov(*addr, SPU_OFF_32(gpr[op.rt]._u32[3]));
-		c->mov(SPU_OFF_32(ch_mfc_cmd.lsa), *addr);
+		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]._u32[3]));
-		c->mov(SPU_OFF_32(ch_mfc_cmd.eah), *addr);
+		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]._u32[3]));
-		c->mov(SPU_OFF_32(ch_mfc_cmd.eal), *addr);
+		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]._u32[3]));
-		c->mov(SPU_OFF_16(ch_mfc_cmd.size), addr->r16());
+		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]._u32[3]));
-		c->mov(SPU_OFF_8(ch_mfc_cmd.tag), addr->r8());
+		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;
 	}
@@ -925,40 +925,40 @@ void spu_recompiler::WRCH(spu_opcode_t op)
 
 void spu_recompiler::BIZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	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
-	c->cmp(SPU_OFF_32(gpr[op.rt]._u32[3]), 0);
+	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
 	c->je(*jt);
 	c->unuse(*addr);
 }
 
 void spu_recompiler::BINZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	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
-	c->cmp(SPU_OFF_32(gpr[op.rt]._u32[3]), 0);
+	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
 	c->jne(*jt);
 	c->unuse(*addr);
 }
 
 void spu_recompiler::BIHZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	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
-	c->cmp(SPU_OFF_16(gpr[op.rt]._u16[6]), 0);
+	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
 	c->je(*jt);
 	c->unuse(*addr);
 }
 
 void spu_recompiler::BIHNZ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	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
-	c->cmp(SPU_OFF_16(gpr[op.rt]._u16[6]), 0);
+	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
 	c->jne(*jt);
 	c->unuse(*addr);
 }
@@ -970,8 +970,8 @@ void spu_recompiler::STOPD(spu_opcode_t op)
 
 void spu_recompiler::STQX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
-	c->add(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+	c->add(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x3fff0);
 
 	const XmmLink& vt = XmmGet(op.rt, XmmType::Int);
@@ -982,7 +982,7 @@ void spu_recompiler::STQX(spu_opcode_t op)
 
 void spu_recompiler::BI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	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
 	c->jmp(*jt);
@@ -990,7 +990,7 @@ void spu_recompiler::BI(spu_opcode_t op)
 
 void spu_recompiler::BISL(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	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);
@@ -998,7 +998,7 @@ void spu_recompiler::BISL(spu_opcode_t op)
 
 	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->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->unuse(vr);
 
 	FunctionCall();
@@ -1029,7 +1029,7 @@ void spu_recompiler::GB(spu_opcode_t op)
 	c->pmovmskb(*addr, va);
 	c->pxor(va, va);
 	c->pinsrw(va, *addr, 6);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 }
 
@@ -1041,7 +1041,7 @@ void spu_recompiler::GBH(spu_opcode_t op)
 	c->pmovmskb(*addr, va);
 	c->pxor(va, va);
 	c->pinsrw(va, *addr, 6);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 }
 
@@ -1052,7 +1052,7 @@ void spu_recompiler::GBB(spu_opcode_t op)
 	c->pmovmskb(*addr, va);
 	c->pxor(va, va);
 	c->pinsrw(va, *addr, 6);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 }
 
@@ -1060,11 +1060,11 @@ void spu_recompiler::FSM(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.fsm));
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0xf);
 	c->shl(*addr, 4);
 	c->movdqa(vr, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1073,11 +1073,11 @@ void spu_recompiler::FSMH(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.fsmh));
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0xff);
 	c->shl(*addr, 4);
 	c->movdqa(vr, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1086,11 +1086,11 @@ void spu_recompiler::FSMB(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.fsmb));
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->and_(*addr, 0xffff);
 	c->shl(*addr, 4);
 	c->movdqa(vr, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1099,7 +1099,7 @@ void spu_recompiler::FREST(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
 	c->rcpps(va, va);
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FRSQEST(spu_opcode_t op)
@@ -1107,19 +1107,19 @@ void spu_recompiler::FRSQEST(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
 	c->andps(va, XmmConst(_mm_set1_epi32(0x7fffffff))); // abs
 	c->rsqrtps(va, va);
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::LQX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
-	c->add(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+	c->add(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x3fff0);
 
 	const XmmLink& vt = XmmAlloc();
 	c->movdqa(vt, asmjit::host::oword_ptr(*ls, *addr));
 	c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 	c->unuse(*addr);
 }
 
@@ -1127,11 +1127,11 @@ void spu_recompiler::ROTQBYBI(spu_opcode_t 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]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0xf << 3);
 	c->shl(*addr, 1);
 	c->pshufb(va, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1140,13 +1140,13 @@ void spu_recompiler::ROTQMBYBI(spu_opcode_t 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]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->shr(*addr, 3);
 	c->neg(*addr);
 	c->and_(*addr, 0x1f);
 	c->shl(*addr, 4);
 	c->pshufb(va, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1155,84 +1155,84 @@ void spu_recompiler::SHLQBYBI(spu_opcode_t 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]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x1f << 3);
 	c->shl(*addr, 1);
 	c->pshufb(va, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
 
 void spu_recompiler::CBX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
-	c->add(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
+	c->add(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->not_(*addr);
 	c->and_(*addr, 0xf);
 
 	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::host::byte_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), 0x03);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
+	c->mov(asmjit::host::byte_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x03);
 	c->unuse(*addr);
 }
 
 void spu_recompiler::CHX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
-	c->add(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
+	c->add(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->not_(*addr);
 	c->and_(*addr, 0xe);
 
 	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::host::word_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), 0x0203);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
+	c->mov(asmjit::host::word_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x0203);
 	c->unuse(*addr);
 }
 
 void spu_recompiler::CWX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
-	c->add(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
+	c->add(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->not_(*addr);
 	c->and_(*addr, 0xc);
 
 	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::host::dword_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), 0x00010203);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
+	c->mov(asmjit::host::dword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x00010203);
 	c->unuse(*addr);
 }
 
 void spu_recompiler::CDX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
-	c->add(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
+	c->add(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->not_(*addr);
 	c->and_(*addr, 0x8);
 
 	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->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->mov(*qw0, asmjit::imm_u(0x0001020304050607));
-	c->mov(asmjit::host::qword_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), *qw0);
+	c->mov(asmjit::host::qword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), *qw0);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
 
 void spu_recompiler::ROTQBI(spu_opcode_t op)
 {
-	c->mov(*qw0, SPU_OFF_64(gpr[op.ra]._u64[0]));
-	c->mov(*qw1, SPU_OFF_64(gpr[op.ra]._u64[1]));
+	c->mov(*qw0, SPU_OFF_64(gpr, op.ra, &v128::_u64, 0));
+	c->mov(*qw1, SPU_OFF_64(gpr, op.ra, &v128::_u64, 1));
 	c->mov(*qw2, *qw0);
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 7);
 	c->shld(*qw0, *qw1, *addr);
 	c->shld(*qw1, *qw2, *addr);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[1]), *qw1);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw0);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw1);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 	c->unuse(*qw1);
@@ -1241,15 +1241,15 @@ void spu_recompiler::ROTQBI(spu_opcode_t op)
 
 void spu_recompiler::ROTQMBI(spu_opcode_t op)
 {
-	c->mov(*qw0, SPU_OFF_64(gpr[op.ra]._u64[0]));
-	c->mov(*qw1, SPU_OFF_64(gpr[op.ra]._u64[1]));
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
+	c->mov(*qw0, SPU_OFF_64(gpr, op.ra, &v128::_u64, 0));
+	c->mov(*qw1, SPU_OFF_64(gpr, op.ra, &v128::_u64, 1));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->neg(*addr);
 	c->and_(*addr, 7);
 	c->shrd(*qw0, *qw1, *addr);
 	c->shr(*qw1, *addr);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[1]), *qw1);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw0);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw1);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 	c->unuse(*qw1);
@@ -1257,14 +1257,14 @@ void spu_recompiler::ROTQMBI(spu_opcode_t op)
 
 void spu_recompiler::SHLQBI(spu_opcode_t op)
 {
-	c->mov(*qw0, SPU_OFF_64(gpr[op.ra]._u64[0]));
-	c->mov(*qw1, SPU_OFF_64(gpr[op.ra]._u64[1]));
-	c->mov(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
+	c->mov(*qw0, SPU_OFF_64(gpr, op.ra, &v128::_u64, 0));
+	c->mov(*qw1, SPU_OFF_64(gpr, op.ra, &v128::_u64, 1));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 7);
 	c->shld(*qw1, *qw0, *addr);
 	c->shl(*qw0, *addr);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[1]), *qw1);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw0);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw1);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 	c->unuse(*qw1);
@@ -1274,11 +1274,11 @@ void spu_recompiler::ROTQBY(spu_opcode_t 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]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0xf);
 	c->shl(*addr, 4);
 	c->pshufb(va, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1287,12 +1287,12 @@ void spu_recompiler::ROTQMBY(spu_opcode_t 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]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->neg(*addr);
 	c->and_(*addr, 0x1f);
 	c->shl(*addr, 4);
 	c->pshufb(va, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
@@ -1301,26 +1301,26 @@ void spu_recompiler::SHLQBY(spu_opcode_t 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]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
 	c->and_(*addr, 0x1f);
 	c->shl(*addr, 4);
 	c->pshufb(va, asmjit::host::oword_ptr(*qw0, *addr));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
 
 void spu_recompiler::ORX(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[0]));
-	c->or_(*addr, SPU_OFF_32(gpr[op.ra]._u32[1]));
-	c->or_(*addr, SPU_OFF_32(gpr[op.ra]._u32[2]));
-	c->or_(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
-	c->mov(SPU_OFF_32(gpr[op.rt]._u32[3]), *addr);
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 0));
+	c->or_(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 1));
+	c->or_(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 2));
+	c->or_(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
+	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), *addr);
 	c->xor_(*addr, *addr);
-	c->mov(SPU_OFF_32(gpr[op.rt]._u32[0]), *addr);
-	c->mov(SPU_OFF_32(gpr[op.rt]._u32[1]), *addr);
-	c->mov(SPU_OFF_32(gpr[op.rt]._u32[2]), *addr);
+	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, 0), *addr);
+	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, 1), *addr);
+	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, 2), *addr);
 	c->unuse(*addr);
 }
 
@@ -1333,19 +1333,19 @@ void spu_recompiler::CBD(spu_opcode_t op)
 	//	v128 value = v128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
 	//	value.u8r[op.i7 & 0xf] = 0x03;
 	//	c->movdqa(vr, XmmConst(value));
-	//	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	//	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	//	return;
 	//}
 
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	if (op.i7) c->add(*addr, op.i7);
 	c->not_(*addr);
 	c->and_(*addr, 0xf);
 
 	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::host::byte_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), 0x03);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
+	c->mov(asmjit::host::byte_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x03);
 	c->unuse(*addr);
 }
 
@@ -1358,19 +1358,19 @@ void spu_recompiler::CHD(spu_opcode_t op)
 	//	v128 value = v128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
 	//	value.u16r[(op.i7 >> 1) & 0x7] = 0x0203;
 	//	c->movdqa(vr, XmmConst(value));
-	//	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	//	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	//	return;
 	//}
 
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	if (op.i7) c->add(*addr, op.i7);
 	c->not_(*addr);
 	c->and_(*addr, 0xe);
 
 	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::host::word_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), 0x0203);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
+	c->mov(asmjit::host::word_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x0203);
 	c->unuse(*addr);
 }
 
@@ -1383,19 +1383,19 @@ void spu_recompiler::CWD(spu_opcode_t op)
 	//	v128 value = v128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
 	//	value.u32r[(op.i7 >> 2) & 0x3] = 0x00010203;
 	//	c->movdqa(vr, XmmConst(value));
-	//	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	//	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	//	return;
 	//}
 
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	if (op.i7) c->add(*addr, op.i7);
 	c->not_(*addr);
 	c->and_(*addr, 0xc);
 
 	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::host::dword_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), 0x00010203);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
+	c->mov(asmjit::host::dword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), 0x00010203);
 	c->unuse(*addr);
 }
 
@@ -1408,33 +1408,33 @@ void spu_recompiler::CDD(spu_opcode_t op)
 	//	v128 value = v128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
 	//	value.u64r[(op.i7 >> 3) & 0x1] = 0x0001020304050607ull;
 	//	c->movdqa(vr, XmmConst(value));
-	//	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	//	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	//	return;
 	//}
 
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	if (op.i7) c->add(*addr, op.i7);
 	c->not_(*addr);
 	c->and_(*addr, 0x8);
 
 	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->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->mov(*qw0, asmjit::imm_u(0x0001020304050607));
-	c->mov(asmjit::host::qword_ptr(*cpu, *addr, 0, OFFSET_32(SPUThread, gpr[op.rt])), *qw0);
+	c->mov(asmjit::host::qword_ptr(*cpu, *addr, 0, offset32(&SPUThread::gpr, op.rt)), *qw0);
 	c->unuse(*addr);
 	c->unuse(*qw0);
 }
 
 void spu_recompiler::ROTQBII(spu_opcode_t op)
 {
-	c->mov(*qw0, SPU_OFF_64(gpr[op.ra]._u64[0]));
-	c->mov(*qw1, SPU_OFF_64(gpr[op.ra]._u64[1]));
+	c->mov(*qw0, SPU_OFF_64(gpr, op.ra, &v128::_u64, 0));
+	c->mov(*qw1, SPU_OFF_64(gpr, op.ra, &v128::_u64, 1));
 	c->mov(*qw2, *qw0);
 	c->shld(*qw0, *qw1, op.i7 & 0x7);
 	c->shld(*qw1, *qw2, op.i7 & 0x7);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[1]), *qw1);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw0);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw1);
 	c->unuse(*qw0);
 	c->unuse(*qw1);
 	c->unuse(*qw2);
@@ -1442,24 +1442,24 @@ void spu_recompiler::ROTQBII(spu_opcode_t op)
 
 void spu_recompiler::ROTQMBII(spu_opcode_t op)
 {
-	c->mov(*qw0, SPU_OFF_64(gpr[op.ra]._u64[0]));
-	c->mov(*qw1, SPU_OFF_64(gpr[op.ra]._u64[1]));
+	c->mov(*qw0, SPU_OFF_64(gpr, op.ra, &v128::_u64, 0));
+	c->mov(*qw1, SPU_OFF_64(gpr, op.ra, &v128::_u64, 1));
 	c->shrd(*qw0, *qw1, 0-op.i7 & 0x7);
 	c->shr(*qw1, 0-op.i7 & 0x7);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[1]), *qw1);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw0);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw1);
 	c->unuse(*qw0);
 	c->unuse(*qw1);
 }
 
 void spu_recompiler::SHLQBII(spu_opcode_t op)
 {
-	c->mov(*qw0, SPU_OFF_64(gpr[op.ra]._u64[0]));
-	c->mov(*qw1, SPU_OFF_64(gpr[op.ra]._u64[1]));
+	c->mov(*qw0, SPU_OFF_64(gpr, op.ra, &v128::_u64, 0));
+	c->mov(*qw1, SPU_OFF_64(gpr, op.ra, &v128::_u64, 1));
 	c->shld(*qw1, *qw0, op.i7 & 0x7);
 	c->shl(*qw0, op.i7 & 0x7);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._u64[1]), *qw1);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 0), *qw0);
+	c->mov(SPU_OFF_64(gpr, op.rt, &v128::_u64, 1), *qw1);
 	c->unuse(*qw0);
 	c->unuse(*qw1);
 }
@@ -1469,7 +1469,7 @@ void spu_recompiler::ROTQBYI(spu_opcode_t op)
 	const int s = op.i7 & 0xf;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->palignr(va, va, 16 - s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ROTQMBYI(spu_opcode_t op)
@@ -1477,7 +1477,7 @@ void spu_recompiler::ROTQMBYI(spu_opcode_t op)
 	const int s = 0-op.i7 & 0x1f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psrldq(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::SHLQBYI(spu_opcode_t op)
@@ -1485,7 +1485,7 @@ void spu_recompiler::SHLQBYI(spu_opcode_t op)
 	const int s = op.i7 & 0x1f;
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pslldq(va, s);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::NOP(spu_opcode_t op)
@@ -1495,38 +1495,38 @@ void spu_recompiler::NOP(spu_opcode_t op)
 void spu_recompiler::CGT(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pcmpgtd(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pcmpgtd(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::XOR(spu_opcode_t op)
 {
 	// xor
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pxor(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pxor(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CGTH(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pcmpgtw(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pcmpgtw(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::EQV(spu_opcode_t op)
 {
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
 	c->pxor(vb, XmmConst(_mm_set1_epi32(0xffffffff)));
-	c->pxor(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->pxor(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::CGTB(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pcmpgtb(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pcmpgtb(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::SUMB(spu_opcode_t op)
@@ -1539,14 +1539,14 @@ void spu_recompiler::SUMB(spu_opcode_t op)
 	c->pmaddubsw(vb, vi);
 	c->phaddw(va, vb);
 	c->pshufb(va, XmmConst(_mm_set_epi8(15, 14, 7, 6, 13, 12, 5, 4, 11, 10, 3, 2, 9, 8, 1, 0)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 //HGT uses signed values.  HLGT uses unsigned values
 void spu_recompiler::HGT(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._s32[3]));
-	c->cmp(*addr, SPU_OFF_32(gpr[op.rb]._s32[3]));
+	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);
@@ -1563,8 +1563,8 @@ void spu_recompiler::CLZ(spu_opcode_t op)
 		}
 	};
 
-	c->lea(*qw0, SPU_OFF_128(gpr[op.rt]));
-	c->lea(*qw1, SPU_OFF_128(gpr[op.ra]));
+	c->lea(*qw0, SPU_OFF_128(gpr, op.rt));
+	c->lea(*qw1, SPU_OFF_128(gpr, op.ra));
 	asmjit::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u32*, const u32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder2<void, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -1572,19 +1572,19 @@ void spu_recompiler::CLZ(spu_opcode_t op)
 	//c->mov(*qw0, 32 + 31);
 	//for (u32 i = 0; i < 4; i++) // unrolled loop
 	//{
-	//	c->bsr(*addr, SPU_OFF_32(gpr[op.ra]._u32[i]));
+	//	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]._u32[i]), *addr);
+	//	c->mov(SPU_OFF_32(gpr, op.rt, &v128::_u32, i), *addr);
 	//}
 }
 
 void spu_recompiler::XSWD(spu_opcode_t op)
 {
-	c->movsxd(*qw0, SPU_OFF_32(gpr[op.ra]._s32[0]));
-	c->movsxd(*qw1, SPU_OFF_32(gpr[op.ra]._s32[2]));
-	c->mov(SPU_OFF_64(gpr[op.rt]._s64[0]), *qw0);
-	c->mov(SPU_OFF_64(gpr[op.rt]._s64[1]), *qw1);
+	c->movsxd(*qw0, SPU_OFF_32(gpr, op.ra, &v128::_s32, 0));
+	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);
 }
@@ -1594,7 +1594,7 @@ void spu_recompiler::XSHW(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pslld(va, 16);
 	c->psrad(va, 16);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CNTB(spu_opcode_t op)
@@ -1612,7 +1612,7 @@ void spu_recompiler::CNTB(spu_opcode_t op)
 	c->movdqa(va, XmmConst(_mm_set_epi8(4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0)));
 	c->pshufb(va, v1);
 	c->paddb(va, vm);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::XSBH(spu_opcode_t op)
@@ -1620,7 +1620,7 @@ void spu_recompiler::XSBH(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psllw(va, 8);
 	c->psraw(va, 8);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CLGT(spu_opcode_t op)
@@ -1630,25 +1630,25 @@ void spu_recompiler::CLGT(spu_opcode_t op)
 	const XmmLink& vi = XmmAlloc();
 	c->movdqa(vi, XmmConst(_mm_set1_epi32(0x80000000)));
 	c->pxor(va, vi);
-	c->pxor(vi, SPU_OFF_128(gpr[op.rb]));
+	c->pxor(vi, SPU_OFF_128(gpr, op.rb));
 	c->pcmpgtd(va, vi);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ANDC(spu_opcode_t op)
 {
 	// and not
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
-	c->pandn(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->pandn(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::FCGT(spu_opcode_t op)
 {
 	// reverted less-than
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Float);
-	c->cmpps(vb, SPU_OFF_128(gpr[op.ra]), 1);
-	c->movaps(SPU_OFF_128(gpr[op.rt]), vb);
+	c->cmpps(vb, SPU_OFF_128(gpr, op.ra), 1);
+	c->movaps(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::DFCGT(spu_opcode_t op)
@@ -1659,22 +1659,22 @@ void spu_recompiler::DFCGT(spu_opcode_t op)
 void spu_recompiler::FA(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
-	c->addps(va, SPU_OFF_128(gpr[op.rb]));
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->addps(va, SPU_OFF_128(gpr, op.rb));
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FS(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
-	c->subps(va, SPU_OFF_128(gpr[op.rb]));
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->subps(va, SPU_OFF_128(gpr, op.rb));
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FM(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
-	c->mulps(va, SPU_OFF_128(gpr[op.rb]));
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->mulps(va, SPU_OFF_128(gpr, op.rb));
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CLGTH(spu_opcode_t op)
@@ -1684,17 +1684,17 @@ void spu_recompiler::CLGTH(spu_opcode_t op)
 	const XmmLink& vi = XmmAlloc();
 	c->movdqa(vi, XmmConst(_mm_set1_epi16(INT16_MIN)));
 	c->pxor(va, vi);
-	c->pxor(vi, SPU_OFF_128(gpr[op.rb]));
+	c->pxor(vi, SPU_OFF_128(gpr, op.rb));
 	c->pcmpgtw(va, vi);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ORC(spu_opcode_t op)
 {
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
 	c->pxor(vb, XmmConst(_mm_set1_epi32(0xffffffff)));
-	c->por(vb, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->por(vb, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::FCMGT(spu_opcode_t op)
@@ -1704,9 +1704,9 @@ void spu_recompiler::FCMGT(spu_opcode_t op)
 	const XmmLink& vi = XmmAlloc();
 	c->movaps(vi, XmmConst(_mm_set1_epi32(0x7fffffff)));
 	c->andps(vb, vi); // abs
-	c->andps(vi, SPU_OFF_128(gpr[op.ra]));
+	c->andps(vi, SPU_OFF_128(gpr, op.ra));
 	c->cmpps(vb, vi, 1);
-	c->movaps(SPU_OFF_128(gpr[op.rt]), vb);
+	c->movaps(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::DFCMGT(spu_opcode_t op)
@@ -1717,22 +1717,22 @@ void spu_recompiler::DFCMGT(spu_opcode_t op)
 void spu_recompiler::DFA(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
-	c->addpd(va, SPU_OFF_128(gpr[op.rb]));
-	c->movapd(SPU_OFF_128(gpr[op.rt]), va);
+	c->addpd(va, SPU_OFF_128(gpr, op.rb));
+	c->movapd(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::DFS(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
-	c->subpd(va, SPU_OFF_128(gpr[op.rb]));
-	c->movapd(SPU_OFF_128(gpr[op.rt]), va);
+	c->subpd(va, SPU_OFF_128(gpr, op.rb));
+	c->movapd(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::DFM(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
-	c->mulpd(va, SPU_OFF_128(gpr[op.rb]));
-	c->movapd(SPU_OFF_128(gpr[op.rt]), va);
+	c->mulpd(va, SPU_OFF_128(gpr, op.rb));
+	c->movapd(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CLGTB(spu_opcode_t op)
@@ -1742,15 +1742,15 @@ void spu_recompiler::CLGTB(spu_opcode_t op)
 	const XmmLink& vi = XmmAlloc();
 	c->movdqa(vi, XmmConst(_mm_set1_epi8(INT8_MIN)));
 	c->pxor(va, vi);
-	c->pxor(vi, SPU_OFF_128(gpr[op.rb]));
+	c->pxor(vi, SPU_OFF_128(gpr, op.rb));
 	c->pcmpgtb(va, vi);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::HLGT(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
-	c->cmp(*addr, SPU_OFF_32(gpr[op.rb]._u32[3]));
+	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);
@@ -1761,45 +1761,45 @@ void spu_recompiler::DFMA(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmGet(op.rt, XmmType::Double);
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
-	c->mulpd(va, SPU_OFF_128(gpr[op.rb]));
+	c->mulpd(va, SPU_OFF_128(gpr, op.rb));
 	c->addpd(vr, va);
-	c->movapd(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movapd(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::DFMS(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
 	const XmmLink& vt = XmmGet(op.rt, XmmType::Double);
-	c->mulpd(va, SPU_OFF_128(gpr[op.rb]));
+	c->mulpd(va, SPU_OFF_128(gpr, op.rb));
 	c->subpd(va, vt);
-	c->movapd(SPU_OFF_128(gpr[op.rt]), va);
+	c->movapd(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::DFNMS(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmGet(op.rt, XmmType::Double);
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
-	c->mulpd(va, SPU_OFF_128(gpr[op.rb]));
+	c->mulpd(va, SPU_OFF_128(gpr, op.rb));
 	c->subpd(vr, va);
-	c->movapd(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movapd(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::DFNMA(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
 	const XmmLink& vt = XmmGet(op.rt, XmmType::Double);
-	c->mulpd(va, SPU_OFF_128(gpr[op.rb]));
+	c->mulpd(va, SPU_OFF_128(gpr, op.rb));
 	c->addpd(vt, va);
 	c->xorpd(va, va);
 	c->subpd(va, vt);
-	c->movapd(SPU_OFF_128(gpr[op.rt]), va);
+	c->movapd(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CEQ(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pcmpeqd(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pcmpeqd(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::MPYHHU(spu_opcode_t op)
@@ -1813,16 +1813,16 @@ void spu_recompiler::MPYHHU(spu_opcode_t op)
 	c->pand(va, XmmConst(_mm_set1_epi32(0xffff0000)));
 	c->psrld(va2, 16);
 	c->por(va, va2);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ADDX(spu_opcode_t op)
 {
 	const XmmLink& vt = XmmGet(op.rt, XmmType::Int);
 	c->pand(vt, XmmConst(_mm_set1_epi32(1)));
-	c->paddd(vt, SPU_OFF_128(gpr[op.ra]));
-	c->paddd(vt, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->paddd(vt, SPU_OFF_128(gpr, op.ra));
+	c->paddd(vt, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 }
 
 void spu_recompiler::SFX(spu_opcode_t op)
@@ -1830,9 +1830,9 @@ void spu_recompiler::SFX(spu_opcode_t op)
 	const XmmLink& vt = XmmGet(op.rt, XmmType::Int);
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
 	c->pandn(vt, XmmConst(_mm_set1_epi32(1)));
-	c->psubd(vb, SPU_OFF_128(gpr[op.ra]));
+	c->psubd(vb, SPU_OFF_128(gpr, op.ra));
 	c->psubd(vb, vt);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vb);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::CGX(spu_opcode_t op) //nf
@@ -1845,9 +1845,9 @@ void spu_recompiler::CGX(spu_opcode_t op) //nf
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -1865,9 +1865,9 @@ void spu_recompiler::BGX(spu_opcode_t op) //nf
 		}
 	};
 
-	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]));
+	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::X86CallNode* call = c->call(asmjit::imm_ptr(asmjit_cast<void*, void(u32*, const u32*, const u32*)>(body)), asmjit::kFuncConvHost, asmjit::FuncBuilder3<void, void*, void*, void*>());
 	call->setArg(0, *qw0);
 	call->setArg(1, *qw1);
@@ -1883,7 +1883,7 @@ void spu_recompiler::MPYHHA(spu_opcode_t op)
 	c->psrld(vb, 16);
 	c->pmaddwd(va, vb);
 	c->paddd(vt, va);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 }
 
 void spu_recompiler::MPYHHAU(spu_opcode_t op)
@@ -1899,7 +1899,7 @@ void spu_recompiler::MPYHHAU(spu_opcode_t op)
 	c->psrld(va2, 16);
 	c->paddd(vt, va);
 	c->paddd(vt, va2);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 }
 
 void spu_recompiler::FSCRRD(spu_opcode_t op)
@@ -1907,7 +1907,7 @@ void spu_recompiler::FSCRRD(spu_opcode_t op)
 	// zero (hack)
 	const XmmLink& v0 = XmmAlloc();
 	c->pxor(v0, v0);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), v0);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), v0);
 }
 
 void spu_recompiler::FESD(spu_opcode_t op)
@@ -1915,7 +1915,7 @@ void spu_recompiler::FESD(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Float);
 	c->shufps(va, va, 0x8d); // _f[0] = _f[1]; _f[1] = _f[3];
 	c->cvtps2pd(va, va);
-	c->movapd(SPU_OFF_128(gpr[op.rt]), va);
+	c->movapd(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FRDS(spu_opcode_t op)
@@ -1923,7 +1923,7 @@ void spu_recompiler::FRDS(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Double);
 	c->cvtpd2ps(va, va);
 	c->shufps(va, va, 0x72); // _f[1] = _f[0]; _f[3] = _f[1]; _f[0] = _f[2] = 0;
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FSCRWR(spu_opcode_t op)
@@ -1940,8 +1940,8 @@ void spu_recompiler::FCEQ(spu_opcode_t op)
 {
 	// compare equal
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Float);
-	c->cmpps(vb, SPU_OFF_128(gpr[op.ra]), 0);
-	c->movaps(SPU_OFF_128(gpr[op.rt]), vb);
+	c->cmpps(vb, SPU_OFF_128(gpr, op.ra), 0);
+	c->movaps(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::DFCEQ(spu_opcode_t op)
@@ -1958,7 +1958,7 @@ void spu_recompiler::MPY(spu_opcode_t op)
 	c->pand(va, vi);
 	c->pand(vb, vi);
 	c->pmaddwd(va, vb);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::MPYH(spu_opcode_t op)
@@ -1968,7 +1968,7 @@ void spu_recompiler::MPYH(spu_opcode_t op)
 	c->psrld(va, 16);
 	c->pmullw(va, vb);
 	c->pslld(va, 16);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::MPYHH(spu_opcode_t op)
@@ -1978,7 +1978,7 @@ void spu_recompiler::MPYHH(spu_opcode_t op)
 	c->psrld(va, 16);
 	c->psrld(vb, 16);
 	c->pmaddwd(va, vb);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::MPYS(spu_opcode_t op)
@@ -1988,14 +1988,14 @@ void spu_recompiler::MPYS(spu_opcode_t op)
 	c->pmulhw(va, vb);
 	c->pslld(va, 16);
 	c->psrad(va, 16);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CEQH(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pcmpeqw(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pcmpeqw(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FCMEQ(spu_opcode_t op)
@@ -2004,9 +2004,9 @@ void spu_recompiler::FCMEQ(spu_opcode_t op)
 	const XmmLink& vi = XmmAlloc();
 	c->movaps(vi, XmmConst(_mm_set1_epi32(0x7fffffff)));
 	c->andps(vb, vi); // abs
-	c->andps(vi, SPU_OFF_128(gpr[op.ra]));
+	c->andps(vi, SPU_OFF_128(gpr, op.ra));
 	c->cmpps(vb, vi, 0); // ==
-	c->movaps(SPU_OFF_128(gpr[op.rt]), vb);
+	c->movaps(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::DFCMEQ(spu_opcode_t op)
@@ -2025,27 +2025,27 @@ void spu_recompiler::MPYU(spu_opcode_t op)
 	c->pslld(va, 16);
 	c->pand(va2, XmmConst(_mm_set1_epi32(0xffff)));
 	c->por(va, va2);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CEQB(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
-	c->pcmpeqb(va, SPU_OFF_128(gpr[op.rb]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->pcmpeqb(va, SPU_OFF_128(gpr, op.rb));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::FI(spu_opcode_t op)
 {
 	// Floating Interpolate
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Float);
-	c->movaps(SPU_OFF_128(gpr[op.rt]), vb);
+	c->movaps(SPU_OFF_128(gpr, op.rt), vb);
 }
 
 void spu_recompiler::HEQ(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._s32[3]));
-	c->cmp(*addr, SPU_OFF_32(gpr[op.rb]._s32[3]));
+	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);
@@ -2061,7 +2061,7 @@ void spu_recompiler::CFLTS(spu_opcode_t op)
 	c->cmpps(vi, va, 2);
 	c->cvttps2dq(va, va); // convert to ints with truncation
 	c->pxor(va, vi); // fix result saturation (0x80000000 -> 0x7fffffff)
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CFLTU(spu_opcode_t op)
@@ -2083,7 +2083,7 @@ void spu_recompiler::CFLTU(spu_opcode_t op)
 	c->cvttps2dq(vs2, vs2);
 	c->por(va, vs);
 	c->por(va, vs2);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CSFLT(spu_opcode_t op)
@@ -2091,7 +2091,7 @@ void spu_recompiler::CSFLT(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->cvtdq2ps(va, va); // convert to floats
 	if (op.i8 != 155) c->mulps(va, XmmConst(_mm_set1_ps(std::exp2(static_cast<float>(static_cast<s16>(op.i8 - 155)))))); // scale
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CUFLT(spu_opcode_t op)
@@ -2105,7 +2105,7 @@ void spu_recompiler::CUFLT(spu_opcode_t op)
 	c->andps(v1, XmmConst(_mm_set1_ps(std::exp2(31.f)))); // generate correction component
 	c->addps(va, v1); // add correction component
 	if (op.i8 != 155) c->mulps(va, XmmConst(_mm_set1_ps(std::exp2(static_cast<float>(static_cast<s16>(op.i8 - 155)))))); // scale
-	c->movaps(SPU_OFF_128(gpr[op.rt]), va);
+	c->movaps(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::BRZ(spu_opcode_t op)
@@ -2114,7 +2114,7 @@ void spu_recompiler::BRZ(spu_opcode_t op)
 
 	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
 
-	c->cmp(SPU_OFF_32(gpr[op.rt]._u32[3]), 0);
+	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
 
 	if (labels[target / 4].isInitialized())
 	{
@@ -2146,7 +2146,7 @@ void spu_recompiler::BRNZ(spu_opcode_t op)
 
 	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
 
-	c->cmp(SPU_OFF_32(gpr[op.rt]._u32[3]), 0);
+	c->cmp(SPU_OFF_32(gpr, op.rt, &v128::_u32, 3), 0);
 
 	if (labels[target / 4].isInitialized())
 	{
@@ -2171,7 +2171,7 @@ void spu_recompiler::BRHZ(spu_opcode_t op)
 
 	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
 
-	c->cmp(SPU_OFF_16(gpr[op.rt]._u16[6]), 0);
+	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
 
 	if (labels[target / 4].isInitialized())
 	{
@@ -2196,7 +2196,7 @@ void spu_recompiler::BRHNZ(spu_opcode_t op)
 
 	if (target == m_pos) fmt::throw_exception("Branch-to-self (0x%05x)" HERE, target);
 
-	c->cmp(SPU_OFF_16(gpr[op.rt]._u16[6]), 0);
+	c->cmp(SPU_OFF_16(gpr, op.rt, &v128::_u16, 6), 0);
 
 	if (labels[target / 4].isInitialized())
 	{
@@ -2250,7 +2250,7 @@ void spu_recompiler::LQA(spu_opcode_t op)
 	const XmmLink& vt = XmmAlloc();
 	c->movdqa(vt, asmjit::host::oword_ptr(*ls, spu_ls_target(0, op.i16)));
 	c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 }
 
 void spu_recompiler::BRASL(spu_opcode_t op)
@@ -2261,7 +2261,7 @@ void spu_recompiler::BRASL(spu_opcode_t op)
 
 	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->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->unuse(vr);
 
 	c->mov(SPU_OFF_32(pc), target);
@@ -2305,7 +2305,7 @@ void spu_recompiler::FSMBI(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(g_spu_imm.fsmb[op.i16]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::BRSL(spu_opcode_t op)
@@ -2316,7 +2316,7 @@ void spu_recompiler::BRSL(spu_opcode_t op)
 
 	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->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 	c->unuse(vr);
 
 	if (target == spu_branch_target(m_pos + 4))
@@ -2335,93 +2335,93 @@ void spu_recompiler::LQR(spu_opcode_t op)
 	const XmmLink& vt = XmmAlloc();
 	c->movdqa(vt, asmjit::host::oword_ptr(*ls, spu_ls_target(m_pos, op.i16)));
 	c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 }
 
 void spu_recompiler::IL(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set1_epi32(op.si16)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::ILHU(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set1_epi32(op.i16 << 16)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::ILH(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set1_epi16(op.i16)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::IOHL(spu_opcode_t op)
 {
 	const XmmLink& vt = XmmGet(op.rt, XmmType::Int);
 	c->por(vt, XmmConst(_mm_set1_epi32(op.i16)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 }
 
 void spu_recompiler::ORI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	if (op.si10) c->por(va, XmmConst(_mm_set1_epi32(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ORHI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->por(va, XmmConst(_mm_set1_epi16(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ORBI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->por(va, XmmConst(_mm_set1_epi8(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::SFI(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set1_epi32(op.si10)));
-	c->psubd(vr, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->psubd(vr, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::SFHI(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set1_epi16(op.si10)));
-	c->psubw(vr, SPU_OFF_128(gpr[op.ra]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->psubw(vr, SPU_OFF_128(gpr, op.ra));
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::ANDI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pand(va, XmmConst(_mm_set1_epi32(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ANDHI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pand(va, XmmConst(_mm_set1_epi16(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::ANDBI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pand(va, XmmConst(_mm_set1_epi8(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::AI(spu_opcode_t op)
@@ -2429,7 +2429,7 @@ void spu_recompiler::AI(spu_opcode_t op)
 	// add
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->paddd(va, XmmConst(_mm_set1_epi32(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::AHI(spu_opcode_t op)
@@ -2437,12 +2437,12 @@ void spu_recompiler::AHI(spu_opcode_t op)
 	// add
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->paddw(va, XmmConst(_mm_set1_epi16(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::STQD(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	if (op.si10) c->add(*addr, op.si10 << 4);
 	c->and_(*addr, 0x3fff0);
 
@@ -2454,14 +2454,14 @@ void spu_recompiler::STQD(spu_opcode_t op)
 
 void spu_recompiler::LQD(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	if (op.si10) c->add(*addr, op.si10 << 4);
 	c->and_(*addr, 0x3fff0);
 
 	const XmmLink& vt = XmmAlloc();
 	c->movdqa(vt, asmjit::host::oword_ptr(*ls, *addr));
 	c->pshufb(vt, XmmConst(_mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vt);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vt);
 	c->unuse(*addr);
 }
 
@@ -2469,47 +2469,47 @@ void spu_recompiler::XORI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pxor(va, XmmConst(_mm_set1_epi32(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::XORHI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pxor(va, XmmConst(_mm_set1_epi16(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::XORBI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pxor(va, XmmConst(_mm_set1_epi8(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CGTI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pcmpgtd(va, XmmConst(_mm_set1_epi32(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CGTHI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pcmpgtw(va, XmmConst(_mm_set1_epi16(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CGTBI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pcmpgtb(va, XmmConst(_mm_set1_epi8(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::HGTI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._s32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_s32, 3));
 	c->cmp(*addr, op.si10);
 
 	c->mov(*addr, m_pos | 0x1000000);
@@ -2522,7 +2522,7 @@ void spu_recompiler::CLGTI(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pxor(va, XmmConst(_mm_set1_epi32(0x80000000)));
 	c->pcmpgtd(va, XmmConst(_mm_set1_epi32(op.si10 - 0x80000000)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CLGTHI(spu_opcode_t op)
@@ -2530,7 +2530,7 @@ void spu_recompiler::CLGTHI(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pxor(va, XmmConst(_mm_set1_epi16(INT16_MIN)));
 	c->pcmpgtw(va, XmmConst(_mm_set1_epi16(op.si10 - 0x8000)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CLGTBI(spu_opcode_t op)
@@ -2538,12 +2538,12 @@ void spu_recompiler::CLGTBI(spu_opcode_t op)
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->psubb(va, XmmConst(_mm_set1_epi8(INT8_MIN)));
 	c->pcmpgtb(va, XmmConst(_mm_set1_epi8(op.si10 - 0x80)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::HLGTI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->cmp(*addr, op.si10);
 
 	c->mov(*addr, m_pos | 0x1000000);
@@ -2555,7 +2555,7 @@ void spu_recompiler::MPYI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pmaddwd(va, XmmConst(_mm_set1_epi32(op.si10 & 0xffff)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::MPYUI(spu_opcode_t op)
@@ -2569,33 +2569,33 @@ void spu_recompiler::MPYUI(spu_opcode_t op)
 	c->pmullw(va2, vi);
 	c->pslld(va, 16);
 	c->por(va, va2);
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CEQI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pcmpeqd(va, XmmConst(_mm_set1_epi32(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CEQHI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pcmpeqw(va, XmmConst(_mm_set1_epi16(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::CEQBI(spu_opcode_t op)
 {
 	const XmmLink& va = XmmGet(op.ra, XmmType::Int);
 	c->pcmpeqb(va, XmmConst(_mm_set1_epi8(op.si10)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), va);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), va);
 }
 
 void spu_recompiler::HEQI(spu_opcode_t op)
 {
-	c->mov(*addr, SPU_OFF_32(gpr[op.ra]._u32[3]));
+	c->mov(*addr, SPU_OFF_32(gpr, op.ra, &v128::_u32, 3));
 	c->cmp(*addr, op.si10);
 
 	c->mov(*addr, m_pos | 0x1000000);
@@ -2615,7 +2615,7 @@ void spu_recompiler::ILA(spu_opcode_t op)
 {
 	const XmmLink& vr = XmmAlloc();
 	c->movdqa(vr, XmmConst(_mm_set1_epi32(op.i18)));
-	c->movdqa(SPU_OFF_128(gpr[op.rt]), vr);
+	c->movdqa(SPU_OFF_128(gpr, op.rt), vr);
 }
 
 void spu_recompiler::SELB(spu_opcode_t op)
@@ -2623,9 +2623,9 @@ void spu_recompiler::SELB(spu_opcode_t op)
 	const XmmLink& vb = XmmGet(op.rb, XmmType::Int);
 	const XmmLink& vc = XmmGet(op.rc, XmmType::Int);
 	c->pand(vb, vc);
-	c->pandn(vc, SPU_OFF_128(gpr[op.ra]));
+	c->pandn(vc, SPU_OFF_128(gpr, op.ra));
 	c->por(vb, vc);
-	c->movdqa(SPU_OFF_128(gpr[op.rt4]), vb);
+	c->movdqa(SPU_OFF_128(gpr, op.rt4), vb);
 }
 
 void spu_recompiler::SHUFB(spu_opcode_t op)
@@ -2655,16 +2655,16 @@ void spu_recompiler::SHUFB(spu_opcode_t op)
 	c->movdqa(v2, XmmConst(_mm_set1_epi8(0x0f))); //   v2 = 00001111
 	c->pxor(v1, XmmConst(_mm_set1_epi8(0x10))); //   v1 = (mask & 00011111) ^ 00010000
 	c->psubb(v2, v1); //                 v2 = 00001111 - ((mask & 00011111) ^ 00010000)
-	c->movdqa(v1, SPU_OFF_128(gpr[op.rb])); //        v1 = op.rb
+	c->movdqa(v1, SPU_OFF_128(gpr, op.rb)); //        v1 = op.rb
 	c->pshufb(v1, v2); //                v1 = select(op.rb, 00001111 - ((mask & 00011111) ^ 00010000))
 	// select bytes from [op.ra]:
 	c->pxor(v2, XmmConst(_mm_set1_epi8(-0x10))); //   v2 = (00001111 - ((mask & 00011111) ^ 00010000)) ^ 11110000
-	c->movdqa(v3, SPU_OFF_128(gpr[op.ra])); //        v3 = op.ra
+	c->movdqa(v3, SPU_OFF_128(gpr, op.ra)); //        v3 = op.ra
 	c->pshufb(v3, v2); //                v3 = select(op.ra, (00001111 - ((mask & 00011111) ^ 00010000)) ^ 11110000)
 	c->por(v1, v3); //                   v1 = select(op.rb, 00001111 - ((mask & 00011111) ^ 00010000)) | (v3)
 	c->pandn(v4, v1); // filter result   v4 = v1 & ((mask & 10000000 == 10000000) ? 0 : 0xff)
 	c->por(vFF, v4); // final merge      vFF = (mask & 10000000 == 10000000) ? ((mask & 11100000 == 11000000) ? 0xff : (mask & 11100000 == 11100000) ? 0x80 : 0) : (v1)
-	c->movdqa(SPU_OFF_128(gpr[op.rt4]), vFF);
+	c->movdqa(SPU_OFF_128(gpr, op.rt4), vFF);
 }
 
 void spu_recompiler::MPYA(spu_opcode_t op)
@@ -2676,8 +2676,8 @@ void spu_recompiler::MPYA(spu_opcode_t op)
 	c->pand(va, vi);
 	c->pand(vb, vi);
 	c->pmaddwd(va, vb);
-	c->paddd(va, SPU_OFF_128(gpr[op.rc]));
-	c->movdqa(SPU_OFF_128(gpr[op.rt4]), va);
+	c->paddd(va, SPU_OFF_128(gpr, op.rc));
+	c->movdqa(SPU_OFF_128(gpr, op.rt4), va);
 }
 
 void spu_recompiler::FNMS(spu_opcode_t op)
@@ -2689,18 +2689,18 @@ void spu_recompiler::FNMS(spu_opcode_t op)
 	const XmmLink& tmp_b = XmmAlloc();
 
 	c->movdqa(tmp_a, mask);                     //tmp_a = mask
-	c->andps(tmp_a, SPU_OFF_128(gpr[op.ra]));   //tmp_a = a & mask
+	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra));   //tmp_a = a & mask
 	c->cmpps(tmp_a, mask, 4);                   //tmp_a = tmp_a != mask
-	c->andps(tmp_a, SPU_OFF_128(gpr[op.ra]));   //tmp_a = mask_a & va
+	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra));   //tmp_a = mask_a & va
 
 	c->movdqa(tmp_b, mask);                      //tmp_b = mask
-	c->andps(tmp_b, SPU_OFF_128(gpr[op.rb]));    //tmp_b = b & mask
+	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb));    //tmp_b = b & mask
 	c->cmpps(tmp_b, mask, 4);                    //tmp_b = tmp_b != mask
-	c->andps(tmp_b, SPU_OFF_128(gpr[op.rb]));    //tmp_b = mask_b & vb
+	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb));    //tmp_b = mask_b & vb
 
 	c->mulps(tmp_a, tmp_b);
 	c->subps(vc, tmp_a);
-	c->movaps(SPU_OFF_128(gpr[op.rt4]), vc);
+	c->movaps(SPU_OFF_128(gpr, op.rt4), vc);
 }
 
 void spu_recompiler::FMA(spu_opcode_t op)
@@ -2712,18 +2712,18 @@ void spu_recompiler::FMA(spu_opcode_t op)
 	const XmmLink& tmp_b = XmmAlloc();
 
 	c->movdqa(tmp_a, mask);                     //tmp_a = mask
-	c->andps(tmp_a, SPU_OFF_128(gpr[op.ra]));   //tmp_a = a & mask
+	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra));   //tmp_a = a & mask
 	c->cmpps(tmp_a, mask, 4);                   //tmp_a = tmp_a != mask
-	c->andps(tmp_a, SPU_OFF_128(gpr[op.ra]));   //tmp_a = mask_a & va
+	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra));   //tmp_a = mask_a & va
 
 	c->movdqa(tmp_b, mask);                      //tmp_b = mask
-	c->andps(tmp_b, SPU_OFF_128(gpr[op.rb]));    //tmp_b = b & mask
+	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb));    //tmp_b = b & mask
 	c->cmpps(tmp_b, mask, 4);                    //tmp_b = tmp_b != mask
-	c->andps(tmp_b, SPU_OFF_128(gpr[op.rb]));    //tmp_b = mask_b & vb
+	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb));    //tmp_b = mask_b & vb
 
 	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->addps(tmp_a, SPU_OFF_128(gpr, op.rc));
+	c->movaps(SPU_OFF_128(gpr, op.rt4), tmp_a);
 }
 
 void spu_recompiler::FMS(spu_opcode_t op)
@@ -2735,18 +2735,18 @@ void spu_recompiler::FMS(spu_opcode_t op)
 	const XmmLink& tmp_b = XmmAlloc();
 
 	c->movdqa(tmp_a, mask);                     //tmp_a = mask
-	c->andps(tmp_a, SPU_OFF_128(gpr[op.ra]));   //tmp_a = a & mask
+	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra));   //tmp_a = a & mask
 	c->cmpps(tmp_a, mask, 4);                   //tmp_a = tmp_a != mask
-	c->andps(tmp_a, SPU_OFF_128(gpr[op.ra]));   //tmp_a = mask_a & va
+	c->andps(tmp_a, SPU_OFF_128(gpr, op.ra));   //tmp_a = mask_a & va
 
 	c->movdqa(tmp_b, mask);                      //tmp_b = mask
-	c->andps(tmp_b, SPU_OFF_128(gpr[op.rb]));    //tmp_b = b & mask
+	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb));    //tmp_b = b & mask
 	c->cmpps(tmp_b, mask, 4);                    //tmp_b = tmp_b != mask
-	c->andps(tmp_b, SPU_OFF_128(gpr[op.rb]));    //tmp_b = mask_b & vb
+	c->andps(tmp_b, SPU_OFF_128(gpr, op.rb));    //tmp_b = mask_b & vb
 
 	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);
+	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)
diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
index 019302bceb..b0bd873d18 100644
--- a/rpcs3/Emu/Memory/vm.h
+++ b/rpcs3/Emu/Memory/vm.h
@@ -188,12 +188,6 @@ namespace vm
 		fmt::throw_exception("Not a virtual memory pointer (%p)", real_ptr);
 	}
 
-	// Convert pointer-to-member to a vm address compatible offset
-	template<typename MT, typename T> inline u32 get_offset(MT T::*const member_ptr)
-	{
-		return static_cast<u32>(reinterpret_cast<std::uintptr_t>(&reinterpret_cast<char const volatile&>(reinterpret_cast<T*>(0ull)->*member_ptr)));
-	}
-
 	template<typename T>
 	struct cast_impl
 	{
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 7f4c31c9d9..2b3403853d 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -60,31 +60,31 @@ namespace vm
 		}
 
 		// Get vm pointer to a struct member
-		template<typename MT, typename T2, typename = if_comparable_t<T, T2>>
+		template <typename MT, typename T2, typename = if_comparable_t<T, T2>>
 		_ptr_base<MT> ptr(MT T2::*const mptr) const
 		{
-			return vm::cast(vm::cast(m_addr, HERE) + get_offset(mptr));
+			return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr));
 		}
 
 		// Get vm pointer to a struct member with array subscription
-		template<typename MT, typename T2, typename ET = std::remove_extent_t<MT>, typename = if_comparable_t<T, T2>>
+		template <typename MT, typename T2, typename ET = std::remove_extent_t<MT>, typename = if_comparable_t<T, T2>>
 		_ptr_base<ET> ptr(MT T2::*const mptr, u32 index) const
 		{
-			return vm::cast(vm::cast(m_addr, HERE) + get_offset(mptr) + SIZE_32(ET) * index);
+			return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr) + SIZE_32(ET) * index);
 		}
 
 		// Get vm reference to a struct member
-		template<typename MT, typename T2, typename = if_comparable_t<T, T2>>
+		template <typename MT, typename T2, typename = if_comparable_t<T, T2>>
 		_ref_base<MT> ref(MT T2::*const mptr) const
 		{
-			return vm::cast(vm::cast(m_addr, HERE) + get_offset(mptr));
+			return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr));
 		}
 
 		// Get vm reference to a struct member with array subscription
-		template<typename MT, typename T2, typename ET = std::remove_extent_t<MT>, typename = if_comparable_t<T, T2>>
+		template <typename MT, typename T2, typename ET = std::remove_extent_t<MT>, typename = if_comparable_t<T, T2>>
 		_ref_base<ET> ref(MT T2::*const mptr, u32 index) const
 		{
-			return vm::cast(vm::cast(m_addr, HERE) + get_offset(mptr) + SIZE_32(ET) * index);
+			return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr) + SIZE_32(ET) * index);
 		}
 
 		// Get vm reference