support JP (HL/IX/IY) tail calls

Author: Sightem

core/cpu.c

@@ -60,7 +60,7 @@ static void debug_break_before_ret(const uint32_t len) {
     if (unlikely(debug.untilRet)) {
         const uint32_t curSp = cpu_address_mode(cpu.registers.stack[cpu.L].hl, cpu.L);
         if (curSp >= debug.untilRetBase) {
-            const uint32_t start = cpu_mask_mode(cpu.registers.PC - len, cpu.ADL);
+            const uint32_t start = cpu_mask_mode(cpu.registers.PC - (len + (cpu.SUFFIX ? 1u : 0u)), cpu.ADL);
             cpu.registers.PC = start;
             debug_open(DBG_STEP, cpu.registers.PC);
         }
@@ -1236,10 +1236,21 @@ void cpu_execute(void) {
                                             REG_WRITE_EX(HL,  r->HL,  r->_HL);
                                             REG_WRITE_EX(HLP, r->_HL, w);
                                             break;
-                                        case 2: /* JP (rr) */
+                                        case 2: { /* JP (rr) */
+                                            uint32_t target = cpu_read_index();
                                             cpu_prefetch_discard();
+#ifdef DEBUG_SUPPORT
+                                            if (unlikely(debug.untilRet)) {
+                                                uint32_t curSp = cpu_address_mode(cpu.registers.stack[cpu.L].hl, cpu.L);
+                                                /* if this indirect jp is a logical return for the frame
+                                                 * where DBG_UNTIL_RET started, the hook rewinds PC and opens
+                                                 * the debugger */
+                                                (void)debug_until_ret_handle_indirect_jump(target, curSp);
+                                            }
+#endif
                                             cpu_jump(cpu_read_index(), cpu.L);
                                             break;
+                                        }
                                         case 3: /* LD SP, HL */
                                             cpu_write_sp(cpu_read_index());
                                             break;

core/debug/debug.c

@@ -316,6 +316,7 @@ void debug_step(int mode, uint32_t addr) {
             gui_debug_close();
             debug.untilRet = true;
             debug.untilRetBase = cpu_address_mode(cpu.registers.stack[cpu.L].hl, cpu.L);
+            debug.untilRetIndex = debug.stackIndex;
             break;
         case DBG_BASIC_STEP_IN:
         case DBG_BASIC_STEP_NEXT:
@@ -335,6 +336,48 @@ void debug_clear_step(void) {
     debug.tempExec = debug.stepOut = ~0u;
     debug.untilRet = false;
     debug.untilRetBase = 0;
+    debug.untilRetIndex = 0;
+}
+
+bool debug_until_ret_handle_indirect_jump(uint32_t target, uint32_t currentSp) {
+    /* stop if this JP(rr) is an actual return for a
+    * recorded call frame, where target matches its retAddr and
+    * SP has been restored to that frame's precall stack
+    * value (or frame was detected popped) */
+    uint32_t idx = debug.stackIndex;
+    uint32_t sz = debug.stackSize;
+    debug_stack_entry_t *hit = NULL;
+    uint32_t hit_idx = ~0u;
+
+    while (sz--) {
+        debug_stack_entry_t *entry = &debug.stack[idx];
+        const uint32_t this_idx = idx;
+        idx = (idx - 1) & DBG_STACK_MASK;
+        if (entry->mode == cpu.L &&
+            /* only consider frames above current SP baseline. target
+             * must also match the frame's retAddr window */
+            entry->stack >= debug.untilRetBase &&
+            (target - entry->retAddr) <= entry->range) {
+            hit = entry;
+            hit_idx = this_idx;
+            break;
+        }
+    }
+
+    /* break if we are returning from the same frame
+     * where DBG_UNTIL_RET started */
+    if (hit && hit_idx == debug.untilRetIndex &&
+        (currentSp == hit->stack || hit->popped)) {
+        const uint32_t len = 1 + (cpu.PREFIX != 0);
+        const uint32_t start = cpu_mask_mode(
+            cpu.registers.PC - (len + (cpu.SUFFIX ? 1u : 0u)),
+            cpu.ADL);
+        REG_WRITE_EX(PC, cpu.registers.PC, start);
+        debug_open(DBG_STEP, cpu.registers.PC);
+        return true;
+    }
+
+    return false;
 }
 
 void debug_clear_basic_step(void) {

core/debug/debug.h

@@ -147,6 +147,7 @@ typedef struct {
     uint32_t tempExec, stepOut;
     bool untilRet;
     uint32_t untilRetBase; /* normalized 24bit stack pointer baseline */
+    uint32_t untilRetIndex; /* call-stack index when DBG_UNTIL_RET started */
 
     uint32_t stackIndex, stackSize;
     debug_stack_entry_t *stack;
@@ -190,6 +191,7 @@ enum {
 void debug_step_switch(void);
 void debug_clear_step(void);
 void debug_clear_basic_step(void);
+bool debug_until_ret_handle_indirect_jump(uint32_t target, uint32_t currentSp);
 #endif
 
 /* register watchpoints */