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

↩ module page · 255 lines · 9467 B
1// nx_fwdconst_scan.nx -- FORWARD-CONST DEAD-READ DETECTOR (eats seq360's discovery half, 2026-07-20).
2// The miscompile class: a module const READ by code textually ABOVE its declaration resolves to
3// CONSTANT 0 in binaries built before the 07-20 nx_cc diagnostic (proven live: AT_FDCWD dirfd=0,
4// VC_EO_PART/VC_EO_T8 codec early-outs dead since 07-12). The new compiler REJECTS the pattern at
5// build time; this organ finds it in SOURCE so already-shipped binaries' sources get fixed+rebuilt
6// deliberately, and the class is sweepable on cadence forever.
7// argv: <dir> [dir2] [dir3]   (flat dirs, .nx files; the build-resolution pair is the usual input)
8// Report rows: FWDCONST <file> use-line=<L> const=<NAME> decl-line=<D>
9// Summary: NX-FWDCONST-SCAN files=<f> consts=<c> flagged=<n> skipped-big=<s>   (exit 0 = scan completed)
10// HONEST SCOPE v1: full-comment lines (// or \) and double-quoted spans are SKIPPED; an INLINE
11// trailing comment mentioning the name still flags (rare; review rows by eye). Reporter only --
12// a ratchet gate asserting flagged<=N composes on top once the map is eaten.
13// license_tier: ORIGINAL   No hw writes (Rule 26).
14import "nx_sovjson_lib.nx"
15import "nx_syscalls.nx"
16const FW_MAGIC_4096: i64 = 4096
17const FW_MAGIC_262144: i64 = 262144
18
19const FW_FILE_CAP: i64 = 2097152
20const FW_NAME_CAP: i64 = 64
21const FW_MAX_CONSTS: i64 = 512
22
23static g_names: *u8
24static g_doffs: *i64
25
26func fw_w(s: *u8) -> i64 { return sj_puts(s) }
27
28func fw_wn(v: i64) -> i64 {
  var t: i64 = v
  if t < 0 { sys_write(1, "-" as *u8, 1); t = 0 - t }
  let tm: *u8 = sys_mmap(24)
  var k: i64 = 0
  if t == 0 { tm[0] = 48 as u8; k = 1 }
  while t > 0 { tm[k] = (48 + (t % 10)) as u8; t = t / 10; k = k + 1 }
  let b: *u8 = sys_mmap(24)
  var j: i64 = 0
  while j < k { b[j] = tm[k - 1 - j]; j = j + 1 }
  sys_write(1, b, k)
  return 0
40}
41
42func fw_isid(c: i64) -> i64 {
  if c >= 97 { if c <= 122 { return 1 } }
  if c >= 65 { if c <= 90 { return 1 } }
  if c >= 48 { if c <= 57 { return 1 } }
  if c == 95 { return 1 }
  return 0
48}
49
50func fw_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var n: i64 = 0
  var r: i64 = sys_read(fd, buf, cap - 1)
  while r > 0 { n = n + r; if n >= cap - 1 { r = 0 } else { r = sys_read(fd, buf + n, cap - 1 - n) } }
  sys_close(fd)
  return n
