From b30df474998340a76748e90274c3bbeaaa99032f Mon Sep 17 00:00:00 2001
From: Jonathan Russell <russj159@yahoo.co.uk>
Date: Tue, 14 Aug 2018 13:02:56 +0100
Subject: [PATCH 1/2] - adds OP_EQ_R, the first instruction using jumps

---
 src/scripting/vm/jit.cpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/src/scripting/vm/jit.cpp b/src/scripting/vm/jit.cpp
index cedaffb920..e31bbf4493 100644
--- a/src/scripting/vm/jit.cpp
+++ b/src/scripting/vm/jit.cpp
@@ -309,6 +309,11 @@ JitFuncPtr JitCompile(VMScriptFunction *sfunc)
 		*/
 
 		int size = sfunc->CodeSize;
+
+		TArray<Label> labels(size, true);
+
+		for (int i = 0; i < size; i++) labels[i] = cc.newLabel();
+
 		for (int i = 0; i < size; i++)
 		{
 			const VMOP *pc = sfunc->Code + i;
@@ -316,6 +321,8 @@ JitFuncPtr JitCompile(VMScriptFunction *sfunc)
 			int a = pc->a;
 			int b;// , c;
 
+			cc.bind(labels[i]);
+
 			switch (op)
 			{
 			default:
@@ -905,6 +912,29 @@ JitFuncPtr JitCompile(VMScriptFunction *sfunc)
 				cc.not_(regD[a]);
 				break;
 			case OP_EQ_R: // if ((dB == dkC) != A) then pc++
+			{
+				Label elseLabel = cc.newLabel();
+
+				auto tmp0 = cc.newInt32();
+				auto tmp1 = cc.newInt32();
+
+				cc.cmp(regD[B], regD[C]);
+				cc.sete(tmp0);
+
+				cc.mov(tmp1, A);
+				cc.and_(tmp1, CMP_CHECK);
+				cc.setz(tmp1);
+
+				cc.cmp(tmp0, tmp1);
+				cc.je(elseLabel);
+
+				cc.jmp(labels[i + 2 + JMPOFS(pc + 1)]);
+
+				cc.bind(elseLabel);
+				cc.jmp(labels[i + 2]);
+
+				break;
+			}
 			case OP_EQ_K:
 			case OP_LT_RR: // if ((dkB < dkC) != A) then pc++
 			case OP_LT_RK:

From 167693f102ea16912cafbbaf32c956df44331901 Mon Sep 17 00:00:00 2001
From: Jonathan Russell <russj159@yahoo.co.uk>
Date: Tue, 14 Aug 2018 15:07:09 +0100
Subject: [PATCH 2/2] - implemented all integer comparison operators

---
 src/scripting/vm/jit.cpp | 196 ++++++++++++++++++++++++++++++++-------
 1 file changed, 165 insertions(+), 31 deletions(-)

diff --git a/src/scripting/vm/jit.cpp b/src/scripting/vm/jit.cpp
index e31bbf4493..341ce7c96b 100644
--- a/src/scripting/vm/jit.cpp
+++ b/src/scripting/vm/jit.cpp
@@ -8,6 +8,7 @@
 
 #include <asmjit/asmjit.h>
 #include <asmjit/x86.h>
+#include <functional>
 
 class AsmJitException : public std::exception
 {
@@ -221,6 +222,29 @@ static bool CanJit(VMScriptFunction *sfunc)
 	return true;
 }
 
+template <typename Func>
+void emitComparisonOpcode(asmjit::X86Compiler& cc, const TArray<asmjit::Label>& labels, const VMOP* pc, int i, Func compFunc) {
+	using namespace asmjit;
+
+	Label elseLabel = cc.newLabel();
+
+	auto tmp0 = cc.newInt32();
+	auto tmp1 = cc.newInt32();
+
+	compFunc(tmp0);
+
+	cc.mov(tmp1, A);
+	cc.and_(tmp1, CMP_CHECK);
+
+	cc.cmp(tmp0, tmp1);
+	cc.jne(elseLabel);
+
+	cc.jmp(labels[i + 2 + JMPOFS(pc + 1)]);
+
+	cc.bind(elseLabel);
+	cc.jmp(labels[i + 2]);
+}
+
 JitFuncPtr JitCompile(VMScriptFunction *sfunc)
 {
 #if 0 // For debugging
@@ -913,42 +937,152 @@ JitFuncPtr JitCompile(VMScriptFunction *sfunc)
 				break;
 			case OP_EQ_R: // if ((dB == dkC) != A) then pc++
 			{
-				Label elseLabel = cc.newLabel();
-
-				auto tmp0 = cc.newInt32();
-				auto tmp1 = cc.newInt32();
-
-				cc.cmp(regD[B], regD[C]);
-				cc.sete(tmp0);
-
-				cc.mov(tmp1, A);
-				cc.and_(tmp1, CMP_CHECK);
-				cc.setz(tmp1);
-
-				cc.cmp(tmp0, tmp1);
-				cc.je(elseLabel);
-
-				cc.jmp(labels[i + 2 + JMPOFS(pc + 1)]);
-
-				cc.bind(elseLabel);
-				cc.jmp(labels[i + 2]);
+				auto compLambda = [&] (X86Gp& result) {
+					cc.cmp(regD[B], regD[C]);
+					cc.sete(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
 
 				break;
 			}
 			case OP_EQ_K:
-			case OP_LT_RR: // if ((dkB < dkC) != A) then pc++
-			case OP_LT_RK:
-			case OP_LT_KR:
-			case OP_LE_RR: // if ((dkB <= dkC) != A) then pc++
-			case OP_LE_RK:
-			case OP_LE_KR:
-			case OP_LTU_RR: // if ((dkB < dkC) != A) then pc++		-- unsigned
-			case OP_LTU_RK:
-			case OP_LTU_KR:
-			case OP_LEU_RR: // if ((dkB <= dkC) != A) then pc++		-- unsigned
-			case OP_LEU_RK:
-			case OP_LEU_KR:
+			{
+				auto compLambda = [&] (X86Gp& result) { 
+					cc.cmp(regD[B], konstd[C]);
+					cc.sete(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
 				break;
+			}
+			case OP_LT_RR: // if ((dkB < dkC) != A) then pc++
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], regD[C]);
+					cc.setl(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LT_RK:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], konstd[C]);
+					cc.setl(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LT_KR:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					auto tmp = cc.newIntPtr();
+					cc.mov(tmp, reinterpret_cast<ptrdiff_t>(&(konstd[C])));
+					cc.cmp(x86::ptr(tmp), regD[B]);
+					cc.setl(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LE_RR: // if ((dkB <= dkC) != A) then pc++
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], regD[C]);
+					cc.setle(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LE_RK:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], konstd[C]);
+					cc.setle(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LE_KR:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					auto tmp = cc.newIntPtr();
+					cc.mov(tmp, reinterpret_cast<ptrdiff_t>(&(konstd[C])));
+					cc.cmp(x86::ptr(tmp), regD[B]);
+					cc.setle(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LTU_RR: // if ((dkB < dkC) != A) then pc++		-- unsigned
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], regD[C]);
+					cc.setb(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LTU_RK:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], konstd[C]);
+					cc.setb(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LTU_KR:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					auto tmp = cc.newIntPtr();
+					cc.mov(tmp, reinterpret_cast<ptrdiff_t>(&(konstd[C])));
+					cc.cmp(x86::ptr(tmp), regD[B]);
+					cc.setb(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LEU_RR: // if ((dkB <= dkC) != A) then pc++		-- unsigned
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], regD[C]);
+					cc.setbe(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LEU_RK:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					cc.cmp(regD[B], konstd[C]);
+					cc.setbe(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
+			case OP_LEU_KR:
+			{
+				auto compLambda = [&](X86Gp& result) {
+					auto tmp = cc.newIntPtr();
+					cc.mov(tmp, reinterpret_cast<ptrdiff_t>(&(konstd[C])));
+					cc.cmp(x86::ptr(tmp), regD[B]);
+					cc.setbe(result);
+				};
+				emitComparisonOpcode(cc, labels, pc, i, compLambda);
+
+				break;
+			}
 
 			// Double-precision floating point math.
 			case OP_ADDF_RR: // fA = fB + fkC