code wiki / (root) / nx_dwline_stmt_gate.nx
`nx_dwline_stmt_gate.nx` source

↩ module page · 232 lines · 10955 B
1// nx_dwline_stmt_gate.nx -- DOES STATEMENT GRANULARITY ACTUALLY BEAT FUNCTION GRANULARITY?
2//
3// DDR-006 rung 2. Rung 1 emitted ONE .loc per function. This gate does not merely assert that the
4// new compiler emits line info -- rung 1 did that too, and a gate that both versions pass measures
5// nothing. It runs the SAME probe through BOTH compilers and measures the DIFFERENCE:
6//
7//   OLD  _offc/nx_cc_sovereign.elf   (blessed 3bd47652, function granularity)  -> lines {5, 9}
8//   NEW  ../nx_compile_x86.elf       (statement granularity)                   -> must ALSO carry 6 and 10
9//
10// runtime/nx_probe_dbgtiny.nx:
11//   L5  func dbgtiny_a() -> i64 {      L6  return 1          L7 }
12//   L9  func main() -> i64 {           L10 return dbgtiny_a()  L11 }
13// so lines 6 and 10 are STATEMENT lines that function granularity CANNOT produce, and lines 5 and 9
14// are the function lines it already produced. THE OLD COMPILER IS THE NEGATIVE CONTROL, and it is
15// what makes this a measurement of the improvement rather than a restatement of the feature.
16//
17// Deliberately reads the ".s" rather than the ELF: the claim under test is what the COMPILER emits.
18// nx_dwline_e2e_gate already proves the assembler and decoder carry it through to a real ELF, so
19// duplicating that here would test the wrong subject.
20//
21// license_tier: ORIGINAL  expect_exit: 0
22import "syscalls.nx"
23import "nx_elf_read.nx"
24import "nx_addr2line_lib.nx"
25import "nx_gate_verdict.nx"
26
27const SG_CAP: i64 = 4194304
28const SG_OLD: *u8 = "_offc/nx_cc_sovereign.elf" as *u8
29const SG_NEW: *u8 = "../nx_compile_x86.elf" as *u8
30const SG_SRC: *u8 = "runtime/nx_probe_dbgtiny.nx" as *u8
31const SG_S_OLD: *u8 = "/tmp/nx_dwstmt_old.s" as *u8
32const SG_S_NEW: *u8 = "/tmp/nx_dwstmt_new.s" as *u8
33
34func sg_run_out(elf: *u8, args: *i64, nargs: i64, outfile: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let fd: i64 = sys_openat_wr(outfile, 0x1a4)
      if fd >= 0 { sys_dup3(fd, 1, 0) }
      let argv: *i64 = sys_mmap(8 * (nargs + 2)) as *i64
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      argv[0] = elf as i64
      var i: i64 = 0
      while i < nargs { argv[i+1] = args[i]; i = i + 1 }
      argv[nargs+1] = 0
      sys_execve(elf, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  if (st[0] % 128) != 0 { return 0 - 1 }
  return (st[0] >> 8) & 0xff
53}
54
55func sg_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var tot: i64 = 0
  while tot < cap {
      let n: i64 = sys_read(fd, (buf as i64 + tot) as *u8, cap - tot)
      if n <= 0 { break }
      tot = tot + n
  }
  sys_close(fd)
  return tot
66}
67
68// count occurrences of the exact directive "    .loc 1 <line>\n"
69func sg_count_loc(buf: *u8, n: i64, line: i64) -> i64 {
  let pat: *u8 = sys_mmap(64)
  var p: i64 = 0
  pat[p] = 46 as u8; p = p + 1      // .
  pat[p] = 108 as u8; p = p + 1     // l
  pat[p] = 111 as u8; p = p + 1     // o
  pat[p] = 99 as u8; p = p + 1      // c
  pat[p] = 32 as u8; p = p + 1      // space
  pat[p] = 49 as u8; p = p + 1      // 1  (file index)
  pat[p] = 32 as u8; p = p + 1      // space
  // decimal line
  var m: i64 = line
  let t: *u8 = sys_mmap(32)
  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 j: i64 = 0
  while j < k { pat[p] = t[k-1-j]; p = p + 1; j = j + 1 }
  pat[p] = 10 as u8; p = p + 1      // newline -- anchors the match so ".loc 1 1" cannot match ".loc 1 10"
  let plen: i64 = p
89
  var hits: i64 = 0
  var i: i64 = 0
  while i + plen <= n {
      var q: i64 = 0
      var ok: i64 = 1
      while q < plen { if buf[i+q] != pat[q] { ok = 0; q = plen } else { q = q + 1 } }
      if ok == 1 { hits = hits + 1 }
      i = i + 1
  }
  return hits
100}
101
102func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("=== NX-DWLINE-STMT GATE -- statement granularity vs the blessed function-granularity build ===" as *u8)
105
  sys_chdir("buildroot" as *u8)
