Runtime diag extended with translate_insn

Author: eldiablolives

TODO.md

@@ -41,6 +41,12 @@
     - [ ] Add CI target to run benchmarks and record baselines (tolerant thresholds)
   - [ ] Diagnostics + trap model (structured, stable)
     - [ ] Define stable trap/error codes (decode/verify, OOB, div0, unsupported-op, ABI failure, OOM/fuel)
+      - [x] Fuel exhaustion (structured trap)
+      - [x] Out-of-bounds memory access (structured trap)
+      - [x] Division/mod by zero (structured trap)
+      - [ ] Unsupported opcode (structured trap)
+      - [ ] ABI misuse / host-call failure (structured trap)
+      - [ ] OOM (structured trap)
     - [ ] Extend runtime diagnostics to include trap category + best-effort PC/offset
     - [ ] Ensure all failures are fail-closed (no host crashes, no UB)
   - [ ] Implement code cache keyed by (module hash, mem_base, mem_size, policy flags)
@@ -50,6 +56,11 @@
   - [ ] Define and implement trap/abort behavior (decode error, OOB, div0, unsupported op)
     - [ ] Plumb trap reporting from translated code back to runtime API (no printf-only failures)
     - [ ] Add negative tests for each trap category (including edge-case pointer/len ABI misuse)
+      - [x] Fuel trap smoke coverage
+      - [x] OOB trap smoke coverage (JIT-only)
+      - [x] DIV0 trap smoke coverage (JIT-only)
+      - [ ] Unsupported-op smoke coverage
+      - [ ] ABI misuse smoke coverage
   - [x] Add differential test harness: run the same module under a reference runner and under the JIT; compare rc/stdout/stderr
     - [x] Add a tiny `zrt` CLI runner (executes `.zasm.bin` via `zasm_rt`) for test harness usage
     - [ ] Compare against a reference runner (choose one):

include/zasm_rt.h

@@ -28,6 +28,8 @@ typedef enum zasm_rt_err {
 typedef enum zasm_rt_trap {
   ZASM_RT_TRAP_NONE = 0,
   ZASM_RT_TRAP_FUEL = 1,
+  ZASM_RT_TRAP_OOB = 2,
+  ZASM_RT_TRAP_DIV0 = 3,
 } zasm_rt_trap_t;
 
 /* Translation/execution target selection.
@@ -95,6 +97,14 @@ typedef struct zasm_rt_diag {
   zasm_verify_err_t verify_err;
   size_t verify_off;
   uint8_t verify_opcode;
+
+  /* Optional translate detail (when err==TRANSLATE_FAIL).
+   * translate_err uses zxc_err_t numeric values.
+   */
+  uint32_t translate_err;
+  size_t translate_off;
+  uint8_t translate_opcode;
+  uint32_t translate_insn;
 } zasm_rt_diag_t;
 
 typedef struct zasm_rt_engine zasm_rt_engine_t;

src/common/zasm_rt.c

@@ -176,6 +176,11 @@ static void diag_reset(zasm_rt_diag_t* diag) {
   diag->bin_tag[0] = '\0';
 }
 
