From f708f0452dc339ecd244bd37198de6701837c4ee Mon Sep 17 00:00:00 2001
From: SimoneN64 <simococo03@gmail.com>
Date: Sat, 12 Aug 2023 15:42:56 +0200
Subject: [PATCH] Fix last linking issues

---
 src/backend/core/registers/Cop0.cpp           |  9 ++++--
 src/backend/core/registers/Cop1.cpp           |  7 +++--
 src/backend/core/registers/Cop1.hpp           | 16 +++++++---
 .../core/registers/cop/cop1instructions.cpp   | 30 ++++++++++++++-----
 4 files changed, 45 insertions(+), 17 deletions(-)

diff --git a/src/backend/core/registers/Cop0.cpp b/src/backend/core/registers/Cop0.cpp
index 575f7d21..e56c468e 100644
--- a/src/backend/core/registers/Cop0.cpp
+++ b/src/backend/core/registers/Cop0.cpp
@@ -325,15 +325,18 @@ ExceptionCode GetTLBExceptionCode(TLBError error, TLBAccessType accessType) {
 
 template<class T>
 void Cop0::decode(T& cpu, u32 instr) {
-  if constexpr (std::is_same_v<decltype(cpu), Interpreter>()) {
-    decodeInterpreter(cpu.regs, instr);
-  } else if constexpr (std::is_same_v<decltype(cpu), JIT>()) {
+  if constexpr (std::is_same_v<decltype(cpu), Interpreter&>) {
+    decodeInterp(cpu.regs, instr);
+  } else if constexpr (std::is_same_v<decltype(cpu), JIT&>) {
     decodeJIT(cpu, instr);
   } else {
     Util::panic("What the fuck did you just give me?!!");
   }
 }
 
+template void Cop0::decode<Interpreter>(Interpreter&, u32);
+template void Cop0::decode<JIT>(JIT&, u32);
+
 void Cop0::decodeJIT(JIT& cpu, u32 instr) {
 
 }
diff --git a/src/backend/core/registers/Cop1.cpp b/src/backend/core/registers/Cop1.cpp
index bdac2fe1..e82598ff 100644
--- a/src/backend/core/registers/Cop1.cpp
+++ b/src/backend/core/registers/Cop1.cpp
@@ -17,15 +17,18 @@ void Cop1::Reset() {
 
 template <class T>
 void Cop1::decode(T& cpu, u32 instr) {
-  if constexpr (std::is_same_v<decltype(cpu), Interpreter>()) {
+  if constexpr (std::is_same_v<decltype(cpu), Interpreter&>) {
     decodeInterp(cpu, instr);
-  } else if constexpr (std::is_same_v<decltype(cpu), JIT>()) {
+  } else if constexpr (std::is_same_v<decltype(cpu), JIT&>) {
     decodeJIT(cpu, instr);
   } else {
     Util::panic("What the fuck did you just give me?!");
   }
 }
 
+template void Cop1::decode<Interpreter>(Interpreter&, u32);
+template void Cop1::decode<JIT>(JIT&, u32);
+
 void Cop1::decodeInterp(Interpreter &cpu, u32 instr) {
   Registers &regs = cpu.regs;
   if(!regs.cop0.status.cu1) {
diff --git a/src/backend/core/registers/Cop1.hpp b/src/backend/core/registers/Cop1.hpp
index d5544c0a..9d463289 100644
--- a/src/backend/core/registers/Cop1.hpp
+++ b/src/backend/core/registers/Cop1.hpp
@@ -203,10 +203,18 @@ private:
   void swc1Interp(Registers&, Mem&, u32);
   void ldc1Interp(Registers&, Mem&, u32);
   void sdc1Interp(Registers&, Mem&, u32);
-  void lwc1JIT(JIT&, Mem&, u32);
-  void swc1JIT(JIT&, Mem&, u32);
-  void ldc1JIT(JIT&, Mem&, u32);
-  void sdc1JIT(JIT&, Mem&, u32);
+  void lwc1JIT(JIT&, Mem&, u32) {
+    Util::panic("[JIT]: lwc1 not implemented!");
+  }
+  void swc1JIT(JIT&, Mem&, u32) {
+    Util::panic("[JIT]: swc1 not implemented!");
+  }
+  void ldc1JIT(JIT&, Mem&, u32) {
+    Util::panic("[JIT]: ldc1 not implemented!");
+  }
+  void sdc1JIT(JIT&, Mem&, u32) {
+    Util::panic("[JIT]: sdc1 not implemented!");
+  }
   void mfc1(Registers&, u32 instr);
   void dmfc1(Registers&, u32 instr);
   void mtc1(Registers&, u32 instr);
diff --git a/src/backend/core/registers/cop/cop1instructions.cpp b/src/backend/core/registers/cop/cop1instructions.cpp
index 1f182cd9..fd494ec0 100644
--- a/src/backend/core/registers/cop/cop1instructions.cpp
+++ b/src/backend/core/registers/cop/cop1instructions.cpp
@@ -1,5 +1,7 @@
 #include <core/registers/Cop1.hpp>
 #include <core/registers/Registers.hpp>
+#include <core/Interpreter.hpp>
+#include <core/JIT.hpp>
 #include <core/Mem.hpp>
 #include <cmath>
 #include <cfenv>
@@ -445,48 +447,60 @@ void Cop1::floorwd(Registers& regs, u32 instr) {
 
 template<class T>
 void Cop1::lwc1(T &cpu, Mem &mem, u32 instr) {
-  if constexpr(std::is_same_v<decltype(cpu), Interpreter>()) {
+  if constexpr(std::is_same_v<decltype(cpu), Interpreter&>) {
     lwc1Interp(cpu.regs, mem, instr);
-  } else if(std::is_same_v<decltype(cpu), JIT>()) {
+  } else if constexpr (std::is_same_v<decltype(cpu), JIT&>) {
     lwc1JIT(cpu, mem, instr);
   } else {
     Util::panic("What the fuck did you just give me?!!");
   }
 }
 
+template void Cop1::lwc1<Interpreter>(Interpreter&, Mem&, u32);
+template void Cop1::lwc1<JIT>(JIT&, Mem&, u32);
+
 template<class T>
 void Cop1::swc1(T &cpu, Mem &mem, u32 instr) {
-  if constexpr(std::is_same_v<decltype(cpu), Interpreter>()) {
+  if constexpr(std::is_same_v<decltype(cpu), Interpreter&>) {
     swc1Interp(cpu.regs, mem, instr);
-  } else if(std::is_same_v<decltype(cpu), JIT>()) {
+  } else if constexpr (std::is_same_v<decltype(cpu), JIT&>) {
     swc1JIT(cpu, mem, instr);
   } else {
     Util::panic("What the fuck did you just give me?!!");
   }
 }
 
+template void Cop1::swc1<Interpreter>(Interpreter&, Mem&, u32);
+template void Cop1::swc1<JIT>(JIT&, Mem&, u32);
+
 template<class T>
 void Cop1::ldc1(T &cpu, Mem &mem, u32 instr) {
-  if constexpr(std::is_same_v<decltype(cpu), Interpreter>()) {
+  if constexpr(std::is_same_v<decltype(cpu), Interpreter&>) {
     ldc1Interp(cpu.regs, mem, instr);
-  } else if(std::is_same_v<decltype(cpu), JIT>()) {
+  } else if constexpr (std::is_same_v<decltype(cpu), JIT&>) {
     ldc1JIT(cpu, mem, instr);
   } else {
     Util::panic("What the fuck did you just give me?!!");
   }
 }
 
+template void Cop1::ldc1<Interpreter>(Interpreter&, Mem&, u32);
+template void Cop1::ldc1<JIT>(JIT&, Mem&, u32);
+
 template<class T>
 void Cop1::sdc1(T &cpu, Mem &mem, u32 instr) {
-  if constexpr(std::is_same_v<decltype(cpu), Interpreter>()) {
+  if constexpr(std::is_same_v<decltype(cpu), Interpreter&>) {
     sdc1Interp(cpu.regs, mem, instr);
-  } else if(std::is_same_v<decltype(cpu), JIT>()) {
+  } else if constexpr (std::is_same_v<decltype(cpu), JIT&>) {
     sdc1JIT(cpu, mem, instr);
   } else {
     Util::panic("What the fuck did you just give me?!!");
   }
 }
 
+template void Cop1::sdc1<Interpreter>(Interpreter&, Mem&, u32);
+template void Cop1::sdc1<JIT>(JIT&, Mem&, u32);
+
 void Cop1::lwc1Interp(Registers& regs, Mem& mem, u32 instr) {
   if(!regs.cop0.status.cu1) {
     FireException(regs, ExceptionCode::CoprocessorUnusable, 1, true);