107
  let args: *i64 = sys_mmap(64) as *i64
  args[0] = "-g" as i64
  args[1] = SG_SRC as i64
111
  let rc_old: i64 = sg_run_out(SG_OLD, args, 2, SG_S_OLD)
  let rc_new: i64 = sg_run_out(SG_NEW, args, 2, SG_S_NEW)
  gv_check("old-compiler-runs" as *u8, (rc_old == 0) as i64, ctr)
  gv_check("new-compiler-runs" as *u8, (rc_new == 0) as i64, ctr)
116
  let ob: *u8 = sys_mmap(SG_CAP)
  let nb: *u8 = sys_mmap(SG_CAP)
  let on: i64 = sg_read(SG_S_OLD, ob, SG_CAP)
  let nn: i64 = sg_read(SG_S_NEW, nb, SG_CAP)
  gv_check("both-emitted-assembly" as *u8, ((on > 256) & (nn > 256)) as i64, ctr)
122
  let o5: i64 = sg_count_loc(ob, on, 5)
  let o6: i64 = sg_count_loc(ob, on, 6)
  let o9: i64 = sg_count_loc(ob, on, 9)
  let o10: i64 = sg_count_loc(ob, on, 10)
  let n5: i64 = sg_count_loc(nb, nn, 5)
  let n6: i64 = sg_count_loc(nb, nn, 6)
  let n9: i64 = sg_count_loc(nb, nn, 9)
  let n10: i64 = sg_count_loc(nb, nn, 10)
131
  // BASELINE: the blessed compiler carries the FUNCTION lines. It used to be asserted here that it LACKED the
  // statement lines -- the differential this gate was born to measure. MEASURED 2026-09-02: OLD(blessed) reads
  // L6=2 L10=2, total=6, equal to NEW: statement granularity was PROMOTED into the toolchain and the differential
  // collapsed, so the old neg-control read RED on every beat for a feature that had landed. The oracle is now the
  // feature PINNED: the blessed compiler must keep carrying the statement rows (a toolchain that regressed them
  // would fail here), and NEW must equal the blessed count rather than exceed it.
  gv_check("baseline-has-function-lines-5-and-9" as *u8, ((o5 > 0) & (o9 > 0)) as i64, ctr)
  gv_check("blessed-compiler-CARRIES-statement-lines-6-and-10-the-feature-is-promoted" as *u8, ((o6 > 0) & (o10 > 0)) as i64, ctr)
140
  // THE IMPROVEMENT, measured: the new compiler keeps everything the old one had...
  gv_check("new-keeps-function-lines-5-and-9" as *u8, ((n5 > 0) & (n9 > 0)) as i64, ctr)
  // ...and ADDS the statement lines function granularity structurally cannot express.
  gv_check("new-ADDS-statement-line-6" as *u8, (n6 > 0) as i64, ctr)
  gv_check("new-ADDS-statement-line-10" as *u8, (n10 > 0) as i64, ctr)
146
  // NO SWAP: a compiler that emitted 6 and 10 while LOSING 5 and 9 would pass the checks above and be a regression
  // wearing a feature's clothes. With the feature blessed, NEW and OLD must agree on the row count (a strict-greater
  // test would now demand the statement build ADD rows the blessed build already has -- RED forever by construction).
  let o_tot: i64 = o5 + o6 + o9 + o10
  let n_tot: i64 = n5 + n6 + n9 + n10
  gv_check("new-row-count-equals-the-blessed-count-both-statement-granular" as *u8, (n_tot == o_tot) as i64, ctr)
  gv_check("neg-control-row-counts-are-positive-not-an-empty-agreement" as *u8, (n_tot > 0) as i64, ctr)
154
  // ---- AND THE CHAIN MUST CARRY THEM: .loc -> nxasm -> .debug_line -> decoder ----------------
  // The counts above prove only what the COMPILER emitted. Whether the extra rows survive the
  // assembler and come back out of a real line table is a separate claim, and inferring it from
  // "the mechanism is the same" is exactly the kind of unmeasured composition this estate keeps
  // paying for. So assemble the NEW .s and decode the ELF.
  let aargs: *i64 = sys_mmap(64) as *i64
  aargs[0] = SG_S_NEW as i64
  aargs[1] = "/tmp/nx_dwstmt_new.elf" as i64
  let rc_asm: i64 = sg_run_out("_offc/nxasm_x86_main.elf" as *u8, aargs, 2, "/tmp/nx_dwstmt_asm.log" as *u8)
  gv_check("new-s-assembles" as *u8, (rc_asm == 0) as i64, ctr)
