Slight improvements to debugger, still wonky

src/backend/Core.cpp

@@ -91,6 +91,7 @@ void Core::StepRSP(int cpuCycles) {
 void Core::Run(float volumeL, float volumeR) {
   MMIO &mmio = mem->mmio;
 
+  bool broken = false;
   for (int field = 0; field < mmio.vi.numFields; field++) {
     u32 frameCycles = 0;
     for (int i = 0; i < mmio.vi.numHalflines; i++) {
@@ -102,16 +103,25 @@ void Core::Run(float volumeL, float volumeR) {
 
       while(cycles < mem->mmio.vi.cyclesPerHalfline) {
         u32 taken = StepCPU();
-        StepRSP(taken);
-
         cycles += taken;
+
+        if((broken = breakpoints.contains(regs.nextPC)))
+          break;
+
+        StepRSP(taken);
         frameCycles += taken;
         Scheduler::GetInstance().Tick(taken);
       }
 
+      if(broken)
+        break;
+
       cycles -= mmio.vi.cyclesPerHalfline;
     }
 
+    if(broken)
+      break;
+
     if ((mmio.vi.current & 0x3FE) == mmio.vi.intr) {
       mmio.mi.InterruptRaise(MI::Interrupt::VI);
     }
@@ -119,5 +129,8 @@ void Core::Run(float volumeL, float volumeR) {
     mmio.ai.Step(frameCycles, volumeL, volumeR);
     Scheduler::GetInstance().Tick(frameCycles);
   }
+
+  if(broken)
+    pause = true;
 }
 } // namespace n64

src/backend/Core.hpp

@@ -38,7 +38,7 @@ struct Core {
   void Run(float volumeL, float volumeR);
   void TogglePause() { pause = !pause; }
   inline void ToggleBreakpoint(s64 addr) {
-    if(breakpoints.contains(addr)){
+    if(breakpoints.contains(addr)) {
       breakpoints.erase(addr);
       return;
     }

src/backend/core/mmio/PIF.cpp

@@ -118,7 +118,7 @@ void PIF::LoadEeprom(const SaveType saveType, const std::string &path) {
 
     eeprom = mio::make_mmap_sink(eepromPath, 0, mio::map_entire_file, error);
     if (error) {
-      panic("Could not open {}", eepromPath);
+      panic("Could not open {}. Reason {}", eepromPath, error.message());
     }
   }
 }

src/frontend/Debugger.cpp

@@ -13,16 +13,16 @@ char const* regNames[] = {
   "gp", "sp", "s8", "ra",
 };
 
-void BreakpointFunc(s64 addr, s64 startAddr, Disassembler::DisassemblyResult&) {
+void BreakpointFunc(s64 addr, Disassembler::DisassemblyResult&) {
   n64::Core& core = n64::Core::GetInstance();
-  bool isBroken = core.breakpoints.contains(addr + 4);
+  bool isBroken = core.breakpoints.contains(addr);
   ImGui::PushStyleColor(ImGuiCol_CheckMark, 0xff0000ff);
   ImGui::PushStyleColor(ImGuiCol_FrameBg, 0);
   ImGui::PushStyleColor(ImGuiCol_FrameBgActive, 0);
   ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, 0x800000ff);
   ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 0.5f);
-  if(ImGui::Checkbox(std::format("##toggleBreakpoint{}", (addr - startAddr) / 4).c_str(), &isBroken)) {
-    core.ToggleBreakpoint(addr + 4);
+  if(ImGui::Checkbox(std::format("##toggleBreakpoint{}", addr).c_str(), &isBroken)) {
+    core.ToggleBreakpoint(addr);
   }
   ImGui::PopStyleVar();
   ImGui::PopStyleColor();
@@ -31,7 +31,7 @@ void BreakpointFunc(s64 addr, s64 startAddr, Disassembler::DisassemblyResult&) {
   ImGui::PopStyleColor();
 }
 
-void AddressFunc(s64, s64, Disassembler::DisassemblyResult& disasm) {
+void AddressFunc(s64, Disassembler::DisassemblyResult& disasm) {
   if(!disasm.success) {
     ImGui::TextColored(ImColor(0xffeaefb6), "????????????????");
     return;
@@ -40,7 +40,7 @@ void AddressFunc(s64, s64, Disassembler::DisassemblyResult& disasm) {
   ImGui::TextColored(ImColor(0xffeaefb6), "%s", std::format("{:016X}:", disasm.address).c_str());
 }
 
-void InstructionFunc(s64, s64, Disassembler::DisassemblyResult& disasm) {
+void InstructionFunc(s64, Disassembler::DisassemblyResult& disasm) {
   if(!disasm.success) {
     ImGui::TextColored(ImColor(0xffcbf1ae), "Disassembly unsuccessful...");
     return;
@@ -146,6 +146,7 @@ void Debugger::RegisterView() {
 bool Debugger::render() {
   n64::Core& core = n64::Core::GetInstance();
   n64::Registers& regs = core.GetRegs();
+  bool ret = true;
 
   if(!enabled)
     return false;
@@ -153,8 +154,10 @@ bool Debugger::render() {
   static s64 startAddr = 0xFFFF'FFFF'8000'0000;
   int step = 4, stepFast = 256;
   
-  if(!ImGui::Begin("Debugger", &enabled))
-    return false;
+  if(!ImGui::Begin("Debugger", &enabled)) {
+    ret = false;
+    goto EXIT;
+  }
 
   ImGui::BeginDisabled(followPC);
   ImGui::InputScalar("Address", ImGuiDataType_S64, (void*)&startAddr, (void*)&step, (void*)&stepFast, "%016lX", ImGuiInputTextFlags_CharsHexadecimal);
@@ -176,8 +179,13 @@ bool Debugger::render() {
     core.ToggleBreakpoint(startAddr);
   }
 
-  if(!ImGui::BeginTable("Disassembly", columns.size(), ImGuiTableFlags_SizingFixedSame | ImGuiTableFlags_Resizable | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV | ImGuiTableFlags_ContextMenuInBody))
-    return false;
+  auto disasmTableFlags = ImGuiTableFlags_SizingFixedSame | ImGuiTableFlags_Resizable | ImGuiTableFlags_BordersOuter |
+                          ImGuiTableFlags_BordersV | ImGuiTableFlags_ContextMenuInBody;
+
+  if(!ImGui::BeginTable("Disassembly", columns.size(), disasmTableFlags)) {
+    ret = false;
+    goto EXIT;
+  }
 
   for(int i = 0; i < columns.size(); i++)
     ImGui::TableSetupColumn(columns[i].name);
@@ -206,7 +214,7 @@ bool Debugger::render() {
     ImGui::TableNextRow();
     for(int i = 0; i < columns.size(); i++) {
       ImGui::TableSetColumnIndex(i);
-      columns[i].func(addr, startAddr, disasm);
+      columns[i].func(addr, disasm);
     }
 
     ImGui::PopStyleColor();
@@ -217,7 +225,7 @@ bool Debugger::render() {
 
   RegisterView();
 
+EXIT:
   ImGui::End();
-
-  return true;
+  return ret;
 }

src/frontend/Debugger.hpp

@@ -1,9 +1,9 @@
 #pragma once
 #include <backend/Core.hpp>
 
-void BreakpointFunc(s64, s64, Disassembler::DisassemblyResult&);
-void AddressFunc(s64, s64, Disassembler::DisassemblyResult&);
-void InstructionFunc(s64, s64, Disassembler::DisassemblyResult&);
+void BreakpointFunc(s64, Disassembler::DisassemblyResult&);
+void AddressFunc(s64, Disassembler::DisassemblyResult&);
+void InstructionFunc(s64, Disassembler::DisassemblyResult&);
 
 class Debugger final {
   bool enabled = false;
@@ -11,7 +11,7 @@ class Debugger final {
 
   struct Column {
     const char* name;
-    void (*func)(s64, s64, Disassembler::DisassemblyResult&) = nullptr;
+    void (*func)(s64, Disassembler::DisassemblyResult&) = nullptr;
   };
 
   std::array<Column, 3> columns = {

src/frontend/KaizenGui.cpp

@@ -332,6 +332,7 @@ void KaizenGui::RenderUI() {
             n64::Core::GetInstance().ToggleBreakpoint(lastPC.value());
           
           debugger.Open();
+          emuThread.Reset();
         }
       } break;
       default: break;

src/utils/ErrorData.hpp

@@ -125,11 +125,11 @@ struct Error {
         return instance;
     }
 
-    static std::string GetError() { return GetInstance().err; }
-    static Severity GetSeverity() { return GetInstance().severity; }
-    static Type GetType() { return GetInstance().type; }
-    static std::optional<u64> GetLastPC() { return GetInstance().lastPC; }
-    static std::optional<MemoryAccess> GetMemoryAccess() { return GetInstance().memoryAccess; }
+    static std::string& GetError() { return GetInstance().err; }
+    static Severity& GetSeverity() { return GetInstance().severity; }
+    static Type& GetType() { return GetInstance().type; }
+    static std::optional<u64>& GetLastPC() { return GetInstance().lastPC; }
+    static std::optional<MemoryAccess>& GetMemoryAccess() { return GetInstance().memoryAccess; }
     static bool IsHandled() {
         return GetSeverity().as_enum == Severity::NONE;
     }

src/utils/log.hpp

@@ -10,7 +10,7 @@ namespace Util {
 enum LogLevel : u8 { Trace, Debug, Warn, Info, Error, Always };
 
 #ifndef NDEBUG
-static constexpr auto globalLogLevel = Trace;
+static constexpr auto globalLogLevel = Debug;
 #else
 static constexpr auto globalLogLevel = Info;
 #endif