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

↩ module page · 281 lines · 10156 B
1// nx_constscan_beat.nx -- STANDING guard for LM-030, the const-pointer direct-index SILENT MISCOMPILE.
2//
3// WHY A BEAT: on 2026-07-30 I reproduced LM-030 with a controlled probe/control pair -- CONST[i] compiles
4// clean, runs, and returns WRONG DATA with no diagnostic anywhere -- then scanned all 17,501 .nx in the tree
5// and found hits=0. Clean TODAY is not a property; it is a snapshot. A defect whose only symptom is a wrong
6// number needs a continuous guard, because the first reintroduction is invisible by construction.
7//
8// WHY THE DETECTOR WAS DARK, which is the real lesson: nx_doc_constscan already existed and had even measured
9// the same garbage value, but it was SOURCE-ONLY -- never built, never in tool_allowlist.conf, never on the
10// sweep rail. A detector nobody can run is not a guard. This beat is the missing rail.
11//
12// Discovers + batches + aggregates ONLY. It forks the proven ./nx_doc_constscan_run.elf exactly as
13// nx_store_fold_beat forks nx_store_compact, so the DETECTOR keeps sole ownership of what counts as a hit.
14// Batching exists because the runner takes files as argv and the tree is ~17.5k files -- one exec cannot hold
15// them, so this is xargs-in-an-organ, not a re-implementation.
16//
17// Sweep-row contract: exit 0 = zero LM-030 sites; exit 1 = at least one, surfaced RED with the count.
18// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
19import "nx_syscalls.nx"
20import "nx_tool_run.nx"
21
22const CB_DIRBUF: i64 = 262144
23const CB_ARENA: i64 = 1048576
24const CB_OUTCAP: i64 = 262144
25const CB_PATHCAP: i64 = 1024
26const CB_BATCH: i64 = 96
27const CB_AVSLOTS: i64 = 100
28const CB_STDOUT: i64 = 1
29const CB_NL: i64 = 10
30
31func cb_len(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) {
      n = n + 1
  }
  return n
