code wiki / _hdl_build / nx_gdbstub_gate.nx
`nx_gdbstub_gate.nx` source

↩ module page · 490 lines · 26859 B
1// nx_gdbstub_gate.nx -- the VERDICT gate for NO1 (nx_gdbstub, watch symbol gdbstub_serve).  NO mocks.
2//
3// THE ACCEPT RULE (nishios.plan NO1, verbatim): a STOCK gdb attaches to a running guest, breaks at an
4// address the disassembler independently resolved, steps, reads a register whose value a separate path
5// derived, and detaches leaving the guest running -- plus a NEG-CONTROL that a breakpoint at an address
6// never executed does NOT stop.  The oracle is a third-party debugger, so this rung cannot be self-graded.
7//
8// HOW EACH EXPECTATION IS DERIVED INDEPENDENTLY OF THE STUB (the stub is never its own oracle):
9//   bp address   = the pc of the FIRST store-kind instruction the K-R0 boot image executes, found by
10//                  running a SECOND, stub-free sim in this process and DECODING each fetched word with
11//                  rv64im_min_decoder (nx_rv64im_decode_kind == NX_RV64IM_OP_STORE).
12//   register     = that store's rs2 (decoded) read from the reference sim's regfile at that pc.
13//   next pc      = bp + 4, after asserting the word is a 32-bit encoding ((w & 3) == 3) and a store never branches.
14//   memory words = the first two little-endian words of the IMAGE FILE, not of any sim.
15//   never-addr   = the lowest 4-aligned RAM address at/after the image end that the reference run NEVER
16//                  fetched (a bitmap of every executed pc over the WHOLE boot, not a guess).
17//   golden       = <image>.gold, the transcript the boot rulers already certify.
18//
19// SESSIONS (each on a FRESH stub process, port 0 = kernel-chosen, read back from the stub's ready file):
20//   A  stock gdb: attach, break *bp, continue, p/x $xN, stepi, x/2xw mem_base, detach  -> T1..T7
21//   B  stock gdb: break *never-addr, continue -> the guest must run to EXIT, never a breakpoint stop -> T8
22//   C  sovereign RSP client (no gdb): a frame with a WRONG checksum must be NAK'd; a good '?' must be
23//      ACK'd and answered S05; 'D' must be answered OK; the stub must count the bad frame -> T9..T12
24// If no stock gdb is on this host, sessions A/B are a MISSING PRECONDITION (gv_need -> SKIP), never a
25// pass and never a RED: the oracle leg is reported UNWITNESSED, C still runs.  (NAS: no gdb; laptop WSL:
26// gdb-multiarch 15.1 installed 2026-08-23 as a third-party ORACLE only.)
27//
28// Fixtures live in /tmp/nx_gdbstub_gate/ (created at setup; a crashed run cannot leave a fixture beside a
29// production beat).  Every tooth prints the values it compared, not only PASS/FAIL.
30// license_tier: ORIGINAL (the debugger is an oracle; nothing of it ships)
31import "nx_syscalls.nx"
32import "nx_gate_verdict.nx"
33import "nx_gatekit_lib.nx"
34import "nx_http_server.nx"
35import "nx_bootcap.nx"
36import "rv64im_min_decoder.nx"
37
38const GG_DIR:        *u8 = "/tmp/nx_gdbstub_gate"
39const GG_IMG:        *u8 = "runtime/_hdl_build/_boot_nishi_virt.bin"
40const GG_IMG_ALT:    *u8 = "_boot_nishi_virt.bin"
41const GG_OUT_CAP:    i64 = 1048576         // gdb's batch output for a 1,164-step boot is a few KB; 1 MiB = the gatekit capture bound
42// A stub that has not written its ready file within this budget never listened (the measured start is
43// ~0.3 s: load a 2 KB image, listen, write one line).  Announced when it fires; never silent.
44const GG_READY_MS:   i64 = 5000
45const GG_READY_POLL_MS: i64 = 50
46// A gdb session over the K-R0 image (1,164 guest steps) completes in well under a second; a minute is a
47// hang, and a hung oracle must become a failed tooth, not a hung gate (the gatekit watchdog kills it).
48const GG_GDB_MS:     i64 = 60000
49const GG_IO_MS:      i64 = 5000            // session C: one reply should arrive within this; a stub that answers nothing fails the tooth
50const GG_RV_INSTR_BYTES: i64 = 4
51const GG_EXIT_CODE_RD: i64 = 0
52
53func gg_p(s: *u8) -> i64 { return gv_puts(s) }
54func gg_n(v: i64) -> i64 { return gv_num(v) }
55func gg_hex(v: i64) -> i64 {
  let b: *u8 = sys_mmap(16)
  var i: i64 = 0
  while i < 16 {
      let nib: i64 = (v >> ((15 - i) * 4)) & 15
      if nib < 10 { b[i] = (48 + nib) as u8 } else { b[i] = (87 + nib) as u8 }
      i = i + 1
  }
  sys_write(1, b, 16)
  sys_munmap(b, 16)
  return 0
66}
67// find needle in buf[from..n); returns index or -1
68func gg_find(buf: *u8, n: i64, from: i64, needle: *u8) -> i64 {
  let nl: i64 = gk_len(needle)
  if nl == 0 { return 0 - 1 }
  var i: i64 = from
  while i + nl <= n {
      var j: i64 = 0
      var ok: i64 = 1
      while j < nl { if buf[i + j] != needle[j] { ok = 0; j = nl } j = j + 1 }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
80}
81func gg_hexval(c: i64) -> i64 {
  if c >= 48 { if c <= 57 { return c - 48 } }
  if c >= 97 { if c <= 102 { return c - 87 } }
  if c >= 65 { if c <= 70 { return c - 55 } }
  return 0 - 1
86}
87// parse hex digits at buf[i..]; returns the value, digits counted into ndig[0]
88func gg_parse_hex(buf: *u8, n: i64, i: i64, ndig: *i64) -> i64 {
  var v: i64 = 0
  var k: i64 = i
  var d: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if k >= n { go = 0; continue }
      let h: i64 = gg_hexval(buf[k] as i64)
      if h < 0 { go = 0; continue }
      v = (v << 4) | h
      d = d + 1
      k = k + 1
  }
  ndig[0] = d
  return v
103}
104// value printed after the k-th occurrence (1-based) of `needle` followed by "0x"
105func gg_value_after(buf: *u8, n: i64, needle: *u8, k: i64, found: *i64) -> i64 {
  var from: i64 = 0
  var hits: i64 = 0
  var at: i64 = 0 - 1
  var go: i64 = 1
  while go == 1 {
      at = gg_find(buf, n, from, needle)
      if at < 0 { go = 0; continue }
      hits = hits + 1
      if hits == k { go = 0; continue }
      from = at + 1
  }
  if at < 0 { found[0] = 0; return 0 }
  if hits < k { found[0] = 0; return 0 }
  let px: i64 = gg_find(buf, n, at + gk_len(needle), "0x" as *u8)
  if px < 0 { found[0] = 0; return 0 }
  let nd: *i64 = sys_mmap(8) as *i64
  let v: i64 = gg_parse_hex(buf, n, px + 2, nd)
  if nd[0] == 0 { found[0] = 0; return 0 }
  found[0] = 1
  return v
126}
127
128// ---- resolve the subject (the deployed stub) and the oracle (a stock gdb): say which one was used
129func gg_resolve(out: *u8, a: *u8, b: *u8, c: *u8) -> i64 {
  if gk_exists(a) == 1 { gk_cat(out, 0, a); out[gk_len(a)] = 0 as u8; return 1 }
  if gk_exists(b) == 1 { gk_cat(out, 0, b); out[gk_len(b)] = 0 as u8; return 1 }
  if gk_exists(c) == 1 { gk_cat(out, 0, c); out[gk_len(c)] = 0 as u8; return 1 }
  out[0] = 0 as u8
  return 0
135}
136
137// ---- spawn the stub in the background, stdout+stderr -> logpath.  Returns pid.
138func gg_spawn(elf: *u8, a1: *u8, a2: *u8, a3: *u8, logpath: *u8) -> i64 {
  let argv: *i64 = sys_mmap(64) as *i64
  argv[0] = elf as i64
  argv[1] = a1 as i64
  argv[2] = a2 as i64
  argv[3] = a3 as i64
  argv[4] = 0
  let envp: *i64 = sys_mmap(16) as *i64
  envp[0] = 0
  let pid: i64 = sys_fork()
  if pid < 0 { return 0 - 1 }
  if pid == 0 {
      let lf: i64 = sys_openat_wr(logpath, 420)
      if lf >= 0 { sys_dup3(lf, 1, 0); sys_dup3(lf, 2, 0) }
      sys_execve(elf, argv, envp)
      sys_exit(127)
  }
  return pid
156}
157// wait for the ready file and parse "port=N"; returns the port or -1
158func gg_wait_port(readyfile: *u8) -> i64 {
  var waited: i64 = 0
  let buf: *u8 = sys_mmap(256)
  while waited < GG_READY_MS {
      let n: i64 = gk_read(readyfile, buf, 255)
      if n > 5 {
          var v: i64 = 0
          var i: i64 = 5
          var digits: i64 = 0
          while i < n { let c: i64 = buf[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); digits = digits + 1 } } i = i + 1 }
          if digits > 0 { return v }
      }
      sys_sleep_ms(GG_READY_POLL_MS)
      waited = waited + GG_READY_POLL_MS
  }
  return 0 - 1
