kit

step.c (9298B)

---

 /* Resume-mode state machine.
  *
  * STEP_INSN uses the displaced-step primitive directly via pending_pc_override
  * and the outer session_resume's signal/wait. STEP_LINE / NEXT_LINE / STEP_OUT
  * drive their own signal/wait cycles in-loop and set pending_done so the outer
  * resume short-circuits. */
 
 #include <string.h>
 
 #include "core/slice.h"
 #include "dbg/dbg.h"
 
 #define DBG_STEP_LINE_INSN_CAP 1024u
 
 static KitStatus run_step_line_loop(KitDebugSession* s);
 
 /* DWARF line/CFI tables are authored in image-relative vaddrs (kit's
  * debug emitter writes them, the JIT view applies relocs against final
  * image vaddrs).  Stop PCs and the values dropped onto the stack by
  * BL/RET, on the other hand, live in runtime address space.  Every
  * DWARF call from the session translates at the boundary. */
 static uint64_t step_rt_to_img(KitDebugSession* s, uint64_t pc) {
   uint64_t v = kit_jit_runtime_to_image(s->jit, pc);
   return v ? v : pc;
 }
 
 static KitStatus prepare_step_insn(KitDebugSession* s) {
   uint64_t pc = s->stop.regs.pc;
   uint64_t scratch_entry = 0;
   KitStatus st = dbg_displaced_prepare(s, pc, &scratch_entry);
   if (st != KIT_OK) return st;
   s->pending_has_pc = 1;
   s->pending_pc_override = scratch_entry;
   return KIT_OK;
 }
 
 /* Drive a single displaced-step cycle synchronously. Returns KIT_OK on
  * success; the session is parked again at the post-step PC. */
 static KitStatus do_one_displaced(KitDebugSession* s) {
   KitStatus st = prepare_step_insn(s);
   if (st != KIT_OK) return st;
   st = dbg_session_signal_resume(s);
   if (st != KIT_OK) return st;
   return dbg_session_wait_stop(s);
 }
 
 static int stop_is_internal_completion(const KitDebugSession* s) {
   return s->stop.kind == KIT_STOP_BREAKPOINT && s->stop.bp_id == 0;
 }
 
 /* Arm a one-shot internal bp at `target`, resume the worker, and wait for the
  * next stop. on_fault clears the internal bp only if it is the bp that traps;
  * if a user bp / signal / exit intervenes first the one-shot would linger and
  * later resurface as a spurious bp_id==0 stop, so clear it here on any return
  * path that is not its own completion. Mirrors the displaced-step sentinel
  * cleanup. */
 static KitStatus run_to_internal_bp(KitDebugSession* s, uint64_t target) {
   u32 bp_id = 0;
   KitStatus st = dbg_bp_set_internal(s, target, &bp_id);
   if (st != KIT_OK) return st;
   st = dbg_session_signal_resume(s);
   if (st != KIT_OK) {
     dbg_bp_clear(s, bp_id);
     return st;
   }
   st = dbg_session_wait_stop(s);
   if (st != KIT_OK) {
     dbg_bp_clear(s, bp_id);
     return st;
   }
   if (!stop_is_internal_completion(s)) {
     dbg_bp_clear(s, bp_id);
   }
   return KIT_OK;
 }
 
 static KitStatus direct_call_target(KitDebugSession* s, uint64_t* target) {
   ArchDbgInsn insn;
   if (!s->arch_dbg || !s->arch_dbg->direct_call_target) return KIT_NOT_FOUND;
   if (dbg_arch_decode_insn(s, s->stop.regs.pc, &insn) != KIT_OK)
     return KIT_NOT_FOUND;
   return s->arch_dbg->direct_call_target(&insn, target);
 }
 
 static KitStatus direct_jump_target(KitDebugSession* s, uint64_t* target) {
   ArchDbgInsn insn;
   if (!s->arch_dbg || !s->arch_dbg->direct_jump_target) return KIT_NOT_FOUND;
   if (dbg_arch_decode_insn(s, s->stop.regs.pc, &insn) != KIT_OK)
     return KIT_NOT_FOUND;
   return s->arch_dbg->direct_jump_target(&insn, target);
 }
 
 static KitStatus dwarf_line_for(KitDebugSession* s, uint64_t pc, KitSlice* file,
                                 uint32_t* line) {
   uint32_t col = 0;
   *file = KIT_SLICE_NULL;
   *line = 0;
   return kit_dwarf_addr_to_line(s->dwarf, step_rt_to_img(s, pc), file, line,
                                 &col);
 }
 
 static KitStatus dwarf_sub_for(KitDebugSession* s, uint64_t pc,
                                KitDwarfSubprogram* out) {
   memset(out, 0, sizeof(*out));
   return kit_dwarf_subprogram_at(s->dwarf, step_rt_to_img(s, pc), out);
 }
 
 static int line_changed(KitSlice base_file, uint32_t base_line,
                         KitSlice new_file, uint32_t new_line) {
   if (new_line == 0) return 0;
   if (base_line == 0) return 1;
   if (new_line != base_line) return 1;
   if (base_file.s != new_file.s) {
     if (!base_file.s || !new_file.s) return 1;
     if (!slice_eq(base_file, new_file)) return 1;
   }
   return 0;
 }
 
 static KitStatus try_step_into_direct_call(KitDebugSession* s, int* did) {
   uint64_t target = 0;
   KitStatus st;
   *did = 0;
   st = direct_call_target(s, &target);
   if (st == KIT_NOT_FOUND || st == KIT_UNSUPPORTED) return KIT_OK;
   if (st != KIT_OK) return st;
   *did = 1;
   st = run_to_internal_bp(s, target);
   if (st != KIT_OK) return st;
   if (stop_is_internal_completion(s)) {
     return run_step_line_loop(s);
   }
   return KIT_OK;
 }
 
 static KitStatus try_follow_direct_jump(KitDebugSession* s, int* did) {
   uint64_t target = 0;
   KitStatus st;
   *did = 0;
   st = direct_jump_target(s, &target);
   if (st == KIT_NOT_FOUND || st == KIT_UNSUPPORTED) return KIT_OK;
   if (st != KIT_OK) return st;
   *did = 1;
   return run_to_internal_bp(s, target);
 }
 
 static KitStatus run_step_line_loop(KitDebugSession* s) {
   KitSlice base_file = KIT_SLICE_NULL;
   uint32_t base_line = 0;
   KitDwarfSubprogram base_sub;
   int have_sub;
   u32 i;
 
   (void)dwarf_line_for(s, s->stop.regs.pc, &base_file, &base_line);
   have_sub = (dwarf_sub_for(s, s->stop.regs.pc, &base_sub) == KIT_OK);
 
   for (i = 0; i < DBG_STEP_LINE_INSN_CAP; ++i) {
     KitSlice new_file = KIT_SLICE_NULL;
     uint32_t new_line = 0;
     KitDwarfSubprogram new_sub;
     int have_new_sub;
     int did_call = 0;
     int did_jump = 0;
     KitStatus st;
 
     st = try_step_into_direct_call(s, &did_call);
     if (st != KIT_OK) return st;
     if (did_call) return KIT_OK;
 
     st = try_follow_direct_jump(s, &did_jump);
     if (st != KIT_OK) return st;
 
     if (!did_jump && do_one_displaced(s) != KIT_OK) {
       /* Lifter declined; surface whatever the current stop is. */
       return KIT_OK;
     }
     if (!stop_is_internal_completion(s)) {
       /* User breakpoint, signal, or exit — surface. */
       return KIT_OK;
     }
 
     (void)dwarf_line_for(s, s->stop.regs.pc, &new_file, &new_line);
     have_new_sub = (dwarf_sub_for(s, s->stop.regs.pc, &new_sub) == KIT_OK);
 
     if (have_sub && have_new_sub) {
       if (new_sub.low_pc != base_sub.low_pc) {
         /* Left the original subprogram — STEP_LINE follows in. */
         return KIT_OK;
       }
     }
 
     if (line_changed(base_file, base_line, new_file, new_line)) {
       return KIT_OK;
     }
   }
   return KIT_OK;
 }
 
 static KitStatus run_step_out(KitDebugSession* s) {
   KitUnwindFrame frame;
   KitStatus st;
   frame = s->stop.regs;
   frame.pc = step_rt_to_img(s, frame.pc); /* CFI lookup is in image space */
   st = kit_dwarf_unwind_step(s->dwarf, &frame);
   if (st != KIT_OK) {
     if (!s->arch_dbg || !s->arch_dbg->link_register_return_address ||
         s->arch_dbg->link_register_return_address(&s->stop.regs, &frame.pc) !=
             KIT_OK) {
       return st;
     }
   }
   /* On success unwind_step or the link-register fallback writes frame.pc from
    * the saved return-address register / stack slot — already a runtime PC, no
    * inverse translation needed before the internal bp install. */
   if (frame.pc == 0) return KIT_NOT_FOUND;
   return run_to_internal_bp(s, frame.pc);
 }
 
 static KitStatus run_next_line(KitDebugSession* s) {
   ArchDbgInsn insn;
 
   if (!s->arch_dbg || !s->arch_dbg->is_call ||
       dbg_arch_decode_insn(s, s->stop.regs.pc, &insn) != KIT_OK) {
     return run_step_line_loop(s);
   }
   if (!s->arch_dbg->is_call(&insn)) {
     return run_step_line_loop(s);
   }
 
   /* Step OVER the call by setting an internal bp at the unwound return PC
    * and CONTINUE-ing. After the bp fires, fall into the STEP_LINE loop to
    * keep advancing until the source line actually changes. */
   {
     KitUnwindFrame frame = s->stop.regs;
     KitStatus st;
     frame.pc = step_rt_to_img(s, frame.pc);
     if (kit_dwarf_unwind_step(s->dwarf, &frame) != KIT_OK || frame.pc == 0) {
       /* Fall back to stepping into the call. */
       return run_step_line_loop(s);
     }
     /* frame.pc is now a runtime return-address (from the stack). */
     st = run_to_internal_bp(s, frame.pc);
     if (st != KIT_OK) return st;
     if (stop_is_internal_completion(s)) {
       return run_step_line_loop(s);
     }
     return KIT_OK;
   }
 }
 
 KitStatus dbg_step_resume(KitDebugSession* s, KitResumeMode mode) {
   switch (mode) {
     case KIT_RESUME_ABORT:
       return KIT_OK;
     case KIT_RESUME_CONTINUE:
       if (dbg_bp_lookup_index(s, s->stop.regs.pc) != 0) {
         return prepare_step_insn(s);
       }
       return KIT_OK;
 
     case KIT_RESUME_STEP_INSN:
       return prepare_step_insn(s);
 
     case KIT_RESUME_STEP_LINE: {
       KitStatus st;
       if (!s->dwarf) return KIT_INVALID;
       st = run_step_line_loop(s);
       if (st != KIT_OK) return st;
       s->pending_done = 1;
       return KIT_OK;
     }
 
     case KIT_RESUME_NEXT_LINE: {
       KitStatus st;
       if (!s->dwarf) return KIT_INVALID;
       st = run_next_line(s);
       if (st != KIT_OK) return st;
       s->pending_done = 1;
       return KIT_OK;
     }
 
     case KIT_RESUME_STEP_OUT: {
       KitStatus st;
       if (!s->dwarf) return KIT_INVALID;
       st = run_step_out(s);
       if (st != KIT_OK) return st;
       s->pending_done = 1;
       return KIT_OK;
     }
   }
   return KIT_INVALID;
 }