Add diagnostic logging to JIT compilation pipeline

This introduces debug-level logging throughout the JITC to facilitate
troubleshooting of intermittent compilation and execution failures on
Arm64.

Author: jserv

src/emulate.c

@@ -24,6 +24,7 @@ extern struct target_ops gdbstub_ops;
 #endif
 
 #include "decode.h"
+#include "log.h"
 #include "mpool.h"
 #include "riscv.h"
 #include "riscv_private.h"
@@ -1207,12 +1208,16 @@ void rv_step(void *arg)
             jit_translate(rv, block);
             /* Only execute if translation succeeded (block is hot) */
             if (block->hot) {
+                rv_log_debug("JIT: Executing block pc=0x%08x, offset=%u",
+                             block->pc_start, block->offset);
                 ((exec_block_func_t) state->buf)(
                     rv, (uintptr_t) (state->buf + block->offset));
                 prev = NULL;
                 continue;
             }
             /* Fall through to interpreter if translation failed */
+            rv_log_debug("JIT: Translation failed for block pc=0x%08x, using interpreter",
+                         block->pc_start);
         }
         set_reset(&pc_set);
         has_loops = false;

src/jit.c

@@ -42,6 +42,7 @@
 #include "decode.h"
 #include "io.h"
 #include "jit.h"
+#include "log.h"
 #include "riscv.h"
 #include "riscv_private.h"
 #include "utils.h"
@@ -593,6 +594,7 @@ static void update_branch_imm(struct jit_state *state,
     assert((imm & 3) == 0);
     uint32_t insn;
     imm >>= 2;
+    rv_log_debug("JIT: Patching branch at offset=%u, imm=%d", offset, imm << 2);
 #if defined(__APPLE__) && defined(__aarch64__)
     /* Must be in write mode to read/write MAP_JIT memory on Apple ARM64 */
     pthread_jit_write_protect_np(false);
@@ -2166,6 +2168,8 @@ void clear_hot(block_t *block)
 
 static void code_cache_flush(struct jit_state *state, riscv_t *rv)
 {
+    rv_log_debug("JIT: Flushing code cache (n_blocks=%d, n_jumps=%d, offset=%u)",
+                 state->n_blocks, state->n_jumps, state->offset);
     should_flush = false;
     state->offset = state->org_size;
     state->n_blocks = 0;
@@ -2199,6 +2203,7 @@ static void translate(struct jit_state *state, riscv_t *rv, block_t *block)
 
 static void resolve_jumps(struct jit_state *state)
 {
+    rv_log_debug("JIT: Resolving %d jumps", state->n_jumps);
     for (int i = 0; i < state->n_jumps; i++) {
         struct jump jump = state->jumps[i];
         int target_loc;
@@ -2221,6 +2226,8 @@ static void resolve_jumps(struct jit_state *state)
                     (if (jump.target_satp == state->offset_map[i].satp), )
                     {
                         target_loc = state->offset_map[i].offset;
+                        rv_log_debug("JIT: Jump %d resolved to block pc=0x%08x, offset=%d",
+                                     i, jump.target_pc, target_loc);
                         break;
                     }
                 }
@@ -2312,12 +2319,15 @@ void jit_translate(riscv_t *rv, block_t *block)
             ) {
                 block->offset = state->offset_map[i].offset;
                 block->hot = true;
+                rv_log_debug("JIT: Cache hit for block pc=0x%08x, offset=%u",
+                             block->pc_start, block->offset);
                 return;
             }
         }
         assert(NULL);
         __UNREACHABLE;
     }
+    rv_log_debug("JIT: Starting translation for block pc=0x%08x", block->pc_start);
 restart:
     memset(state->jumps, 0, MAX_JUMPS * sizeof(struct jump));
     state->n_jumps = 0;
@@ -2327,11 +2337,15 @@ void jit_translate(riscv_t *rv, block_t *block)
         /* Mark block as not translated since translation was incomplete */
         block->hot = false;
         /* Don't reset offset - it will be set correctly on restart */
+        rv_log_debug("JIT: Translation triggered flush for block pc=0x%08x",
+                     block->pc_start);
         code_cache_flush(state, rv);
         goto restart;
     }
     resolve_jumps(state);
     block->hot = true;
+    rv_log_debug("JIT: Translation completed for block pc=0x%08x, offset=%u, size=%u",
+                 block->pc_start, block->offset, state->offset - block->offset);
 }
 
 struct jit_state *jit_state_init(size_t size)