174}
175// bounded wait for a child: returns its exit code, or -1 if it had to be killed (announced)
176func gg_reap(pid: i64, budget_ms: i64) -> i64 {
  let st: *i64 = sys_mmap(16) as *i64
  var waited: i64 = 0
  while waited < budget_ms {
      st[0] = 0
      let r: i64 = sys_wait4(pid, st, WNOHANG)
      if r == pid { return gk_wait_code(st[0]) }
      sys_sleep_ms(GG_READY_POLL_MS)
      waited = waited + GG_READY_POLL_MS
  }
  gg_p("  WATCHDOG: stub pid did not exit within budget -- killed (this is a failed tooth, not a pass)\n" as *u8)
  nx_kill(pid, 9)
  sys_wait4(pid, st, 0)
  return 0 - 1
190}
191
192// ---- session C: a sovereign RSP client that sends raw frames and reads raw replies
193func gg_rsp_connect(port: i64) -> i64 {
  let fd: i64 = sys_socket(AF_INET, SOCK_STREAM, 0)
  if fd < 0 { return 0 - 1 }
  let sa: *u8 = sys_mmap(16)
  nx_http_server_addr_loopback(sa, port)
  let rc: i64 = sys_connect(fd, sa, 16)
  if rc < 0 { sys_close(fd); return 0 - 1 }
  return fd
201}
202// read until `want` bytes are present or the budget expires; returns bytes read
203func gg_rsp_read(fd: i64, buf: *u8, cap: i64, want: i64) -> i64 {
  var n: i64 = 0
  var waited: i64 = 0
  while n < want {
      let pfd: *u8 = sys_mmap(8)
      pfd[0] = (fd & 255) as u8; pfd[1] = ((fd >> 8) & 255) as u8; pfd[2] = ((fd >> 16) & 255) as u8; pfd[3] = ((fd >> 24) & 255) as u8
      pfd[4] = 1 as u8; pfd[5] = 0 as u8; pfd[6] = 0 as u8; pfd[7] = 0 as u8
      let r: i64 = sys_poll(pfd, 1, GG_IO_MS)
      sys_munmap(pfd, 8)
      if r <= 0 { return n }
      let got: i64 = sys_read(fd, ((buf as i64) + n) as *u8, cap - n)
      if got <= 0 { return n }
      n = n + got
      waited = waited + 1
  }
  return n
219}
220
221func main() -> i64 {
  gv_head("nx_gdbstub gate -- a STOCK gdb over the sovereign rv64 emulator; expectations derived by a stub-free sim + the decoder + the image file; neg-controls for a never-executed breakpoint and a bad checksum" as *u8)
  let ctr: *i64 = gv_ctr()
  gk_mkdir(GG_DIR)
225
  // ---- subject + oracle resolution (announce what was measured)
  let elf: *u8 = sys_mmap(512)
  let have_elf: i64 = gg_resolve(elf, "_offc/nx_gdbstub.elf" as *u8, "./nx_gdbstub.elf" as *u8, "_build/nx_gdbstub.sov.elf" as *u8)
  gg_p("  subject: " as *u8); if have_elf == 1 { gg_p(elf) } else { gg_p("ABSENT (looked in _offc/, ./, _build/)" as *u8) } gg_p("\n" as *u8)
  let gdb: *u8 = sys_mmap(512)
  let have_gdb: i64 = gg_resolve(gdb, "/usr/bin/gdb-multiarch" as *u8, "/usr/bin/gdb" as *u8, "/usr/local/bin/gdb-multiarch" as *u8)
  gg_p("  oracle:  " as *u8); if have_gdb == 1 { gg_p(gdb) } else { gg_p("ABSENT -- stock-gdb leg UNWITNESSED on this host" as *u8) } gg_p("\n" as *u8)
  let lenp: *i64 = sys_mmap(16) as *i64
  let pathp: *i64 = sys_mmap(16) as *i64
  let img: *u8 = bootcap_load(GG_IMG, GG_IMG_ALT, lenp, pathp)
  let ilen: i64 = lenp[0]
  gg_p("  image:   " as *u8); gg_p(pathp[0] as *u8); gg_p(" bytes=" as *u8); gg_n(ilen); gg_p("\n" as *u8)
  // golden
  let gpath: *u8 = sys_mmap(512)
  var gi: i64 = gk_cat(gpath, 0, pathp[0] as *u8)
  gi = gk_cat(gpath, gi, ".gold" as *u8)
  gpath[gi] = 0 as u8
  let glenp: *i64 = sys_mmap(16) as *i64
  let gold: *u8 = sys_read_file(gpath, glenp)
  let glen: i64 = glenp[0]
  gv_need("deployed nx_gdbstub.elf (the subject)" as *u8, have_elf, ctr)
  var have_img: i64 = 0
  if ilen > 0 { have_img = 1 }
  gv_need("K-R0 boot image _boot_nishi_virt.bin" as *u8, have_img, ctr)
  var have_gold: i64 = 0
  if glen > 0 { have_gold = 1 }
  gv_need("golden transcript <image>.gold" as *u8, have_gold, ctr)
  if have_elf == 0 { return gv_verdict("GDBSTUB-GATE" as *u8, ctr, "subject absent" as *u8) }
  if have_img == 0 { return gv_verdict("GDBSTUB-GATE" as *u8, ctr, "image absent" as *u8) }
255
  // ---- reference derivation: a SECOND sim, no stub, decoder-resolved breakpoint + executed-pc bitmap
  let reftx: *u8 = sys_mmap(BOOTCAP_MEM_SIZE)
  let ref: *NxRv64imSim = bootcap_machine(img, ilen, reftx, BOOTCAP_MEM_SIZE)
  let exec_bits: *u8 = sys_mmap((ref.mem_size / 4 / 8) + 1)     // one bit per 4-aligned RAM address
  var bp_addr: i64 = 0
  var bp_rs2: i64 = 0
  var exp_reg: i64 = 0
  var exp_next: i64 = 0
  var bp_found: i64 = 0
  var bp_word_is32: i64 = 0
  var steps: i64 = 0
  while steps < BOOTCAP_MAX_STEPS {
      if ref.halted == 1 { steps = BOOTCAP_MAX_STEPS; continue }
      let pc: i64 = ref.pc
      if pc >= ref.mem_base { if pc < ref.mem_base + ref.mem_size {
          let idx: i64 = (pc - ref.mem_base) / GG_RV_INSTR_BYTES
          exec_bits[idx / 8] = ((exec_bits[idx / 8] as i64) | (1 << (idx % 8))) as u8
          if bp_found == 0 {
              let w: i64 = nx_rv64im_sim_load32(ref, pc)
              if nx_rv64im_decode_kind(w) == NX_RV64IM_OP_STORE {
                  bp_found = 1
                  bp_addr = pc
                  bp_rs2 = nx_rv64im_rs2(w)
                  exp_reg = nx_rv64im_rf_read(ref.rf, bp_rs2)
                  if (w & 3) == 3 { bp_word_is32 = 1 }
                  exp_next = pc + GG_RV_INSTR_BYTES
              }
          }
      } }
      nx_rv64im_sim_step(ref)
      steps = steps + 1
  }
  // never-executed RAM address: lowest 4-aligned address at/after the image end with a clear bit
  var never_addr: i64 = 0 - 1
  var cand: i64 = ref.mem_base + ((ilen + GG_RV_INSTR_BYTES - 1) / GG_RV_INSTR_BYTES) * GG_RV_INSTR_BYTES
  while cand < ref.mem_base + ref.mem_size {
      if never_addr < 0 {
          let idx2: i64 = (cand - ref.mem_base) / GG_RV_INSTR_BYTES
          if (((exec_bits[idx2 / 8] as i64) >> (idx2 % 8)) & 1) == 0 { never_addr = cand }
      }
      cand = cand + GG_RV_INSTR_BYTES
  }
  gg_p("  reference: halted=" as *u8); gg_n(ref.halted); gg_p(" code=" as *u8); gg_n(ref.halt_code); gg_p(" steps=" as *u8); gg_n(ref.steps)
  gg_p(" first-store pc=0x" as *u8); gg_hex(bp_addr); gg_p(" rs2=x" as *u8); gg_n(bp_rs2); gg_p(" value=0x" as *u8); gg_hex(exp_reg)
  gg_p(" next=0x" as *u8); gg_hex(exp_next); gg_p(" never-executed=0x" as *u8); gg_hex(never_addr); gg_p("\n" as *u8)
  var t0: i64 = 0
  if bp_found == 1 { if bp_word_is32 == 1 { if ref.halted == 1 { if ref.halt_code == 0 { if never_addr > 0 { if bp_addr > ref.mem_base { t0 = 1 } } } } } }
  gv_check("T0 fixture-reached-the-condition: reference boot halts clean, a 32-bit store past reset was decoded, a never-executed RAM address exists" as *u8, t0, ctr)
  // image words (from the FILE)
  let w0: i64 = (img[0] as i64) | ((img[1] as i64) << 8) | ((img[2] as i64) << 16) | ((img[3] as i64) << 24)
  let w1: i64 = (img[4] as i64) | ((img[5] as i64) << 8) | ((img[6] as i64) << 16) | ((img[7] as i64) << 24)
307
  let out: *u8 = sys_mmap(GG_OUT_CAP)
  let outlen: *i64 = sys_mmap(16) as *i64
  let slog: *u8 = sys_mmap(GG_OUT_CAP)
  let found: *i64 = sys_mmap(16) as *i64
312
  // =========================== SESSION A: the stock-gdb oracle ===========================
  if gv_need("stock gdb on PATH (/usr/bin/gdb-multiarch | /usr/bin/gdb | /usr/local/bin/gdb-multiarch)" as *u8, have_gdb, ctr) == 1 {
      let readyA: *u8 = "/tmp/nx_gdbstub_gate/readyA" as *u8
      let logA: *u8 = "/tmp/nx_gdbstub_gate/stubA.log" as *u8
      gk_rm(readyA)
      let pidA: i64 = gg_spawn(elf, pathp[0] as *u8, "0" as *u8, readyA, logA)
      let portA: i64 = gg_wait_port(readyA)
      gg_p("  session A: stub pid=" as *u8); gg_n(pidA); gg_p(" port=" as *u8); gg_n(portA); gg_p("\n" as *u8)
      var a_ok: i64 = 0
      if portA > 0 { a_ok = 1 }
      gv_check("T1 stub listens on a kernel-chosen loopback port announced through its ready file" as *u8, a_ok, ctr)
      if a_ok == 1 {
          // gdb batch script, port + addresses substituted
          let scr: *u8 = sys_mmap(4096)
          var o: i64 = gk_cat(scr, 0, "set pagination off\nset confirm off\nset architecture riscv:rv64\ntarget remote 127.0.0.1:" as *u8)
          o = gk_catn(scr, o, portA)
          o = gk_cat(scr, o, "\ninfo registers pc\nbreak *0x" as *u8)
          let hb: *u8 = sys_mmap(32)
          var hi: i64 = 0
          while hi < 16 { let nib: i64 = (bp_addr >> ((15 - hi) * 4)) & 15; if nib < 10 { hb[hi] = (48 + nib) as u8 } else { hb[hi] = (87 + nib) as u8 } hi = hi + 1 }
          var hj: i64 = 0
          while hj < 16 { scr[o] = hb[hj]; o = o + 1; hj = hj + 1 }
          o = gk_cat(scr, o, "\ncontinue\ninfo registers pc\np/x $x" as *u8)
          o = gk_catn(scr, o, bp_rs2)
          o = gk_cat(scr, o, "\nstepi\ninfo registers pc\nx/2xw 0x" as *u8)
          var hk: i64 = 0
          while hk < 16 { let nib2: i64 = (ref.mem_base >> ((15 - hk) * 4)) & 15; if nib2 < 10 { scr[o] = (48 + nib2) as u8 } else { scr[o] = (87 + nib2) as u8 } o = o + 1; hk = hk + 1 }
          o = gk_cat(scr, o, "\ndetach\nquit\n" as *u8)
          scr[o] = 0 as u8
          gk_write("/tmp/nx_gdbstub_gate/a.gdb" as *u8, scr)
          outlen[0] = 0
          let grc: i64 = gk_run_capture_ms(gdb, "-q" as *u8, "-batch" as *u8, "-x" as *u8, "/tmp/nx_gdbstub_gate/a.gdb" as *u8, GG_GDB_MS, out, GG_OUT_CAP, outlen)
          let on: i64 = outlen[0]
          gg_p("  gdb rc=" as *u8); gg_n(grc); gg_p(" output_bytes=" as *u8); gg_n(on); gg_p("\n" as *u8)
          let src: i64 = gg_reap(pidA, GG_GDB_MS)
          let sl: i64 = gk_read(logA, slog, GG_OUT_CAP - 1)
          gg_p("  stub rc=" as *u8); gg_n(src); gg_p(" log_bytes=" as *u8); gg_n(sl); gg_p("\n" as *u8)
          // T2 attach: first pc read == reset pc (mem_base)
          let pc1: i64 = gg_value_after(out, on, "pc " as *u8, 1, found)
          var t2: i64 = 0
          if found[0] == 1 { if pc1 == ref.mem_base { t2 = 1 } }
          gg_p("    attach pc=0x" as *u8); gg_hex(pc1); gg_p(" expected=0x" as *u8); gg_hex(ref.mem_base); gg_p("\n" as *u8)
          gv_check("T2 stock gdb attached and read pc == reset vector" as *u8, t2, ctr)
          // T3 breakpoint hit at the decoder-resolved address
          let bph: i64 = gg_value_after(out, on, "Breakpoint 1, " as *u8, 1, found)
          var t3: i64 = 0
          if found[0] == 1 { if bph == bp_addr { t3 = 1 } }
          gg_p("    breakpoint-hit pc=0x" as *u8); gg_hex(bph); gg_p(" expected=0x" as *u8); gg_hex(bp_addr); gg_p("\n" as *u8)
          gv_check("T3 continue stops at the breakpoint the decoder resolved (first executed store)" as *u8, t3, ctr)
          // T4 register value == independent sim's value
          let rv: i64 = gg_value_after(out, on, "$1 = " as *u8, 1, found)
          var t4: i64 = 0
          if found[0] == 1 { if rv == exp_reg { t4 = 1 } }
          gg_p("    gdb $x" as *u8); gg_n(bp_rs2); gg_p("=0x" as *u8); gg_hex(rv); gg_p(" reference=0x" as *u8); gg_hex(exp_reg); gg_p("\n" as *u8)
          gv_check("T4 register read through gdb == value the stub-free reference sim derived" as *u8, t4, ctr)
          // T5 stepi -> pc advanced by one 32-bit instruction (third pc line)
          let pc3: i64 = gg_value_after(out, on, "pc " as *u8, 3, found)
          var t5: i64 = 0
          if found[0] == 1 { if pc3 == exp_next { t5 = 1 } }
          gg_p("    after-stepi pc=0x" as *u8); gg_hex(pc3); gg_p(" expected=0x" as *u8); gg_hex(exp_next); gg_p("\n" as *u8)
          gv_check("T5 stepi advances pc to the next instruction" as *u8, t5, ctr)
          // T6 memory words == image file words
          let mx: i64 = gg_find(out, on, 0, ":\t0x" as *u8)
          var t6: i64 = 0
          var mw0: i64 = 0
          var mw1: i64 = 0
          if mx >= 0 {
              let nd: *i64 = sys_mmap(8) as *i64
              mw0 = gg_parse_hex(out, on, mx + 4, nd)
              let p2: i64 = gg_find(out, on, mx + 4, "0x" as *u8)
              if p2 >= 0 { mw1 = gg_parse_hex(out, on, p2 + 2, nd) }
              if mw0 == w0 { if mw1 == w1 { t6 = 1 } }
          }
          gg_p("    memory words via gdb=0x" as *u8); gg_hex(mw0); gg_p(",0x" as *u8); gg_hex(mw1); gg_p(" image file=0x" as *u8); gg_hex(w0); gg_p(",0x" as *u8); gg_hex(w1); gg_p("\n" as *u8)
          gv_check("T6 memory read through gdb == the image file's own bytes" as *u8, t6, ctr)
          // T7 detach left the guest running: stub log says after-detach halted clean AND transcript == golden
          var t7: i64 = 0
          if gg_find(slog, sl, 0, "session-end detached=1 killed=0" as *u8) >= 0 {
              if gg_find(slog, sl, 0, "after-detach halted=1 code=0" as *u8) >= 0 {
                  let tb: i64 = gg_find(slog, sl, 0, "transcript=[" as *u8)
                  if tb >= 0 { if have_gold == 1 {
                      let ts: i64 = tb + 12
                      var same: i64 = 1
                      var q: i64 = 0
                      while q < glen { if ts + q >= sl { same = 0 } else { if slog[ts + q] != gold[q] { same = 0 } } q = q + 1 }
                      if ts + glen < sl { if (slog[ts + glen] as i64) != 93 { same = 0 } }   // ']' right after the golden
                      t7 = same
                  } }
              }
          }
          gv_check("T7 detach leaves the guest RUNNING: it completes the boot and its transcript == golden" as *u8, t7, ctr)
      }
      // =========================== SESSION B: neg-control, never-executed breakpoint ===========================
      let readyB: *u8 = "/tmp/nx_gdbstub_gate/readyB" as *u8
      let logB: *u8 = "/tmp/nx_gdbstub_gate/stubB.log" as *u8
      gk_rm(readyB)
      let pidB: i64 = gg_spawn(elf, pathp[0] as *u8, "0" as *u8, readyB, logB)
      let portB: i64 = gg_wait_port(readyB)
      gg_p("  session B: stub pid=" as *u8); gg_n(pidB); gg_p(" port=" as *u8); gg_n(portB); gg_p("\n" as *u8)
      var t8: i64 = 0
      if portB > 0 {
          let scrb: *u8 = sys_mmap(4096)
          var ob: i64 = gk_cat(scrb, 0, "set pagination off\nset confirm off\nset architecture riscv:rv64\ntarget remote 127.0.0.1:" as *u8)
          ob = gk_catn(scrb, ob, portB)
          ob = gk_cat(scrb, ob, "\nbreak *0x" as *u8)
          var hn: i64 = 0
          while hn < 16 { let nib3: i64 = (never_addr >> ((15 - hn) * 4)) & 15; if nib3 < 10 { scrb[ob] = (48 + nib3) as u8 } else { scrb[ob] = (87 + nib3) as u8 } ob = ob + 1; hn = hn + 1 }
          ob = gk_cat(scrb, ob, "\ncontinue\ninfo registers pc\nquit\n" as *u8)
          scrb[ob] = 0 as u8
          gk_write("/tmp/nx_gdbstub_gate/b.gdb" as *u8, scrb)
          outlen[0] = 0
          let grcb: i64 = gk_run_capture_ms(gdb, "-q" as *u8, "-batch" as *u8, "-x" as *u8, "/tmp/nx_gdbstub_gate/b.gdb" as *u8, GG_GDB_MS, out, GG_OUT_CAP, outlen)
          let onb: i64 = outlen[0]
          let srcb: i64 = gg_reap(pidB, GG_GDB_MS)
          let slb: i64 = gk_read(logB, slog, GG_OUT_CAP - 1)
          gg_p("  gdb rc=" as *u8); gg_n(grcb); gg_p(" output_bytes=" as *u8); gg_n(onb); gg_p(" stub rc=" as *u8); gg_n(srcb); gg_p(" log_bytes=" as *u8); gg_n(slb); gg_p("\n" as *u8)
          var exited: i64 = 0
          if gg_find(out, onb, 0, "exited normally" as *u8) >= 0 { exited = 1 }
          var bphit: i64 = 0
          if gg_find(out, onb, 0, "Breakpoint 1, " as *u8) >= 0 { bphit = 1 }
          var guest_done: i64 = 0
          if gg_find(slog, slb, 0, "halted=1 code=0" as *u8) >= 0 { guest_done = 1 }
          gg_p("    gdb saw exit=" as *u8); gg_n(exited); gg_p(" breakpoint-stop=" as *u8); gg_n(bphit); gg_p(" guest halted clean=" as *u8); gg_n(guest_done); gg_p("\n" as *u8)
          if exited == 1 { if bphit == 0 { if guest_done == 1 { t8 = 1 } } }
      }
      gv_check("T8 neg-control-never-executed-breakpoint-does-NOT-stop: guest runs to exit under gdb, no breakpoint stop" as *u8, t8, ctr)
  }
440
  // =========================== SESSION C: protocol neg-controls, sovereign client, no gdb needed ===========================
  let readyC: *u8 = "/tmp/nx_gdbstub_gate/readyC" as *u8
  let logC: *u8 = "/tmp/nx_gdbstub_gate/stubC.log" as *u8
  gk_rm(readyC)
  let pidC: i64 = gg_spawn(elf, pathp[0] as *u8, "0" as *u8, readyC, logC)
  let portC: i64 = gg_wait_port(readyC)
  gg_p("  session C: stub pid=" as *u8); gg_n(pidC); gg_p(" port=" as *u8); gg_n(portC); gg_p("\n" as *u8)
  var t9: i64 = 0
  var t10: i64 = 0
  var t11: i64 = 0
  var t12: i64 = 0
  if portC > 0 {
      let fd: i64 = gg_rsp_connect(portC)
      if fd >= 0 {
          let rb: *u8 = sys_mmap(256)
          // bad checksum: "$g#00" -> expect '-'
          sys_write(fd, "$g#00" as *u8, 5)
          var n1: i64 = gg_rsp_read(fd, rb, 255, 1)
          gg_p("    after bad-checksum frame, peer sent bytes=" as *u8); gg_n(n1); gg_p(" first=" as *u8); if n1 > 0 { gg_n(rb[0] as i64) } gg_p("\n" as *u8)
          if n1 >= 1 { if (rb[0] as i64) == 45 { t9 = 1 } }
          // good frame "$?#3f" -> expect "+$S05#b8" (8 bytes)
          sys_write(fd, "$?#3f" as *u8, 5)
          var n2: i64 = gg_rsp_read(fd, rb, 255, 8)
          var got2: i64 = 0
          if n2 >= 8 { if gg_find(rb, n2, 0, "+$S05#b8" as *u8) >= 0 { got2 = 1 } }
          gg_p("    after good '?' frame, bytes=" as *u8); gg_n(n2); gg_p(" ack+S05=" as *u8); gg_n(got2); gg_p("\n" as *u8)
          t10 = got2
          // ACK the reply: in ack mode the stub (like gdbserver) holds the line until it sees '+' for its
          // own frame, so a client that skips the ack is the one breaking the protocol, not the stub
          sys_write(fd, "+" as *u8, 1)
          // detach "$D#44" -> expect "+$OK#9a"
          sys_write(fd, "$D#44" as *u8, 5)
          var n3: i64 = gg_rsp_read(fd, rb, 255, 7)
          if n3 >= 7 { if gg_find(rb, n3, 0, "+$OK#9a" as *u8) >= 0 { t11 = 1 } }
          gg_p("    after D frame, bytes=" as *u8); gg_n(n3); gg_p(" ack+OK=" as *u8); gg_n(t11); gg_p("\n" as *u8)
          sys_write(fd, "+" as *u8, 1)
          sys_close(fd)
      }
      let srcc: i64 = gg_reap(pidC, GG_GDB_MS)
      let slc: i64 = gk_read(logC, slog, GG_OUT_CAP - 1)
      if gg_find(slog, slc, 0, "bad_checksum_frames=1" as *u8) >= 0 { if gg_find(slog, slc, 0, "after-detach halted=1 code=0" as *u8) >= 0 { t12 = 1 } }
      gg_p("    stub rc=" as *u8); gg_n(srcc); gg_p(" counted-bad-frame+guest-finished=" as *u8); gg_n(t12); gg_p("\n" as *u8)
  }
  gv_check("T9 neg-control-bad-checksum-frame-is-NAKed ('-')" as *u8, t9, ctr)
  gv_check("T10 good '?' frame is ACKed and answered S05 (trap stop reason)" as *u8, t10, ctr)
  gv_check("T11 D (detach) is answered OK" as *u8, t11, ctr)
  gv_check("T12 the stub COUNTED the bad frame (bad_checksum_frames=1) and the guest finished after detach" as *u8, t12, ctr)
488
  return gv_verdict("GDBSTUB-GATE" as *u8, ctr, "oracle=stock gdb when present (named above); reference=stub-free sim+decoder+image file; fixtures /tmp/nx_gdbstub_gate" as *u8)
490}
nx_gdbstub_gate.nx source

`nx_gdbstub_gate.nx` source