58}
59
60func fw_line_of(buf: *u8, off: i64) -> i64 {
  var ln: i64 = 1
  var i: i64 = 0
  while i < off { if buf[i] == (10 as u8) { ln = ln + 1 } i = i + 1 }
  return ln
65}
66
67func ends_nx2(nm: *u8) -> i64 {
  var n: i64 = 0
  while nm[n] != (0 as u8) { n = n + 1 }
  if n < 3 { return 0 }
  if nm[n-3] == (46 as u8) { if nm[n-2] == (110 as u8) { if nm[n-1] == (120 as u8) { return 1 } } }
  return 0
73}
74
75func join2(buf: *u8, dir: *u8, name: *u8) -> i64 {
  var o: i64 = 0
  var i: i64 = 0
  while dir[i] != (0 as u8) { buf[o] = dir[i]; o = o + 1; i = i + 1 }
  buf[o] = 47 as u8
  o = o + 1
  i = 0
  while name[i] != (0 as u8) { buf[o] = name[i]; o = o + 1; i = i + 1 }
  buf[o] = 0 as u8
  return 0
85}
86
87// pass A: collect module const decls "const NAME" at line starts into g_names/g_doffs; returns count
88func fw_collect(buf: *u8, n: i64) -> i64 {
  var cnt: i64 = 0
  var ls: i64 = 0
  while ls < n {
      var p: i64 = ls
      // "const " at line start (col 0 -- module consts in this codebase)
      var m: i64 = 1
      if p + 6 >= n { m = 0 }
      if m == 1 { if buf[p] != (99 as u8) { m = 0 } }
      if m == 1 { if buf[p+1] != (111 as u8) { m = 0 } }
      if m == 1 { if buf[p+2] != (110 as u8) { m = 0 } }
      if m == 1 { if buf[p+3] != (115 as u8) { m = 0 } }
      if m == 1 { if buf[p+4] != (116 as u8) { m = 0 } }
      if m == 1 { if buf[p+5] != (32 as u8) { m = 0 } }
      if m == 1 {
          var q: i64 = p + 6
          while buf[q] == (32 as u8) { q = q + 1 }
          var e: i64 = q
          var run: i64 = 1
          while run == 1 {
              if e >= n { run = 0 } else { let c: i64 = buf[e] as i64; if fw_isid(c) == 1 { e = e + 1 } else { run = 0 } }
          }
          let nl: i64 = e - q
          if nl > 0 { if nl < FW_NAME_CAP - 1 { if cnt < FW_MAX_CONSTS {
              let slot: *u8 = ((g_names as i64) + cnt * FW_NAME_CAP) as *u8
              var w: i64 = 0
              while w < nl { slot[w] = buf[q + w]; w = w + 1 }
              slot[nl] = 0 as u8
              let dof: *i64 = g_doffs
              dof[cnt] = ls
              cnt = cnt + 1
          } } }
      }
      var adv: i64 = 1
      while adv == 1 {
          if ls >= n { adv = 0 } else { let c2: i64 = buf[ls] as i64; ls = ls + 1; if c2 == 10 { adv = 0 } }
      }
  }
  return cnt
127}
128
129// pass B: first word-boundary use of name in buf[0..limit), skipping comment lines + quoted spans.
130// returns byte offset of the hit or -1.
131func fw_first_use(buf: *u8, limit: i64, name: *u8) -> i64 {
  var nl: i64 = 0
  while name[nl] != (0 as u8) { nl = nl + 1 }
  var p: i64 = 0
  var linestart: i64 = 1
  var incmt: i64 = 0
  var inq: i64 = 0
  while p < limit {
      let c: i64 = buf[p] as i64
      if c == 10 { linestart = 1; incmt = 0; inq = 0; p = p + 1 } else {
          if linestart == 1 {
              var sp: i64 = p
              while buf[sp] == (32 as u8) { sp = sp + 1 }
              if buf[sp] == (92 as u8) { incmt = 1 }
              if buf[sp] == (47 as u8) { if buf[sp+1] == (47 as u8) { incmt = 1 } }
              linestart = 0
          }
          if incmt == 1 { p = p + 1 } else {
              if c == 34 { inq = 1 - inq; p = p + 1 } else {
                  if inq == 1 { p = p + 1 } else {
                      var hit: i64 = 1
                      if p + nl > limit { hit = 0 }
                      var k: i64 = 0
                      var chk: i64 = 1
                      while chk == 1 {
                          if hit == 0 { chk = 0 } else {
                              if k >= nl { chk = 0 } else {
                                  if buf[p + k] != name[k] { hit = 0; chk = 0 } else { k = k + 1 }
                              }
                          }
                      }
                      if hit == 1 {
                          var pb: i64 = 0
                          if p > 0 { pb = fw_isid(buf[p-1] as i64) }
                          var nb: i64 = 0
                          if p + nl < limit { nb = fw_isid(buf[p+nl] as i64) }
                          if pb == 0 { if nb == 0 { return p } }
                      }
                      p = p + 1
                  }
              }
          }
      }
  }
  return 0 - 1
176}
177
178// scan one file; prints FWDCONST rows; returns flags found
179func fw_process(path: *u8, buf: *u8) -> i64 {
  let n: i64 = fw_read(path, buf, FW_FILE_CAP)
  if n <= 0 { return 0 }
  let nc: i64 = fw_collect(buf, n)
  var flags: i64 = 0
  var i: i64 = 0
  while i < nc {
      let nm: *u8 = ((g_names as i64) + i * FW_NAME_CAP) as *u8
      let dof: *i64 = g_doffs
      let dl: i64 = dof[i]
      let hit: i64 = fw_first_use(buf, dl, nm)
      if hit >= 0 {
          fw_w("FWDCONST " as *u8)
          fw_w(path)
          fw_w(" use-line=" as *u8)
          let ul: i64 = fw_line_of(buf, hit)
          fw_wn(ul)
          fw_w(" const=" as *u8)
          fw_w(nm)
          fw_w(" decl-line=" as *u8)
          let dln: i64 = fw_line_of(buf, dl)
          fw_wn(dln)
          fw_w("\n" as *u8)
          flags = flags + 1
      }
      i = i + 1
  }
  return flags
207}
208
209func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { fw_w("usage: nx_fwdconst_scan <dir> [dir2] [dir3]\n" as *u8); sys_exit(2); return 2 }
  if (g_names as i64) == 0 { g_names = sys_mmap(FW_MAX_CONSTS * FW_NAME_CAP) }
  if (g_doffs as i64) == 0 { g_doffs = sys_mmap(FW_MAX_CONSTS * 8) as *i64 }
  let buf: *u8 = sys_mmap(FW_FILE_CAP)
  let pbuf: *u8 = sys_mmap(FW_MAGIC_4096)
  let dbuf: *u8 = sys_mmap(FW_MAGIC_262144)
  var files: i64 = 0
  var flagged: i64 = 0
  var d: i64 = 1
  while d < argc {
      let dir: *u8 = argv[d] as *u8
      let fd: i64 = sys_openat_rd(dir)
      if fd >= 0 {
          var go: i64 = 1
          while go == 1 {
              let nr: i64 = sys_getdents64(fd, dbuf, FW_MAGIC_262144)
              if nr <= 0 { go = 0 } else {
                  var off: i64 = 0
                  while off < nr {
                      let rec: *u8 = ((dbuf as i64) + off) as *u8
                      let ty: i64 = dirent_type(rec)
                      let nm: *u8 = dirent_name(rec)
                      if ty != 4 {
                          if ends_nx2(nm) == 1 {
                              join2(pbuf, dir, nm)
                              files = files + 1
                              let fl: i64 = fw_process(pbuf, buf)
                              flagged = flagged + fl
                          }
                      }
                      off = off + dirent_reclen(rec)
                  }
              }
          }
          sys_close(fd)
      }
      d = d + 1
  }
  fw_w("NX-FWDCONST-SCAN files=" as *u8)
  fw_wn(files)
  fw_w(" flagged=" as *u8)
  fw_wn(flagged)
  fw_w("\n" as *u8)
  sys_exit(0)
  return 0
255}
nx_fwdconst_scan.nx source

`nx_fwdconst_scan.nx` source
