From d5743f4dc288492a741e1dec391c5370fb6d73de Mon Sep 17 00:00:00 2001 From: CocoSimone Date: Sat, 27 Aug 2022 14:42:39 +0200 Subject: [PATCH] debugger work --- src/common.hpp | 10 +- src/frontend/imgui/CMakeLists.txt | 9 +- src/frontend/imgui/debugger.cpp | 113 ---------------- src/frontend/imgui/debugger.hpp | 98 +------------- src/frontend/imgui/debugger/cop0/decode.hpp | 22 ++++ src/frontend/imgui/debugger/cpu/decode.hpp | 78 +++++++++++ .../imgui/debugger/debugger_common.hpp | 39 ++++++ src/frontend/imgui/debugger/fpu/decode.hpp | 124 ++++++++++++++++++ src/frontend/imgui/debugger/rsp/decode.hpp | 101 ++++++++++++++ src/n64/Core.cpp | 4 - src/n64/core/cpu/Registers.hpp | 8 -- 11 files changed, 388 insertions(+), 218 deletions(-) create mode 100644 src/frontend/imgui/debugger/cop0/decode.hpp create mode 100644 src/frontend/imgui/debugger/cpu/decode.hpp create mode 100644 src/frontend/imgui/debugger/debugger_common.hpp create mode 100644 src/frontend/imgui/debugger/fpu/decode.hpp create mode 100644 src/frontend/imgui/debugger/rsp/decode.hpp diff --git a/src/common.hpp b/src/common.hpp index a1d993e7..6208c4ae 100644 --- a/src/common.hpp +++ b/src/common.hpp @@ -28,4 +28,12 @@ using m128 = __m128i; #define N64_CYCLES_PER_FRAME ((N64_CPU_FREQ) / 60) #define HALF_ADDRESS(addr) ((addr) ^ 2) #define BYTE_ADDRESS(addr) ((addr) ^ 3) -#define ASPECT_RATIO ((float)4/3) \ No newline at end of file +#define ASPECT_RATIO ((float)4/3) + +#define RD(x) (((x) >> 11) & 0x1F) +#define RT(x) (((x) >> 16) & 0x1F) +#define RS(x) (((x) >> 21) & 0x1F) +#define FD(x) (((x) >> 6) & 0x1F) +#define FT(x) RT(x) +#define FS(x) RD(x) +#define BASE(x) RS(x) \ No newline at end of file diff --git a/src/frontend/imgui/CMakeLists.txt b/src/frontend/imgui/CMakeLists.txt index 8347e628..365f2745 100644 --- a/src/frontend/imgui/CMakeLists.txt +++ b/src/frontend/imgui/CMakeLists.txt @@ -11,10 +11,17 @@ add_library(frontend-imgui STATIC Window.cpp Window.hpp widgets.cpp - debugger.hpp debugger.cpp) + debugger.hpp + debugger.cpp + debugger/cpu/decode.hpp + debugger/cop0/decode.hpp + debugger/fpu/decode.hpp + debugger/rsp/decode.hpp + debugger/debugger_common.hpp) target_include_directories(frontend-imgui PUBLIC . + debugger ../.. ../../n64 ../../n64/core diff --git a/src/frontend/imgui/debugger.cpp b/src/frontend/imgui/debugger.cpp index 768fa114..2bb5856f 100644 --- a/src/frontend/imgui/debugger.cpp +++ b/src/frontend/imgui/debugger.cpp @@ -1,115 +1,2 @@ #include #include - -void DebugStart(void* user_data) { - auto* core = (n64::Core*)user_data; - core->debuggerState.broken = false; -} - -void DebugStop(void* user_data) { - auto* core = (n64::Core*)user_data; - core->debuggerState.broken = true; -} - -void DebugStep(void* user_data) { - auto* core = (n64::Core*)user_data; - bool old_broken = core->debuggerState.broken; - core->debuggerState.broken = false; - core->Step(); - core->debuggerState.broken = old_broken; - core->debuggerState.steps += 2; -} - -void DebugSetBreakpoint(void* user_data, u32 address) { - auto* core = (n64::Core*)user_data; - auto* breakpoint = (Breakpoint*)malloc(sizeof(Breakpoint)); - breakpoint->addr = address; - breakpoint->next = NULL; - - // Special case for this being the first breakpoint - if (core->debuggerState.breakpoints == NULL) { - core->debuggerState.breakpoints = breakpoint; - } else { - // Find end of the list - Breakpoint* tail = core->debuggerState.breakpoints; - while (tail->next != NULL) { - tail = tail->next; - } - - tail->next = breakpoint; - } -} - -void DebugClearBreakpoint(void* user_data, u32 address) { - auto* core = (n64::Core*)user_data; - if (core->debuggerState.breakpoints == NULL) { - return; // No breakpoints set at all - } else if (core->debuggerState.breakpoints->addr == address) { - // Special case for the first breakpoint being the one we want to clear - Breakpoint* next = core->debuggerState.breakpoints->next; - free(core->debuggerState.breakpoints); - core->debuggerState.breakpoints = next; - } else { - // Find the breakpoint somewhere in the list and free it - Breakpoint* iter = core->debuggerState.breakpoints; - while (iter->next != NULL) { - if (iter->next->addr == address) { - Breakpoint* next = iter->next->next; - free(iter->next); - iter->next = next; - } - } - } -} - -ssize_t DebugGetMemory(void* user_data, char* buffer, size_t length, u32 address, size_t bytes) { - auto* core = (n64::Core*)user_data; - printf("Checking memory at address 0x%08X\n", address); - int printed = 0; - for (int i = 0; i < bytes; i++) { - u8 value = core->mem.Read(core->cpu.regs, address + i, core->cpu.regs.pc); - printed += snprintf(buffer + (i*2), length, "%02X", value); - } - printf("Get memory: %ld bytes from 0x%08X: %d\n", bytes, address, printed); - return printed + 1; -} - -ssize_t DebugGetRegisterValue(void* user_data, char * buffer, size_t buffer_length, int reg) { - auto* core = (n64::Core*)user_data; - switch (reg) { - case 0 ... 31: - return snprintf(buffer, buffer_length, "%016llx", core->cpu.regs.gpr[reg]); - case 32: - return snprintf(buffer, buffer_length, "%08x", core->cpu.regs.cop0.status.raw); - case 33: - return snprintf(buffer, buffer_length, "%016llx", core->cpu.regs.lo); - case 34: - return snprintf(buffer, buffer_length, "%016llx", core->cpu.regs.hi); - case 35: - return snprintf(buffer, buffer_length, "%016llx", core->cpu.regs.cop0.badVaddr); - case 36: - return snprintf(buffer, buffer_length, "%08x", core->cpu.regs.cop0.cause.raw); - case 37: - printf("Sending PC: 0x%016llX\n", core->cpu.regs.pc); - return snprintf(buffer, buffer_length, "%016llx", core->cpu.regs.pc); - case 38 ... 71: // TODO FPU stuff - return snprintf(buffer, buffer_length, "%08x", 0); - default: - util::panic("debug get register {} value", reg); - } -} - -ssize_t DebugGetGeneralRegisters(void* user_data, char * buffer, size_t buffer_length) { - auto* core = (n64::Core*)user_data; - printf("The buffer length is %zu!\n", buffer_length); - ssize_t printed = 0; - for (int i = 0; i < 32; i++) { - int ofs = i * 16; // 64 bit regs take up 16 ascii chars to print in hex - if (ofs + 16 > buffer_length) { - util::panic("Too big!"); - } - u64 reg = core->cpu.regs.gpr[i]; - printed += snprintf(buffer + ofs, buffer_length - ofs, "%016llx", reg); - } - return printed; -} \ No newline at end of file diff --git a/src/frontend/imgui/debugger.hpp b/src/frontend/imgui/debugger.hpp index 04247fa6..1357cabb 100644 --- a/src/frontend/imgui/debugger.hpp +++ b/src/frontend/imgui/debugger.hpp @@ -2,96 +2,13 @@ #include #include #include +#include +#include +#include +#include struct Core; -const std::string gprStr[32] = { - "zero", "at", "v0", "v1", - "a0", "a1", "a2", "a3", - "t0", "t1", "t2", "t3", - "t4", "t5", "t6", "t7", - "s0", "s1", "s2", "s3", - "s4", "s5", "s6", "s7", - "t8", "t9", "k0", "k1", - "gp", "sp", "s8", "ra" -}; - -std::string special(u32 instr) { - u8 mask = (instr & 0x3F); - u8 sa = (instr >> 6) & 0x1f; - switch (mask) { // TODO: named constants for clearer code - case 0: - if (mask != 0) { - return fmt::format("sll {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); - } - return "nop"; - case 0x02: return fmt::format("srl {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); - case 0x03: return fmt::format("sra {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); - case 0x04: return fmt::format("sllv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); - case 0x06: return fmt::format("srlv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); - case 0x07: return fmt::format("srav {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); - case 0x08: return fmt::format("jr {}", gprStr[RS(instr)]); - case 0x09: return fmt::format("jalr {}, {}", gprStr[RD(instr)], gprStr[RS(instr)]); - case 0x0C: return fmt::format("syscall"); - case 0x0D: return fmt::format("break"); - case 0x0F: return fmt::format("sync"); - case 0x10: return fmt::format("mfhi {}", gprStr[RD(instr)]); - case 0x11: return fmt::format("mthi {}", gprStr[RS(instr)]); - case 0x12: return fmt::format("mflo {}", gprStr[RD(instr)]); - case 0x13: return fmt::format("mtlo {}", gprStr[RS(instr)]); - case 0x14: return fmt::format("dsllv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); - case 0x16: return fmt::format("dsrlv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); - case 0x17: return fmt::format("dsrav {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); - case 0x18: return fmt::format("mult {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x19: return fmt::format("multu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x1A: return fmt::format("div {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x1B: return fmt::format("divu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x1C: return fmt::format("dmult {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x1D: return fmt::format("dmultu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x1E: return fmt::format("ddiv {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x1F: return fmt::format("ddivu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x20: return fmt::format("add {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x21: return fmt::format("addu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x22: return fmt::format("sub {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x23: return fmt::format("subu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x24: return fmt::format("and {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x25: return fmt::format("or {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x26: return fmt::format("xor {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x27: return fmt::format("nor {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x2A: return fmt::format("slt {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x2B: return fmt::format("sltu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x2C: return fmt::format("dadd {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x2D: return fmt::format("daddu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x2E: return fmt::format("dsub {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x2F: return fmt::format("dsubu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x34: return fmt::format("teq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); - case 0x38: return fmt::format("dsll {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); - case 0x3A: return fmt::format("dsrl {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); - case 0x3B: return fmt::format("dsra {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); - case 0x3C: return fmt::format("dsll32 {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); - case 0x3E: return fmt::format("dsrl32 {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); - case 0x3F: return fmt::format("dsra32 {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); - default: - return fmt::format("INVALID ({:08X})\n", instr); - } -} - -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 0x01: return fmt::format("bgez {}", gprStr[RS(instr)]); - case 0x02: return fmt::format("bltzl {}", gprStr[RS(instr)]); - case 0x03: return fmt::format("bgezl {}", gprStr[RS(instr)]); - case 0x10: return fmt::format("bltzal {}", gprStr[RS(instr)]); - case 0x11: return fmt::format("bgezal {}", gprStr[RS(instr)]); - case 0x12: return fmt::format("bltzall {}", gprStr[RS(instr)]); - case 0x13: return fmt::format("bgezall {}", gprStr[RS(instr)]); - default: return fmt::format("INVALID {:08X}", instr); - } -} - const std::map> cpuInstr = { {0b000000, special}, {0b000001, regimm}, @@ -123,10 +40,9 @@ const std::map> cpuInstr = { return fmt::format("xori {}", gprStr[RS(instr)]); }}, {0b001111, [](u32 instr) { return fmt::format("lui {}", gprStr[RS(instr)]); - }}, {0b010000, /*cop0decode*/ }, - {0b010001, [](u32 instr) { - return fmt::format("j {:08X}", instr & 0x3FFFFFF); - }}, {0b010010, [](u32 instr) { + }}, {0b010000, cop0decode + }, {0b010001, cop1decode + }, {0b010010, [](u32 instr) { return fmt::format("j {:08X}", instr & 0x3FFFFFF); }}, {0b010011, [](u32 instr) { return fmt::format("jal {:08X}", instr & 0x3FFFFFF); diff --git a/src/frontend/imgui/debugger/cop0/decode.hpp b/src/frontend/imgui/debugger/cop0/decode.hpp new file mode 100644 index 00000000..50e9c8f8 --- /dev/null +++ b/src/frontend/imgui/debugger/cop0/decode.hpp @@ -0,0 +1,22 @@ +#pragma once +#include + +inline std::string cop0decode(u32 instr) { + u8 mask_cop = (instr >> 21) & 0x1F; + u8 mask_cop2 = instr & 0x3F; + switch(mask_cop) { + case 0x00: return fmt::format("mfc0 {}, {}", gprStr[RT(instr)], cop0Str[RD(instr)]); + case 0x01: return fmt::format("dmfc0 {}, {}", gprStr[RT(instr)], cop0Str[RD(instr)]); + case 0x04: return fmt::format("mtc0 {}, {}", gprStr[RT(instr)], cop0Str[RD(instr)]); + case 0x05: return fmt::format("dmtc0 {}, {}", gprStr[RT(instr)], cop0Str[RD(instr)]); + case 0x10 ... 0x1F: + switch(mask_cop2) { + case 0x01: return fmt::format("tlbr"); + case 0x02: return fmt::format("tlbwi"); + case 0x08: return fmt::format("tlbp"); + case 0x18: return fmt::format("eret"); + default: return fmt::format("INVALID ({:08X})", instr); + } + default: return fmt::format("INVALID ({:08X})", instr); + } +} \ No newline at end of file diff --git a/src/frontend/imgui/debugger/cpu/decode.hpp b/src/frontend/imgui/debugger/cpu/decode.hpp new file mode 100644 index 00000000..0ecc9aae --- /dev/null +++ b/src/frontend/imgui/debugger/cpu/decode.hpp @@ -0,0 +1,78 @@ +#pragma once +#include + +inline std::string special(u32 instr) { + u8 mask = (instr & 0x3F); + u8 sa = (instr >> 6) & 0x1f; + switch (mask) { + case 0: + if (mask != 0) { + return fmt::format("sll {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); + } + return "nop"; + case 0x02: return fmt::format("srl {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); + case 0x03: return fmt::format("sra {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); + case 0x04: return fmt::format("sllv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x06: return fmt::format("srlv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x07: return fmt::format("srav {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x08: return fmt::format("jr {}", gprStr[RS(instr)]); + case 0x09: return fmt::format("jalr {}, {}", gprStr[RD(instr)], gprStr[RS(instr)]); + case 0x0C: return fmt::format("syscall"); + case 0x0D: return fmt::format("break"); + case 0x0F: return fmt::format("sync"); + case 0x10: return fmt::format("mfhi {}", gprStr[RD(instr)]); + case 0x11: return fmt::format("mthi {}", gprStr[RS(instr)]); + case 0x12: return fmt::format("mflo {}", gprStr[RD(instr)]); + case 0x13: return fmt::format("mtlo {}", gprStr[RS(instr)]); + case 0x14: return fmt::format("dsllv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x16: return fmt::format("dsrlv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x17: return fmt::format("dsrav {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x18: return fmt::format("mult {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x19: return fmt::format("multu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x1A: return fmt::format("div {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x1B: return fmt::format("divu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x1C: return fmt::format("dmult {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x1D: return fmt::format("dmultu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x1E: return fmt::format("ddiv {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x1F: return fmt::format("ddivu {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x20: return fmt::format("add {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x21: return fmt::format("addu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x22: return fmt::format("sub {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x23: return fmt::format("subu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x24: return fmt::format("and {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x25: return fmt::format("or {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x26: return fmt::format("xor {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x27: return fmt::format("nor {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x2A: return fmt::format("slt {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x2B: return fmt::format("sltu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x2C: return fmt::format("dadd {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x2D: return fmt::format("daddu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x2E: return fmt::format("dsub {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x2F: return fmt::format("dsubu {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x34: return fmt::format("teq {}, {}", gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x38: return fmt::format("dsll {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); + case 0x3A: return fmt::format("dsrl {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); + case 0x3B: return fmt::format("dsra {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); + case 0x3C: return fmt::format("dsll32 {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); + case 0x3E: return fmt::format("dsrl32 {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); + case 0x3F: return fmt::format("dsra32 {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RS(instr)], sa); + default: + return fmt::format("INVALID ({:08X})", instr); + } +} + +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 0x01: return fmt::format("bgez {}", gprStr[RS(instr)]); + case 0x02: return fmt::format("bltzl {}", gprStr[RS(instr)]); + case 0x03: return fmt::format("bgezl {}", gprStr[RS(instr)]); + case 0x10: return fmt::format("bltzal {}", gprStr[RS(instr)]); + case 0x11: return fmt::format("bgezal {}", gprStr[RS(instr)]); + case 0x12: return fmt::format("bltzall {}", gprStr[RS(instr)]); + case 0x13: return fmt::format("bgezall {}", gprStr[RS(instr)]); + default: return fmt::format("INVALID ({:08X})", instr); + } +} \ No newline at end of file diff --git a/src/frontend/imgui/debugger/debugger_common.hpp b/src/frontend/imgui/debugger/debugger_common.hpp new file mode 100644 index 00000000..ef219028 --- /dev/null +++ b/src/frontend/imgui/debugger/debugger_common.hpp @@ -0,0 +1,39 @@ +#pragma once +#include + +const std::string gprStr[32] = { + "zero", "at", "v0", "v1", + "a0", "a1", "a2", "a3", + "t0", "t1", "t2", "t3", + "t4", "t5", "t6", "t7", + "s0", "s1", "s2", "s3", + "s4", "s5", "s6", "s7", + "t8", "t9", "k0", "k1", + "gp", "sp", "s8", "ra" +}; + +const std::string cop0Str[32] = { + "Index", "Random", "EntryLo0", "EntryLo1", + "Context", "PageMask", "Wired", "r7", + "BadVAddr", "Count", "EntryHi", "Compare", + "Status", "Cause", "EPC", "PRId", + "Config", "LLAddr", "WatchLo", "WatchHi", + "XContext", "r21", "r22", "r23", + "r24", "r25", "Parity Error", "Cache Error", + "TagLo", "TagHi", "ErrorEPC", "r31" +}; + +const std::string fgrStr[32] = { + "fgr0", "fgr1", "fgr2", "fgr3", + "fgr4", "fgr5", "fgr6", "fgr7", + "fgr8", "fgr9", "fgr10", "fgr11", + "fgr12", "fgr13", "fgr14", "fgr15", + "fgr16", "fgr17", "fgr18", "fgr19", + "fgr20", "fgr21", "fgr22", "fgr23", + "fgr24", "fgr25", "fgr26", "fgr27", + "fgr28", "fgr29", "fgr30", "fgr31" +}; + +const std::string rspStr[] = { + +}; \ No newline at end of file diff --git a/src/frontend/imgui/debugger/fpu/decode.hpp b/src/frontend/imgui/debugger/fpu/decode.hpp new file mode 100644 index 00000000..57d09729 --- /dev/null +++ b/src/frontend/imgui/debugger/fpu/decode.hpp @@ -0,0 +1,124 @@ +#pragma once +#include + +inline std::string cop1decode(u32 instr) { + u8 mask_sub = (instr >> 21) & 0x1F; + u8 mask_fun = instr & 0x3F; + u8 mask_branch = (instr >> 16) & 0x1F; + switch(mask_sub) { + // 000r_rccc + case 0x00: return fmt::format("mfc1 {}, {}", gprStr[RT(instr)], fgrStr[FS(instr)]); + case 0x01: return fmt::format("dmfc1 {}, {}", gprStr[RT(instr)], fgrStr[FS(instr)]); + case 0x02: return fmt::format("cfc1 {}, {}", gprStr[RT(instr)], fgrStr[FS(instr)]); + case 0x04: return fmt::format("mtc1 {}, {}", gprStr[RT(instr)], fgrStr[FS(instr)]); + case 0x05: return fmt::format("dmtc1 {}, {}", gprStr[RT(instr)], fgrStr[FS(instr)]); + case 0x06: return fmt::format("ctc1 {}, {}", gprStr[RT(instr)], fgrStr[FS(instr)]); + case 0x08: + switch(mask_branch) { + case 0: return fmt::format("bcf {:04X}", instr & 0xffff); + case 1: return fmt::format("bct {:04X}", instr & 0xffff); + case 2: return fmt::format("bcfl {:04X}", instr & 0xffff); + case 3: return fmt::format("bctl {:04X}", instr & 0xffff); + default: return fmt::format("INVALID ({:08X})", instr); + } break; + case 0x10: // s + switch(mask_fun) { + case 0x00: return fmt::format("add.s {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x01: return fmt::format("sub.s {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x02: return fmt::format("mul.s {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x03: return fmt::format("div.s {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x04: return fmt::format("sqrt.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x05: return fmt::format("abs.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x06: return fmt::format("mov.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x07: return fmt::format("neg.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x08: return fmt::format("round.l.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x09: return fmt::format("trunc.l.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0A: return fmt::format("ceil.l.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0B: return fmt::format("floor.l.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0C: return fmt::format("round.w.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0D: return fmt::format("trunc.w.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0E: return fmt::format("ceil.w.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0F: return fmt::format("floor.w.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x21: return fmt::format("cvt.d.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x24: return fmt::format("cvt.w.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x25: return fmt::format("cvt.l.s {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x30: return fmt::format("c.f.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x31: return fmt::format("c.un.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x32: return fmt::format("c.eq.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x33: return fmt::format("c.ueq.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x34: return fmt::format("c.olt.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x35: return fmt::format("c.ult.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x36: return fmt::format("c.ole.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x37: return fmt::format("c.ule.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x38: return fmt::format("c.sf.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x39: return fmt::format("c.ngle.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3A: return fmt::format("c.seq.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3B: return fmt::format("c.ngl.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3C: return fmt::format("c.lt.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3D: return fmt::format("c.nge.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3E: return fmt::format("c.le.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3F: return fmt::format("c.ngt.s {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + default: return fmt::format("INVALID ({:08X})", instr); + } break; + case 0x11: // d + switch(mask_fun) { + case 0x00: return fmt::format("add.d {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x01: return fmt::format("sub.d {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x02: return fmt::format("mul.d {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x03: return fmt::format("div.d {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x04: return fmt::format("sqrt.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x05: return fmt::format("abs.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x06: return fmt::format("mov.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x07: return fmt::format("neg.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x08: return fmt::format("round.l.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x09: return fmt::format("trunc.l.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0A: return fmt::format("ceil.l.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0B: return fmt::format("floor.l.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0C: return fmt::format("round.w.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0D: return fmt::format("trunc.w.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0E: return fmt::format("ceil.w.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x0F: return fmt::format("floor.w.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x20: return fmt::format("cvt.s.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x24: return fmt::format("cvt.w.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x25: return fmt::format("cvt.l.d {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x30: return fmt::format("c.f.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x31: return fmt::format("c.un.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x32: return fmt::format("c.eq.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x33: return fmt::format("c.ueq.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x34: return fmt::format("c.olt.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x35: return fmt::format("c.ult.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x36: return fmt::format("c.ole.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x37: return fmt::format("c.ule.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x38: return fmt::format("c.sf.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x39: return fmt::format("c.ngle.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3A: return fmt::format("c.seq.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3B: return fmt::format("c.ngl.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3C: return fmt::format("c.lt.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3D: return fmt::format("c.nge.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3E: return fmt::format("c.le.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x3F: return fmt::format("c.ngt.d {}, {}", fgrStr[FS(instr)], fgrStr[FT(instr)]); + default: return fmt::format("INVALID ({:08X})", instr); + } break; + case 0x14: // w + switch(mask_fun) { + case 0x01: return fmt::format("sub.w {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x02: return fmt::format("mul.w {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x05: return fmt::format("abs.w {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x06: return fmt::format("mov.w {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x20: return fmt::format("cvt.s.w {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x21: return fmt::format("cvt.d.w {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + default: return fmt::format("INVALID ({:08X})", instr); + } break; + case 0x15: // l + switch(mask_fun) { + case 0x01: return fmt::format("sub.l {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x02: return fmt::format("mul.l {}, {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)], fgrStr[FT(instr)]); + case 0x05: return fmt::format("abs.l {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x06: return fmt::format("mov.l {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x20: return fmt::format("cvt.s.l {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + case 0x21: return fmt::format("cvt.d.l {}, {}", fgrStr[FD(instr)], fgrStr[FS(instr)]); + default: return fmt::format("INVALID ({:08X})", instr); + } break; + default: return fmt::format("INVALID ({:08X})", instr); + } +} \ No newline at end of file diff --git a/src/frontend/imgui/debugger/rsp/decode.hpp b/src/frontend/imgui/debugger/rsp/decode.hpp new file mode 100644 index 00000000..d6c087b2 --- /dev/null +++ b/src/frontend/imgui/debugger/rsp/decode.hpp @@ -0,0 +1,101 @@ +#pragma once +#include + +inline std::string rspSpecial(u32 instr) { + u8 mask = instr & 0x3f; + u8 sa = (instr >> 6) & 0x1f; + switch(mask) { + case 0x00: return fmt::format("[rsp]: sll {}, {}, {:02X}", gprStr[RD(instr)], gprStr[RT(instr)], sa); + case 0x04: return fmt::format("[rsp]: sllv {}, {}, {}", gprStr[RD(instr)], gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x08: return fmt::format("[rsp]: jr {}", gprStr[RS(instr)]); + case 0x0C: case 0x0D: + return fmt::format("[rsp]: break"); + case 0x20: case 0x21: + return fmt::format("[rsp]: add {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x24: return fmt::format("[rsp]: and {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x25: return fmt::format("[rsp]: or {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + case 0x27: return fmt::format("[rsp]: nor {}, {}, {}", gprStr[RD(instr)], gprStr[RS(instr)], gprStr[RT(instr)]); + default: return fmt::format("INVALID ({:08X})", 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 0x01: return fmt::format("[rsp]: bgez {}", gprStr[RS(instr)]); + default: return fmt::format("INVALID ({:08X})", instr); + } +} + +inline std::string lwc2(u32 instr) { + u8 mask = (instr >> 11) & 0x1F; + switch(mask) { + case 0x04: return fmt::format("lqv", instr); + default: return fmt::format("INVALID ({:08X})", instr); + } +} + +inline std::string swc2(u32 instr) { + u8 mask = (instr >> 11) & 0x1F; + switch(mask) { + //case 0x04: rsp.sqv(instr); break; + default: return fmt::format("INVALID ({:08X})", instr); + } +} + +inline std::string cop2decode(u32 instr) { + u8 mask = instr & 0x3F; + u8 mask_sub = (instr >> 21) & 0x1F; + switch(mask) { + case 0x00: + switch(mask_sub) { + //case 0x02: rsp.cfc2(instr); break; + default: return fmt::format("INVALID ({:08X})", instr); + } + break; + //case 0x13: rsp.vabs(instr); break; + //case 0x1D: rsp.vsar(instr); break; + //case 0x21: rsp.veq(instr); break; + //case 0x22: rsp.vne(instr); break; + //case 0x33: rsp.vmov(instr); break; + default: return fmt::format("INVALID ({:08X})", instr); + } +} + +inline std::string rspCop0Decode(u32 instr) { + u8 mask = (instr >> 21) & 0x1F; + switch(mask) { + //case 0x00: rsp.mfc0(rdp, instr); break; + //case 0x04: rsp.mtc0(mi, regs, rdp, instr); break; + default: return fmt::format("INVALID ({:08X})", instr); + } +} + +inline std::string rspDecode(u32 instr) { + u8 mask = (instr >> 26) & 0x3F; + switch(mask) { + case 0x00: return special(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 0x05: return fmt::format("[rsp]: bne {}, {}", gprStr[RT(instr)], gprStr[RS(instr)]); + case 0x07: return fmt::format("[rsp]: bgtz {}", gprStr[RS(instr)]); + 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); + case 0x0D: return fmt::format("[rsp]: ori {}, {}, {:04X}", instr); + case 0x0F: return fmt::format("[rsp]: lui {}, {:04X}", gprStr[RT(instr)], instr & 0xffff); + case 0x10: return rspCop0Decode(instr); + case 0x12: return cop2decode(instr); + case 0x21: return fmt::format("[rsp]: lh {}, {:04X}({})", gprStr[RT(instr)], instr & 0xffff, gprStr[BASE(instr)]); + case 0x23: return fmt::format("[rsp]: lw {}, {:04X}({})", gprStr[RT(instr)], instr & 0xffff, gprStr[BASE(instr)]); + case 0x28: return fmt::format("[rsp]: sb {}, {:04X}({})", gprStr[RT(instr)], instr & 0xffff, gprStr[BASE(instr)]); + case 0x29: return fmt::format("[rsp]: sh {}, {:04X}({})", gprStr[RT(instr)], instr & 0xffff, gprStr[BASE(instr)]); + case 0x2B: return fmt::format("[rsp]: sw {}, {:04X}({})", gprStr[RT(instr)], instr & 0xffff, gprStr[BASE(instr)]); + case 0x32: return lwc2(instr); + case 0x3A: return swc2(instr); + default: return fmt::format("INVALID ({:08X})", instr); + } +} \ No newline at end of file diff --git a/src/n64/Core.cpp b/src/n64/Core.cpp index af085757..906f1827 100644 --- a/src/n64/Core.cpp +++ b/src/n64/Core.cpp @@ -8,7 +8,6 @@ namespace n64 { Core::Core() { Stop(); - DebuggerInit(); } void Core::Stop() { @@ -17,7 +16,6 @@ void Core::Stop() { pause = true; romLoaded = false; rom.clear(); - DebuggerCleanup(); } void Core::Reset() { @@ -25,8 +23,6 @@ void Core::Reset() { mem.Reset(); pause = true; romLoaded = false; - DebuggerCleanup(); - DebuggerInit(); if(!rom.empty()) { LoadROM(rom); } diff --git a/src/n64/core/cpu/Registers.hpp b/src/n64/core/cpu/Registers.hpp index ffab217c..ce4bf366 100644 --- a/src/n64/core/cpu/Registers.hpp +++ b/src/n64/core/cpu/Registers.hpp @@ -15,12 +15,4 @@ struct Registers { bool LLBit; bool prevDelaySlot, delaySlot; }; - -#define RD(x) (((x) >> 11) & 0x1F) -#define RT(x) (((x) >> 16) & 0x1F) -#define RS(x) (((x) >> 21) & 0x1F) -#define FD(x) (((x) >> 6) & 0x1F) -#define FT(x) RT(x) -#define FS(x) RD(x) -#define BASE(x) RS(x) }