debugger work

external/parallel-rdp/CMakeLists.txt

@@ -65,6 +65,7 @@ target_include_directories(parallel-rdp PUBLIC
   ..
   ../../src/frontend
   ../../src/frontend/imgui
+  ../../src/frontend/imgui/debugger
   ../../src
   ../imgui
   ../imgui/imgui

src/common.hpp

@@ -37,3 +37,9 @@ using m128 = __m128i;
 #define FT(x) RT(x)
 #define FS(x) RD(x)
 #define BASE(x) RS(x)
+#define VT(x) (((x) >> 16) & 0x1F)
+#define VS(x) (((x) >> 11) & 0x1F)
+#define VD(x) (((x) >> 6) & 0x1F)
+#define E(x) BASE(x)
+#define ELEMENT_INDEX(i) (7 - (i))
+#define BYTE_INDEX(i) (15 - (i))

src/frontend/imgui/CMakeLists.txt

@@ -33,4 +33,4 @@ target_include_directories(frontend-imgui PUBLIC
   ../../../external/parallel-rdp/parallel-rdp-standalone/vulkan
   ../../../external/parallel-rdp/parallel-rdp-standalone/util
   ../../../external/parallel-rdp/parallel-rdp-standalone/volk)
-target_link_libraries(frontend-imgui PUBLIC ws2_32 SDL2main SDL2 imgui nfd fmt)
+target_link_libraries(frontend-imgui PUBLIC SDL2main SDL2 imgui nfd fmt)

src/frontend/imgui/debugger.hpp

@@ -8,135 +8,79 @@
 #include <cop0/decode.hpp>
 
 struct Core;
-
+// TODO: Fix syntax
-const std::map<u8, std::function<std::string(u32)>> cpuInstr = {
+static std::map<u8, std::function<std::string(u32)>> cpuInstr = {
   {0b000000, special},
   {0b000001, regimm},
-  {0b000010, [](u32 instr) {
+  {0b000010, [](u32 instr) { return fmt::format("j {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b000011, [](u32 instr) { return fmt::format("jal {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b000011, [](u32 instr) {
+  {0b000100, [](u32 instr) { return fmt::format("beq {}, {}, {:04X}", gprStr[RS(instr)], gprStr[RT(instr)], instr & 0xffff); }},
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
+  {0b000101, [](u32 instr) { return fmt::format("bne {}, {}, {:04X}", gprStr[RS(instr)], gprStr[RT(instr)], instr & 0xffff); }},
-  }}, {0b000100, [](u32 instr) {
+  {0b000110, [](u32 instr) { return fmt::format("blez {}, {:04X}", gprStr[RS(instr)], instr & 0xffff); }},
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b000111, [](u32 instr) { return fmt::format("bgtz {}, {:04X}", gprStr[RS(instr)], instr & 0xffff); }},
-  }}, {0b000101, [](u32 instr) {
+  {0b001000, [](u32 instr) { return fmt::format("addi {}, {:04X}", gprStr[RS(instr)], instr & 0xFFFF); }},
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b001001, [](u32 instr) { return fmt::format("addiu {}, {:04X}", gprStr[RS(instr)], instr & 0x3FFFFFF); }},
-  }}, {0b000110, [](u32 instr) {
+  {0b001010, [](u32 instr) { return fmt::format("slti {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xFFFF); }},
-    return fmt::format("blez {}", gprStr[RS(instr)]);
+  {0b001011, [](u32 instr) { return fmt::format("sltiu {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xFFFF); }},
-  }}, {0b000111, [](u32 instr) {
+  {0b001100, [](u32 instr) { return fmt::format("andi {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
+  {0b001101, [](u32 instr) { return fmt::format("ori {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-  }}, {0b001000, [](u32 instr) {
+  {0b001110, [](u32 instr) { return fmt::format("xori {}", gprStr[RS(instr)]); }},
-    return fmt::format("addi {}, {:04X}", gprStr[RS(instr)], instr & 0xFFFF);
+  {0b001111, [](u32 instr) { return fmt::format("lui {}", gprStr[RS(instr)]); }},
-  }}, {0b001001, [](u32 instr) {
+  {0b010000, cop0decode},
-    return fmt::format("addiu {}, {:04X}", gprStr[RS(instr)], instr & 0x3FFFFFF);
+  {0b010001, cop1decode},
-  }}, {0b001010, [](u32 instr) {
+  {0b010010, rspDecode},
-    return fmt::format("slti {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xFFFF);
+  {0b010011, [](u32 instr) { return fmt::format("RESERVED"); }},
-  }}, {0b001011, [](u32 instr) {
+  {0b010100, [](u32 instr) { return fmt::format("beql {}, {}, {:04X}", gprStr[RS(instr)], gprStr[RT(instr)], instr & 0xffff); }},
-    return fmt::format("sltiu {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xFFFF);
+  {0b010101, [](u32 instr) { return fmt::format("bnel {}, {}, {:04X}", gprStr[RS(instr)], gprStr[RT(instr)], instr & 0xffff); }},
-  }}, {0b001100, [](u32 instr) {
+  {0b010110, [](u32 instr) { return fmt::format("blezl {}, {:04X}", gprStr[RS(instr)], instr & 0xffff); }},
-    return fmt::format("andi {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b010111, [](u32 instr) { return fmt::format("bgtzl {}, {:04X}", gprStr[RS(instr)], instr & 0xffff); }},
-  }}, {0b001101, [](u32 instr) {
+  {0b011000, [](u32 instr) { return fmt::format("daddi {}, {}, {}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xFFFF);}},
-    return fmt::format("ori {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b011001, [](u32 instr) { return fmt::format("daddiu {}, {}, {}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xFFFF); }},
-  }}, {0b001110, [](u32 instr) {
+  {0b011010, [](u32 instr) { return fmt::format("ldl {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("xori {}", gprStr[RS(instr)]);
+  {0b011011, [](u32 instr) { return fmt::format("ldr {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b001111, [](u32 instr) {
+  {0b011100, [](u32 instr) { return fmt::format("RESERVED"); }},
-    return fmt::format("lui {}", gprStr[RS(instr)]);
+  {0b011101, [](u32 instr) { return fmt::format("RESERVED"); }},
-  }}, {0b010000, cop0decode
+  {0b011110, [](u32 instr) { return fmt::format("RESERVED"); }},
-  }, {0b010001, cop1decode
+  {0b011111, [](u32 instr) { return fmt::format("RESERVED"); }},
-  }, {0b010010, [](u32 instr) {
+  {0b100000, [](u32 instr) { return fmt::format("lb {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b100001, [](u32 instr) { return fmt::format("lh {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b010011, [](u32 instr) {
+  {0b100010, [](u32 instr) { return fmt::format("lwl {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
+  {0b100011, [](u32 instr) { return fmt::format("lw {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b010100, [](u32 instr) {
+  {0b100100, [](u32 instr) { return fmt::format("lbu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b100101, [](u32 instr) { return fmt::format("lhu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-  }}, {0b010101, [](u32 instr) {
+  {0b100110, [](u32 instr) { return fmt::format("lwr {}", gprStr[RS(instr)]); }},
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b100111, [](u32 instr) { return fmt::format("lwu {}", gprStr[RS(instr)]); }},
-  }}, {0b010110, [](u32 instr) {
+  {0b101000, [](u32 instr) { return fmt::format("sb {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("blez {}", gprStr[RS(instr)]);
+  {0b101001, [](u32 instr) { return fmt::format("sh {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b010111, [](u32 instr) {
+  {0b101010, [](u32 instr) { return fmt::format("swl {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
+  {0b101011, [](u32 instr) { return fmt::format("sw {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b011000, [](u32 instr) {
+  {0b101100, [](u32 instr) { return fmt::format("sdl {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b101101, [](u32 instr) { return fmt::format("sdr {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-  }}, {0b011001, [](u32 instr) {
+  {0b101110, [](u32 instr) { return fmt::format("swr {}", gprStr[RS(instr)]); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b101111, [](u32 instr) { return fmt::format("cache", gprStr[RS(instr)]); }},
-  }}, {0b011010, [](u32 instr) {
+  {0b110000, [](u32 instr) { return fmt::format("ll {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b110001, [](u32 instr) { return fmt::format("lwc1 {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b011011, [](u32 instr) {
+  {0b110010, [](u32 instr) { return fmt::format("lwc2 {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
+  {0b110011, [](u32 instr) { return fmt::format("RESERVED"); }},
-  }}, {0b011100, [](u32 instr) {
+  {0b110100, [](u32 instr) { return fmt::format("lld {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b110101, [](u32 instr) { return fmt::format("ldc1 {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-  }}, {0b011101, [](u32 instr) {
+  {0b110110, [](u32 instr) { return fmt::format("ldc2 {}", gprStr[RS(instr)]); }},
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
+  {0b110111, [](u32 instr) { return fmt::format("ld {}", gprStr[RS(instr)]); }},
-  }}, {0b011110, [](u32 instr) {
+  {0b111000, [](u32 instr) { return fmt::format("sc {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("blez {}", gprStr[RS(instr)]);
+  {0b111001, [](u32 instr) { return fmt::format("swc1 {:08X}", instr & 0x3FFFFFF); }},
-  }}, {0b011111, [](u32 instr) {
+  {0b111010, [](u32 instr) { return fmt::format("swc2 {:08X}", instr & 0x3FFFFFF); }},
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
+  {0b111011, [](u32 instr) { return fmt::format("RESERVED"); }},
-  }}, {0b100000, [](u32 instr) {
+  {0b111100, [](u32 instr) { return fmt::format("scd {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b111101, [](u32 instr) { return fmt::format("sdc1 {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); }},
-  }}, {0b100001, [](u32 instr) {
+  {0b111110, [](u32 instr) { return fmt::format("sdc2 {}", gprStr[RS(instr)]); }},
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
+  {0b111111, [](u32 instr) { return fmt::format("sd {}", gprStr[RS(instr)]); }}
-  }}, {0b100010, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b100011, [](u32 instr) {
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
-  }}, {0b100100, [](u32 instr) {
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b100101, [](u32 instr) {
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b100110, [](u32 instr) {
-    return fmt::format("blez {}", gprStr[RS(instr)]);
-  }}, {0b100111, [](u32 instr) {
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
-  }}, {0b101000, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b101001, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b101010, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b101011, [](u32 instr) {
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
-  }}, {0b101100, [](u32 instr) {
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b101101, [](u32 instr) {
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b101110, [](u32 instr) {
-    return fmt::format("blez {}", gprStr[RS(instr)]);
-  }}, {0b101111, [](u32 instr) {
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
-  }}, {0b110000, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b110001, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b110010, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b110011, [](u32 instr) {
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
-  }}, {0b110100, [](u32 instr) {
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b110101, [](u32 instr) {
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b110110, [](u32 instr) {
-    return fmt::format("blez {}", gprStr[RS(instr)]);
-  }}, {0b110111, [](u32 instr) {
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
-  }}, {0b111000, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b111001, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b111010, [](u32 instr) {
-    return fmt::format("j {:08X}", instr & 0x3FFFFFF);
-  }}, {0b111011, [](u32 instr) {
-    return fmt::format("jal {:08X}", instr & 0x3FFFFFF);
-  }}, {0b111100, [](u32 instr) {
-    return fmt::format("beq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b111101, [](u32 instr) {
-    return fmt::format("bne {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]);
-  }}, {0b111110, [](u32 instr) {
-    return fmt::format("blez {}", gprStr[RS(instr)]);
-  }}, {0b111111, [](u32 instr) {
-    return fmt::format("bgtz {}", gprStr[RS(instr)]);
-  }}
 };
 
 struct Debugger {
+  util::CircularBuffer<20, std::string> disassembled;
 
+  inline void Decode(u32 instr) {
+    const u8 mask = (instr >> 26) & 0x3f;
+    disassembled.PushValue(cpuInstr[mask](instr));
+  }
 };

src/frontend/imgui/debugger/cpu/decode.hpp

@@ -65,14 +65,14 @@ inline std::string regimm(u32 instr) {
   u8 mask = ((instr >> 16) & 0x1F);
   // 000r_rccc
   switch (mask) { // TODO: named constants for clearer code
-    case 0x00: return fmt::format("bltz {}", gprStr[RS(instr)]);
+    case 0x00: return fmt::format("bltz {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x01: return fmt::format("bgez {}", gprStr[RS(instr)]);
+    case 0x01: return fmt::format("bgez {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x02: return fmt::format("bltzl {}", gprStr[RS(instr)]);
+    case 0x02: return fmt::format("bltzl {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x03: return fmt::format("bgezl {}", gprStr[RS(instr)]);
+    case 0x03: return fmt::format("bgezl {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x10: return fmt::format("bltzal {}", gprStr[RS(instr)]);
+    case 0x10: return fmt::format("bltzal {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x11: return fmt::format("bgezal {}", gprStr[RS(instr)]);
+    case 0x11: return fmt::format("bgezal {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x12: return fmt::format("bltzall {}", gprStr[RS(instr)]);
+    case 0x12: return fmt::format("bltzall {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x13: return fmt::format("bgezall {}", gprStr[RS(instr)]);
+    case 0x13: return fmt::format("bgezall {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
     default:   return fmt::format("INVALID ({:08X})", instr);
   }
 }

src/frontend/imgui/debugger/debugger_common.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include <common.hpp>
 
-const std::string gprStr[32] = {
+static const std::string gprStr[32] = {
   "zero", "at", "v0", "v1",
   "a0", "a1", "a2", "a3",
   "t0", "t1", "t2", "t3",
@@ -12,7 +12,7 @@ const std::string gprStr[32] = {
   "gp", "sp", "s8", "ra"
 };
 
-const std::string cop0Str[32] = {
+static const std::string cop0Str[32] = {
   "Index", "Random", "EntryLo0", "EntryLo1",
   "Context", "PageMask", "Wired", "r7",
   "BadVAddr", "Count", "EntryHi", "Compare",
@@ -23,7 +23,7 @@ const std::string cop0Str[32] = {
   "TagLo", "TagHi", "ErrorEPC", "r31"
 };
 
-const std::string fgrStr[32] = {
+static const std::string fgrStr[32] = {
   "fgr0", "fgr1", "fgr2", "fgr3",
   "fgr4", "fgr5", "fgr6", "fgr7",
   "fgr8", "fgr9", "fgr10", "fgr11",
@@ -34,6 +34,33 @@ const std::string fgrStr[32] = {
   "fgr28", "fgr29", "fgr30", "fgr31"
 };
 
-const std::string rspStr[] = {
+static const std::string vprStr[32] = {
-
+  "vpr0", "vpr1", "vpr2", "vpr3",
+  "vpr4", "vpr5", "vpr6", "vpr7",
+  "vpr8", "vpr9", "vpr10", "vpr11",
+  "vpr12", "vpr13", "vpr14", "vpr15",
+  "vpr16", "vpr17", "vpr18", "vpr19",
+  "vpr20", "vpr21", "vpr22", "vpr23",
+  "vpr24", "vpr25", "vpr26", "vpr27",
+  "vpr28", "vpr29", "vpr30", "vpr31"
+};
+
+static const std::string vprByteStr[16] = {
+  "e0_8", "e1_8", "e2_8", "e3_8",
+  "e4_8", "e5_8", "e6_8", "e7_8",
+  "e8_8", "e9_8", "e10_8", "e11_8",
+  "e12_8", "e13_8", "e14_8", "e15_8"
+};
+
+static const std::string vprElementStr[8] = {
+  "e0_16", "e2_16", "e4_16", "e6_16",
+  "e8_16", "e10_16", "e12_16", "e14_16"
+};
+
+static const std::string vprWordStr[4] = {
+  "e0_32", "e4_32", "e8_32", "e12_32"
+};
+
+static const std::string rspControlStr[4] = {
+  "vco", "vcc", "vce", "vce"
 };

src/frontend/imgui/debugger/rsp/decode.hpp

@@ -22,8 +22,8 @@ inline std::string rspSpecial(u32 instr) {
 inline std::string rspRegimm(u32 instr) {
   u8 mask = ((instr >> 16) & 0x1F);
   switch(mask) {
-    case 0x00: return fmt::format("[rsp]: bltz {}", gprStr[RS(instr)]);
+    case 0x00: return fmt::format("[rsp]: bltz {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
-    case 0x01: return fmt::format("[rsp]: bgez {}", gprStr[RS(instr)]);
+    case 0x01: return fmt::format("[rsp]: bgez {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
     default: return fmt::format("INVALID ({:08X})", instr);
   }
 }
@@ -31,7 +31,7 @@ inline std::string rspRegimm(u32 instr) {
 inline std::string lwc2(u32 instr) {
   u8 mask = (instr >> 11) & 0x1F;
   switch(mask) {
-    case 0x04: return fmt::format("lqv", instr);
+    case 0x04: return fmt::format("[rsp]: lqv {}[{}], {:02X}({})", vprStr[VT(instr)], vprByteStr[BYTE_INDEX(E(instr))], instr & 0x7F, gprStr[BASE(instr)]);
     default: return fmt::format("INVALID ({:08X})", instr);
   }
 }
@@ -39,7 +39,7 @@ inline std::string lwc2(u32 instr) {
 inline std::string swc2(u32 instr) {
   u8 mask = (instr >> 11) & 0x1F;
   switch(mask) {
-    //case 0x04: rsp.sqv(instr); break;
+    case 0x04: return fmt::format("[rsp]: sqv {}[{}], {:02X}({})", vprStr[VT(instr)], vprByteStr[BYTE_INDEX(E(instr))], instr & 0x7F, gprStr[BASE(instr)]);
     default: return fmt::format("INVALID ({:08X})", instr);
   }
 }
@@ -50,15 +50,15 @@ inline std::string cop2decode(u32 instr) {
   switch(mask) {
     case 0x00:
       switch(mask_sub) {
-        //case 0x02: rsp.cfc2(instr); break;
+        case 0x02: return fmt::format("[rsp]: cfc2 {}, {}", gprStr[RT(instr)], rspControlStr[RD(instr) & 3]);
         default: return fmt::format("INVALID ({:08X})", instr);
       }
       break;
-      //case 0x13: rsp.vabs(instr); break;
+      case 0x13: return fmt::format("[rsp]: vabs {}, {}, {}", vprStr[VD(instr)], vprStr[VS(instr)], vprStr[VT(instr)]);
-      //case 0x1D: rsp.vsar(instr); break;
+      case 0x1D: return fmt::format("[rsp]: vsar {}, {}, {}", vprStr[VD(instr)], vprStr[VS(instr)], vprStr[VT(instr)]);
-      //case 0x21: rsp.veq(instr); break;
+      case 0x21: return fmt::format("[rsp]: veq {}, {}, {}", vprStr[VD(instr)], vprStr[VS(instr)], vprStr[VT(instr)]);
-      //case 0x22: rsp.vne(instr); break;
+      case 0x22: return fmt::format("[rsp]: vne {}, {}, {}", vprStr[VD(instr)], vprStr[VS(instr)], vprStr[VT(instr)]);
-      //case 0x33: rsp.vmov(instr); break;
+      case 0x33: return fmt::format("[rsp]: vmov {}[{}], {}[{}]", vprStr[VD(instr)], vprElementStr[DE(instr)], vprStr[VT(instr)], vprElementStr[E(instr)]);
     default: return fmt::format("INVALID ({:08X})", instr);
   }
 }
@@ -66,8 +66,8 @@ inline std::string cop2decode(u32 instr) {
 inline std::string rspCop0Decode(u32 instr) {
   u8 mask = (instr >> 21) & 0x1F;
   switch(mask) {
-    //case 0x00: rsp.mfc0(rdp, instr); break;
+    case 0x00: return fmt::format("[rsp]: mfc0 {}, {}", gprStr[RT(instr)], cop0Str[RD(instr)]);
-    //case 0x04: rsp.mtc0(mi, regs, rdp, instr); break;
+    case 0x04: return fmt::format("[rsp]: mtc0 {}, {}", gprStr[RT(instr)], cop0Str[RD(instr)]);
     default: return fmt::format("INVALID ({:08X})", instr);
   }
 }
@@ -79,9 +79,9 @@ inline std::string rspDecode(u32 instr) {
     case 0x01: return regimm(instr);
     case 0x02: return fmt::format("[rsp]: j {:04X}", instr & 0xffff);
     case 0x03: return fmt::format("[rsp]: jal {:04X}", instr & 0xffff);
-    case 0x04: return fmt::format("[rsp]: beq {}, {}", gprStr[RT(instr)], gprStr[RS(instr)]);
+    case 0x04: return fmt::format("[rsp]: beq {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xffff);
-    case 0x05: return fmt::format("[rsp]: bne {}, {}", gprStr[RT(instr)], gprStr[RS(instr)]);
+    case 0x05: return fmt::format("[rsp]: bne {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xffff);
-    case 0x07: return fmt::format("[rsp]: bgtz {}", gprStr[RS(instr)]);
+    case 0x07: return fmt::format("[rsp]: bgtz {}, {:04X}", gprStr[RS(instr)], instr & 0xffff);
     case 0x08: case 0x09:
       return fmt::format("[rsp]: addi {}, {}, {:04X}", gprStr[RT(instr)], gprStr[RS(instr)], instr & 0xffff);
     case 0x0C: return fmt::format("[rsp]: andi {}, {}, {:04X}", instr);

src/frontend/imgui/widgets.cpp

@@ -41,9 +41,9 @@ void Window::MainMenuBar(n64::Core& core) {
 void Window::DebuggerWindow(n64::Core& core) const {
   ImGui::PushFont(uiFont);
   ImGui::Begin("Debugger");
-  if(ImGui::Button("Step")) {
+  ImGui::PushFont(codeFont);
-    core.debuggerState.gdb->config.step(&core);
+  ImGui::Text("%s", core.Decode(core.mem.Read<u32>(core.cpu.regs, core.cpu.regs.pc, core.cpu.regs.pc)).c_str());
-  }
+  ImGui::PopFont();
   ImGui::End();
   ImGui::PopFont();
 }

src/n64/CMakeLists.txt

@@ -12,7 +12,7 @@ target_link_libraries(n64 PUBLIC core)
 target_include_directories(n64 PUBLIC
   .
   ..
-  ../frontend/imgui
+  ../frontend/imgui/debugger
   ../../external
   ../../external/imgui/imgui
   ../../external/imgui/imgui/backends

src/n64/Core.hpp

@@ -23,7 +23,6 @@ struct Core {
   bool romLoaded = false;
   SDL_GameController* gamepad;
   bool gamepadConnected = false;
-  DebuggerState debuggerState;
   bool done = false;
   std::string rom;
   Mem mem;

src/n64/core/CMakeLists.txt

@@ -45,13 +45,12 @@ target_include_directories(core PUBLIC
   .
   ..
   ../..
+  ../../frontend/imgui/debugger
   ../../../external
   ../../../external/imgui/imgui
+  ../../../external/imgui/imgui/debugger
   ../../../external/imgui/imgui/backends
   ../../../external/capstone/include
   mmio)
 
 target_link_libraries(core PUBLIC SDL2main SDL2 fmt cpu parallel-rdp capstone)
-if(WIN32)
-
-endif()

src/n64/core/RSP.hpp

@@ -87,17 +87,13 @@ union SPDMADRAMAddr {
 union VPR {
   s16 selement[8];
   u16 element[8];
-  u8 byte[8];
+  u8 byte[16];
   u32 word[4];
 };
 
 struct Mem;
 struct Registers;
 
-#define VT(x) (((x) >> 16) & 0x1F)
-#define VS(x) (((x) >> 11) & 0x1F)
-#define VD(x) (((x) >> 6) & 0x1F)
-#define E(x) (((x) >> 21) & 0x1F)
 #define DE(x) (((x) >> 11) & 0x1F)
 #define CLEAR_SET(val, clear, set) do { \
   if(clear) (val) = 0; \

src/n64/core/rsp/instructions.cpp

@@ -3,10 +3,6 @@
 #include <n64/core/cpu/Registers.hpp>
 
 namespace n64 {
-
-#define ELEMENT_INDEX(i) (7 - (i))
-#define BYTE_INDEX(i) (15 - (i))
-
 inline bool AcquireSemaphore(RSP& rsp) {
   if(rsp.semaphore) {
     return true;

src/util.hpp

@@ -152,7 +152,7 @@ struct CircularBuffer {
   CircularBuffer() : head(0) {
     memset(raw.data(), 0, size * sizeof(T));
   }
-
+  // make it scroll
   void PushValue(T val) {
     raw[head] = val;
     head++;