Fix JIT regression when code cache flushes during translation

This addresses critical issues in the JIT compiler that caused failures,
particularly noticeable when ENABLE_EXT_F=0:
1. Check translation success before execution: The emulator now verifies
   that jit_translate() successfully marked a block as "hot" before
   attempting to execute the JIT-compiled code. This prevents execution
   of incomplete or failed translations.
2. Reset jump count on cache flush: The state->n_jumps counter was not
   being reset during code_cache_flush(), causing stale jump entries to
   persist and corrupt subsequent translations.
3. Mark incomplete translations properly: When a cache flush occurs
   mid-translation, the block is now correctly marked as not hot,
   ensuring it won't be mistakenly executed as valid JIT code.

These fixes resolve the non-deterministic test failures observed in
the pi calculation test and other compute-intensive benchmarks.

Author: jserv

src/emulate.c

@@ -1155,10 +1155,14 @@ void rv_step(void *arg)
 #endif
         ) {
             jit_translate(rv, block);
-            ((exec_block_func_t) state->buf)(
-                rv, (uintptr_t) (state->buf + block->offset));
-            prev = NULL;
-            continue;
+            /* Only execute if translation succeeded (block is hot) */
+            if (block->hot) {
+                ((exec_block_func_t) state->buf)(
+                    rv, (uintptr_t) (state->buf + block->offset));
+                prev = NULL;
+                continue;
+            }
+            /* Fall through to interpreter if translation failed */
         }
         set_reset(&pc_set);
         has_loops = false;

src/jit.c

@@ -611,6 +611,7 @@ static void update_branch_imm(struct jit_state *state,
     pthread_jit_write_protect_np(false);
 #endif
     memcpy(state->buf + offset, &insn, sizeof(uint32_t));
+    sys_icache_invalidate(state->buf + offset, sizeof(uint32_t));
 #if defined(__APPLE__) && defined(__aarch64__)
     pthread_jit_write_protect_np(true);
 #endif
@@ -2167,6 +2168,7 @@ static void code_cache_flush(struct jit_state *state, riscv_t *rv)
     should_flush = false;
     state->offset = state->org_size;
     state->n_blocks = 0;
+    state->n_jumps = 0; /* Reset jump count when flushing */
     set_reset(&state->set);
     clear_cache_hot(rv->block_cache, (clear_func_t) clear_hot);
 #if RV32_HAS(T2C)
@@ -2320,6 +2322,9 @@ void jit_translate(riscv_t *rv, block_t *block)
     block->offset = state->offset;
     translate_chained_block(state, rv, block);
     if (unlikely(should_flush)) {
+        /* Mark block as not translated since translation was incomplete */
+        block->hot = false;
+        /* Don't reset offset - it will be set correctly on restart */
         code_cache_flush(state, rv);
         goto restart;
     }