165
  let eb2: *u8 = sys_mmap(SG_CAP)
  let en2: i64 = sg_read("/tmp/nx_dwstmt_new.elf" as *u8, eb2, SG_CAP)
  let hh: *NxElfHeader = nx_elf_parse_header(eb2, en2)
  var dloff: i64 = 0
  var dlsz: i64 = 0
  if hh.valid == 1 {
      let shstr: *NxElfShdr = nx_elf_read_shdr(eb2, hh, hh.e_shstrndx)
      var si: i64 = 0
      while si < hh.e_shnum {
          let sh: *NxElfShdr = nx_elf_read_shdr(eb2, hh, si)
          let nm: *u8 = nx_elf_strtab_at(eb2, shstr.sh_offset, sh.sh_name)
          var q: i64 = 0
          var same: i64 = 1
          let want: *u8 = ".debug_line" as *u8
          var qf: i64 = 0   // exit by FLAG (2026-09-02, nx_srclint rule 2: `q = 11` inside `while want[q]` relied on want[11] being the NUL)
          while qf == 0 { if want[q] == (0 as u8) { qf = 1 } else { if nm[q] != want[q] { same = 0; qf = 1 } else { q = q + 1 } } }
          if same == 1 { if nm[11] == (0 as u8) { dloff = sh.sh_offset; dlsz = sh.sh_size } }
          si = si + 1
      }
  }
  gv_check("new-elf-carries-debug-line" as *u8, (dlsz > 0) as i64, ctr)
187
  // Scan the text range and collect which of the four source lines are RECOVERABLE from addresses.
  let dsect: *u8 = ((eb2 as i64) + dloff) as *u8
  var g5: i64 = 0
  var g6: i64 = 0
  var g9: i64 = 0
  var g10: i64 = 0
  var sa2: i64 = hh.e_entry
  let se2: i64 = hh.e_entry + 512
  while sa2 < se2 {
      let rr: *NxA2LResult = nx_a2l_run_section(dsect, dlsz, sa2)
      if rr.found == 1 {
          if rr.line == 5 { g5 = 1 }
          if rr.line == 6 { g6 = 1 }
          if rr.line == 9 { g9 = 1 }
          if rr.line == 10 { g10 = 1 }
      }
      sa2 = sa2 + 1
  }
  gv_check("decoder-recovers-function-lines-5-and-9" as *u8, ((g5 == 1) & (g9 == 1)) as i64, ctr)
  gv_check("decoder-recovers-STATEMENT-lines-6-and-10" as *u8, ((g6 == 1) & (g10 == 1)) as i64, ctr)
208
  gv_puts("\n  --- end-to-end: lines recoverable from real addresses ---\n" as *u8)
  gv_puts("  debug_line_bytes=" as *u8); gv_num(dlsz)
  gv_puts("  L5=" as *u8); gv_num(g5)
  gv_puts(" L6=" as *u8); gv_num(g6)
  gv_puts(" L9=" as *u8); gv_num(g9)
  gv_puts(" L10=" as *u8); gv_num(g10); gv_puts("\n" as *u8)
215
  gv_puts("\n  --- measured .loc rows for the same probe ---\n" as *u8)
  gv_puts("  OLD(blessed): L5=" as *u8); gv_num(o5)
  gv_puts(" L6=" as *u8);  gv_num(o6)
  gv_puts(" L9=" as *u8);  gv_num(o9)
  gv_puts(" L10=" as *u8); gv_num(o10)
  gv_puts("  total=" as *u8); gv_num(o_tot); gv_puts("\n" as *u8)
  gv_puts("  NEW(stmt):    L5=" as *u8); gv_num(n5)
  gv_puts(" L6=" as *u8);  gv_num(n6)
  gv_puts(" L9=" as *u8);  gv_num(n9)
  gv_puts(" L10=" as *u8); gv_num(n10)
  gv_puts("  total=" as *u8); gv_num(n_tot); gv_puts("\n" as *u8)
  gv_puts("  s_bytes old=" as *u8); gv_num(on)
  gv_puts(" new=" as *u8); gv_num(nn); gv_puts("\n" as *u8)
229
  return gv_verdict("nx_dwline_stmt_gate" as *u8, ctr,
      "same probe through the blessed function-granularity compiler and the statement-granularity one; the old build is the negative control" as *u8)
232}
nx_dwline_stmt_gate.nx source

`nx_dwline_stmt_gate.nx` source