+static uint32_t u32_le(const uint8_t* p) {
+  return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) |
+         ((uint32_t)p[3] << 24);
+}
+
 static zasm_rt_err_t diag_fail(zasm_rt_diag_t* diag, zasm_rt_err_t err) {
   if (diag) diag->err = err;
   return err;
@@ -524,10 +529,9 @@ zasm_rt_err_t zasm_rt_instance_create(zasm_rt_engine_t* engine,
 #if defined(__aarch64__) || defined(__arm64__)
   {
     uint64_t fuel_ptr = 0;
-    uint64_t trap_ptr = 0;
+    uint64_t trap_ptr = (uint64_t)(uintptr_t)&inst->trap;
     if (inst->policy.fuel != 0) {
       fuel_ptr = (uint64_t)(uintptr_t)&inst->fuel_remaining;
-      trap_ptr = (uint64_t)(uintptr_t)&inst->trap;
     }
     tr = zxc_arm64_translate(code, code_len,
                              inst->jit_mem, inst->jit_cap,
@@ -537,10 +541,9 @@ zasm_rt_err_t zasm_rt_instance_create(zasm_rt_engine_t* engine,
 #elif defined(__x86_64__) || defined(_M_X64)
   {
     uint64_t fuel_ptr = 0;
-    uint64_t trap_ptr = 0;
+    uint64_t trap_ptr = (uint64_t)(uintptr_t)&inst->trap;
     if (inst->policy.fuel != 0) {
       fuel_ptr = (uint64_t)(uintptr_t)&inst->fuel_remaining;
-      trap_ptr = (uint64_t)(uintptr_t)&inst->trap;
     }
     tr = zxc_x86_64_translate(code, code_len,
                               inst->jit_mem, inst->jit_cap,
@@ -554,6 +557,17 @@ zasm_rt_err_t zasm_rt_instance_create(zasm_rt_engine_t* engine,
   return diag_fail(diag, ZASM_RT_ERR_UNSUPPORTED);
 #endif
   if (tr.err != ZXC_OK) {
+    if (diag) {
+      diag->translate_err = (uint32_t)tr.err;
+      diag->translate_off = tr.in_off;
+      diag->translate_opcode = 0;
+      diag->translate_insn = 0;
+      if (tr.in_off + 4u <= code_len) {
+        uint32_t w = u32_le(code + tr.in_off);
+        diag->translate_insn = w;
+        diag->translate_opcode = (uint8_t)(w >> 24);
+      }
+    }
     zasm_rt_instance_destroy(inst);
     *out_instance = NULL;
     return diag_fail(diag, ZASM_RT_ERR_TRANSLATE_FAIL);

src/zrt/main.c

@@ -39,6 +39,18 @@ static void print_version(void) {
   fprintf(stdout, "zrt %s\n", ZASM_VERSION);
 }
 
+static const char* zxc_err_str_local(uint32_t err) {
+  switch (err) {
+    case 0: return "ok";
+    case 1: return "trunc";
+    case 2: return "align";
+    case 3: return "outbuf";
+    case 4: return "opcode";
+    case 5: return "unimpl";
+    default: return "unknown";
+  }
+}
+
 static int read_whole_file(const char *path, uint8_t **out_buf, size_t *out_len) {
   if (!path || !out_buf || !out_len) return 0;
   *out_buf = NULL;
@@ -106,6 +118,13 @@ static void print_diag(const zasm_rt_diag_t *d) {
     fprintf(stderr, "diag: verify: err=%d off=%zu opcode=0x%02x\n",
             (int)d->verify_err, d->verify_off, (unsigned)d->verify_opcode);
   }
+
+  if (d->err == ZASM_RT_ERR_TRANSLATE_FAIL) {
+    fprintf(stderr, "diag: translate: err=%u(%s) off=%zu opcode=0x%02x insn=0x%08x\n",
+            (unsigned)d->translate_err, zxc_err_str_local(d->translate_err),
+            d->translate_off, (unsigned)d->translate_opcode,
+            (unsigned)d->translate_insn);
+  }
 }
 
 static uint64_t monotonic_ms(void) {
@@ -173,12 +192,33 @@ static int run_guest(const char *path, int safe_mode, int allow_primitives, uint
 
   e = zasm_rt_instance_run(inst, &diag);
   if (e != ZASM_RT_OK) {
-    if (e == ZASM_RT_ERR_EXEC_FAIL && diag.trap == ZASM_RT_TRAP_FUEL) {
-      fprintf(stderr, "zrt: trap: fuel exhausted\n");
-      zasm_rt_instance_destroy(inst);
-      zasm_rt_module_destroy(module);
-      zasm_rt_engine_destroy(engine);
-      return 1;
+    if (e == ZASM_RT_ERR_EXEC_FAIL) {
+      switch (diag.trap) {
+        case ZASM_RT_TRAP_FUEL:
+          fprintf(stderr, "zrt: trap: fuel exhausted\n");
+          zasm_rt_instance_destroy(inst);
+          zasm_rt_module_destroy(module);
+          zasm_rt_engine_destroy(engine);
+          return 1;
+        case ZASM_RT_TRAP_OOB:
+          fprintf(stderr, "zrt: trap: out of bounds memory access\n");
+          zasm_rt_instance_destroy(inst);
+          zasm_rt_module_destroy(module);
+          zasm_rt_engine_destroy(engine);
+          return 1;
+        case ZASM_RT_TRAP_DIV0:
+          fprintf(stderr, "zrt: trap: division by zero\n");
+          zasm_rt_instance_destroy(inst);
+          zasm_rt_module_destroy(module);
+          zasm_rt_engine_destroy(engine);
+          return 1;
+        default:
+          fprintf(stderr, "zrt: trap\n");
+          zasm_rt_instance_destroy(inst);
+          zasm_rt_module_destroy(module);
+          zasm_rt_engine_destroy(engine);
+          return 1;
+      }
     }
     fprintf(stderr, "zrt: error: instance_run: %s\n", zasm_rt_err_str(e));
     print_diag(&diag);