Use new breakpoint management in CPU module.

This commit both removes the support for the old embedded breakpoint
support in the CPU, and uses the new module for breakpoint management.

Author: giomba

CMakeLists.txt

@@ -18,6 +18,7 @@ set(CORE_SRCS
     src/int.c
     src/keyboard.c
     src/main.c
+    src/monitor.c
     src/charmon.c
     src/serial.c
     src/sio2.c

src/cpu.c

@@ -3,16 +3,18 @@
 #include "3rd/disassembler.h"
 #include "bus.h"
 #include "int.h"
+#include "monitor.h"
 #include "time.h"
 
 #include <string.h>
 
 #include "log.h"
 
-#define CPU_CHUNK_CYCLES 4000
-#define CPU_FREQ         4000000                                       // [Hz]
-#define CPU_CHUNK_PERIOD (CPU_CHUNK_CYCLES * 1000L * 1000L / CPU_FREQ) // [us]
-#define CPU_PAUSE_PERIOD 20000 // [us] 20 ms => 50 Hz
+#define CPU_CHUNK_CYCLES    4000
+#define CPU_FREQ            4000000 // [Hz]
+#define CPU_CHUNK_PERIOD    (CPU_CHUNK_CYCLES * 1000L * 1000L / CPU_FREQ) // [us]
+#define CPU_PAUSE_PERIOD    20000 // [us] 20 ms => 50 Hz
+#define CPU_INSTRUCTION_NOP (0x00)
 
 static Z80 cpu;
 static bool pause = true;
@@ -23,26 +25,7 @@ static us_time_t update_interval = CPU_PAUSE_PERIOD;
 static float perf_value = 0;
 static const char *perf_unit = "ips";
 
-#define CPU_BREAKPOINTS 8
-static CpuBreakpoint breakpoints[CPU_BREAKPOINTS] = {0};
-static unsigned int valid_breakpoints = 0;
-
-/**
- * @brief Check if a breakpoint has been hit.
- *
- * @return true if a breakpoint has been hit, false otherwise.
- */
-static bool cpu_checkBreakpoints(void) {
-    for (size_t i = 0; i < CPU_BREAKPOINTS; ++i) {
-        if (!breakpoints[i].valid)
-            continue;
-
-        if (cpu.pc.uint16_value == breakpoints[i].address)
-            return true;
-    }
-
-    return false;
-}
+static uint8_t cpu_hook(void *context, zuint16 address);
 
 static zuint8 cpu_fetch_opcode(void *context, zuint16 address) {
     (void)context;
@@ -53,7 +36,14 @@ static zuint8 cpu_fetch_opcode(void *context, zuint16 address) {
         disassemble(blob, address, mnemonic, 256);
         LOG_DEBUG("%s: [%04x]:\t%s\n", __func__, address, mnemonic);
     });
-    return bus_mem_read(address);
+    zuint8 data = 0x00;
+    if (monitor_checkBreakpoint(address)) {
+        cpu.hook = cpu_hook;
+        data = Z80_HOOK;
+    } else {
+        data = bus_mem_read(address);
+    }
+    return data;
 }
 
 static void cpu_performance(float *value, const char **unit) {
@@ -82,20 +72,7 @@ static void cpu_poll(void) {
     if (pause)
         return;
 
-    // check if a breakpoint has been hit
-    if (valid_breakpoints != 0) {
-        if (cpu_checkBreakpoints()) {
-            cpu_pause(true);
-            // TODO(giomba): signal the user that the breakpoint has been hit
-            return;
-        }
-    }
-
-    // if there are breakpoints, step one instruction at a time
-    const unsigned int requested_cycles =
-        (valid_breakpoints == 0) ? CPU_CHUNK_CYCLES : 1;
-
-    cycles += z80_run(&cpu, requested_cycles);
+    cycles += z80_run(&cpu, CPU_CHUNK_CYCLES);
     cpu_update_performance();
 }
 
@@ -109,13 +86,13 @@ static long cpu_remaining(void) {
 void cpu_pause(bool enable) {
     pause = enable;
 
-    if (pause) {
+    if (!pause)
+        cpu.hook = NULL;
+
+    if (pause)
         update_interval = CPU_PAUSE_PERIOD;
-    } else if (valid_breakpoints > 0) {
-        update_interval = 0;
-    } else {
+    else
         update_interval = CPU_CHUNK_PERIOD;
-    }
 }
 
 void cpu_reg(CpuRegs *regs) {
@@ -148,56 +125,44 @@ void cpu_goto(zuint16 address) {
     cpu.pc.uint16_value = address;
 }
 
-bool cpu_addBreakpoint(zuint16 address) {
-    // find free breakpoint slot (if any) and add it
-    for (size_t i = 0; i < CPU_BREAKPOINTS; ++i) {
-        if (!breakpoints[i].valid) {
-            breakpoints[i].address = address;
-            breakpoints[i].valid = true;
-            ++valid_breakpoints;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool cpu_deleteBreakpoint(unsigned int index) {
-    if (index >= CPU_BREAKPOINTS)
-        return false;
-
-    breakpoints[index].valid = false;
-    --valid_breakpoints;
-    return true;
-}
-
-size_t cpu_getBreakpoints(CpuBreakpoint *vector[]) {
-    *vector = breakpoints;
-    return CPU_BREAKPOINTS;
-}
-
 void cpu_int(bool state) {
     z80_int(&cpu, state);
 }
 
 static uint8_t cpu_mem_read(void *context, zuint16 address) {
     (void)context;
+    if (monitor_checkReadWatchpoint(address)) {
+        z80_break(&cpu);
+        cpu_pause(true);
+    }
     return bus_mem_read(address);
 }
 
 static void cpu_mem_write(void *context, ceda_address_t address,
                           uint8_t value) {
     (void)context;
+    if (monitor_checkWriteWatchpoint(address, value)) {
+        z80_break(&cpu);
+        cpu_pause(true);
+    }
     bus_mem_write(address, value);
 }
 
 static uint8_t cpu_io_in(void *context, zuint16 address) {
     (void)context;
+    if (monitor_checkInWatchpoint(address)) {
+        z80_break(&cpu);
+        cpu_pause(true);
+    }
     return bus_io_in((ceda_ioaddr_t)address);
 }
 
 static void cpu_io_out(void *context, zuint16 address, zuint8 value) {
     (void)context;
+    if (monitor_checkOutWatchpoint(address, value)) {
+        z80_break(&cpu);
+        cpu_pause(true);
+    }
     return bus_io_out((ceda_ioaddr_t)address, value);
 }
 
@@ -207,6 +172,15 @@ static uint8_t cpu_int_read(void *context, zuint16 address) {
     return int_pop();
 }
 
+static uint8_t cpu_hook(void *context, zuint16 address) {
+    (void)context;
+    (void)address;
+
+    z80_break(&cpu);
+    cpu_pause(true);
+    return Z80_HOOK;
+}
+
 void cpu_init(CEDAModule *mod) {
     // init mod struct
     memset(mod, 0, sizeof(*mod));

src/cpu.h

@@ -26,11 +26,6 @@ typedef struct CpuRegs {
     zuint16 iy;
 } CpuRegs;
 
-typedef struct CpuBreakpoint {
-    bool valid;
-    zuint16 address;
-} CpuBreakpoint;
-
 void cpu_init(CEDAModule *mod);
 
 void cpu_pause(bool enable);
@@ -44,23 +39,6 @@ void cpu_step(void);
  */
 void cpu_goto(zuint16 address);
 
-/**
- * @brief Add a cpu breakpoint.
- *
- * The breakpoint will pause the cpu when the cpu tries to fetch the instruction
- * located at the given address.
- *
- * There is a finite number of breakpoints which can be set.
- *
- * @param address Address of the instruction which must trigger the breakpoint.
- * @return true if the breakpoint has been set, false otherwise.
- */
-bool cpu_addBreakpoint(zuint16 address);
-
-bool cpu_deleteBreakpoint(unsigned int index);
-
-size_t cpu_getBreakpoints(CpuBreakpoint *v[]);
-
 /**
  * @brief Set the interrupt line of the Z80 CPU.
  *