37}
38func cb_puts(s: *u8) -> i64 {
  sys_write(CB_STDOUT, s, cb_len(s))
  return 0
41}
42func cb_putn(v: i64) -> i64 {
  let t: *u8 = sys_mmap(32)
  let b: *u8 = sys_mmap(32)
  var m: i64 = v
  if m < 0 {
      m = 0 - m
  }
  var k: i64 = 0
  if m == 0 {
      t[0] = 48 as u8
      k = 1
  }
  while m > 0 {
      t[k] = (48 + (m % 10)) as u8
      m = m / 10
      k = k + 1
  }
  var i: i64 = 0
  while i < k {
      b[i] = t[k - 1 - i]
      i = i + 1
  }
  sys_write(CB_STDOUT, b, k)
  sys_munmap(t, 32)
  sys_munmap(b, 32)
  return 0
68}
69// name ends in .nx and is not a shadow copy (.migrated/.premigrate/.bak/.retired/MOVED/SHADOW)
70// FIXTURE EXCLUSION (2026-07-30). Two files in the tree contain LM-030 ON PURPOSE and must not turn a
71// standing guard RED forever: nx_constidx_probe.nx is the positive control that PROVES the detector can fire
72// (its safe twin nx_constidx_ctrl.nx must stay clean), and nx_doc_constscan_gate.nx carries KAT fixture
73// STRINGS containing the offending pattern as test input. Excluding a deliberate fixture is what lint
74// exclusions are for; excluding it is NOT the same as suppressing a finding, and the exclusion is BY NAME so
75// a real defect anywhere else still fires. ⚠RESIDUAL, filed not hidden: cs_scan skips // comments but NOT
76// string literals, which is why the gate's fixture strings match at all -- root fix is a string-literal skip.
77// Compare two NUL-terminated strings. Stops at EITHER terminator, which is the whole point: the
78// version this replaced walked the LITERAL's length while indexing the CANDIDATE, so a candidate
79// shorter than the literal was read past its NUL. dirent names live inside the getdents buffer, so
80// a short name near the end of that mapping meant reading off the end of the mapping itself --
81// SIGSEGV, error 4 (read), at a page-aligned address, every ~7 minutes on the beat schedule.
82// Keeping this loud was deliberate: page-per-allocation FAULTS on such an over-read, whereas the
83// small-allocation arena would quietly hand back a neighbour's bytes and return a wrong answer.
84func cb_streq(x: *u8, y: *u8) -> i64 {
  var i: i64 = 0
  while x[i] != (0 as u8) {
      if y[i] != x[i] { return 0 }
      i = i + 1
  }
  if y[i] != (0 as u8) { return 0 }
  return 1
92}
93func cb_is_fixture(nm: *u8) -> i64 {
  if cb_streq("nx_constidx_probe.nx" as *u8, nm) == 1 { return 1 }
  if cb_streq("nx_doc_constscan_gate.nx" as *u8, nm) == 1 { return 1 }
  return 0
97}
98func cb_is_scannable(nm: *u8) -> i64 {
  let n: i64 = cb_len(nm)
  if n < 4 {
      return 0
  }
  if cb_is_fixture(nm) == 1 {
      return 0
  }
  if nm[n - 3] != (46 as u8) {
      return 0
  }
  if nm[n - 2] != (110 as u8) {
      return 0
  }
  if nm[n - 1] != (120 as u8) {
      return 0
  }
  return 1
116}
117// sum every "hits=N" the runner printed in this batch
118func cb_hits(buf: *u8, n: i64) -> i64 {
  let key: *u8 = "hits=" as *u8
  let kl: i64 = 5
  var total: i64 = 0
  var i: i64 = 0
  while i + kl < n {
      var ok: i64 = 1
      var k: i64 = 0
      while k < kl {
          if buf[i + k] != key[k] {
              ok = 0
              k = kl
          } else {
              k = k + 1
          }
      }
      if ok == 1 {
          var v: i64 = 0
          var j: i64 = i + kl
          var go: i64 = 1
          while go == 1 {
              if j >= n {
                  go = 0
              } else {
                  let c: i64 = buf[j]
                  var d: i64 = 0
                  if c >= 48 {
                      if c <= 57 {
                          d = 1
                      }
                  }
                  if d == 1 {
                      v = v * 10 + (c - 48)
                      j = j + 1
                  } else {
                      go = 0
                  }
              }
          }
          total = total + v
          i = j
      } else {
          i = i + 1
      }
  }
  return total
164}
165
166func main(argc: i64, argv: *i64) -> i64 {
  let runner: *u8 = "./nx_doc_constscan_run.elf" as *u8
  let dbuf: *u8 = sys_mmap(CB_DIRBUF)
  let arena: *u8 = sys_mmap(CB_ARENA)
  let av: *i64 = sys_mmap(8 * CB_AVSLOTS) as *i64
  let out: *u8 = sys_mmap(CB_OUTCAP)
  let ol: *i64 = sys_mmap(16) as *i64
  var scanned: i64 = 0
  var hits: i64 = 0
  var batches: i64 = 0
  var failed: i64 = 0
177
  var d: i64 = 0
  while d < 2 {
      var dir: *u8 = "buildroot/runtime" as *u8
      if d == 1 {
          dir = "buildroot/runtime/_hdl_build" as *u8
      }
      let dl: i64 = cb_len(dir)
      let fd: i64 = sys_openat_rd(dir)
      if fd < 0 {
          cb_puts("CONSTSCAN-BEAT RED cannot open " as *u8)
          cb_puts(dir)
          cb_puts("\n" as *u8)
          return 1
      }
      var ao: i64 = 0
      var nb_in: i64 = 0
      av[0] = runner as i64
      var go: i64 = 1
      while go == 1 {
          let nb: i64 = sys_getdents64(fd, dbuf, CB_DIRBUF)
          if nb <= 0 {
              go = 0
          } else {
              var off: i64 = 0
              while off < nb {
                  let rec: *u8 = (dbuf as i64 + off) as *u8
                  let rl: i64 = dirent_reclen(rec)
                  if rl <= 0 {
                      off = nb
                  } else {
                      let nm: *u8 = dirent_name(rec)
                      if cb_is_scannable(nm) == 1 {
                          let want: i64 = ao + dl + cb_len(nm) + 2
                          if want < CB_ARENA {
                              let start: i64 = ao
                              var z: i64 = 0
                              while z < dl {
                                  arena[ao] = dir[z]
                                  ao = ao + 1
                                  z = z + 1
                              }
                              arena[ao] = 47 as u8
                              ao = ao + 1
                              var y: i64 = 0
                              while nm[y] != (0 as u8) {
                                  arena[ao] = nm[y]
                                  ao = ao + 1
                                  y = y + 1
                              }
                              arena[ao] = 0 as u8
                              ao = ao + 1
                              nb_in = nb_in + 1
                              av[nb_in] = (arena as i64) + start
                              scanned = scanned + 1
                              if nb_in >= CB_BATCH {
                                  av[nb_in + 1] = 0
                                  let rc: i64 = tr_run_capture(runner, av, out, CB_OUTCAP - 1, ol)
                                  if rc != 0 {
                                      failed = failed + 1
                                  }
                                  hits = hits + cb_hits(out, ol[0])
                                  batches = batches + 1
                                  nb_in = 0
                                  ao = 0
                              }
                          }
                      }
                      off = off + rl
                  }
              }
          }
      }
      sys_close(fd)
      if nb_in > 0 {
          av[nb_in + 1] = 0
          let rc2: i64 = tr_run_capture(runner, av, out, CB_OUTCAP - 1, ol)
          if rc2 != 0 {
              failed = failed + 1
          }
          hits = hits + cb_hits(out, ol[0])
          batches = batches + 1
      }
      d = d + 1
  }
262
  cb_puts("CONSTSCAN-BEAT scanned=" as *u8)
  cb_putn(scanned)
  cb_puts(" batches=" as *u8)
  cb_putn(batches)
  cb_puts(" batch_failures=" as *u8)
  cb_putn(failed)
  cb_puts(" LM030_hits=" as *u8)
  cb_putn(hits)
  if hits > 0 {
      cb_puts(" verdict=RED-const-pointer-indexed-directly-SILENT-MISCOMPILE-bind-to-a-local-let\n" as *u8)
      return 1
  }
  if failed > 0 {
      cb_puts(" verdict=RED-a-batch-FAILED-coverage-incomplete-do-not-read-hits-as-zero\n" as *u8)
      return 1
  }
  cb_puts(" verdict=GREEN-no-LM-030-sites\n" as *u8)
  return 0
281}
nx_constscan_beat.nx source

`nx_constscan_beat.nx` source
