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

↩ module page · 305 lines · 10794 B
1// nx_cc_splice_bisect.nx -- PER-FUNCTION COMPILER-CODEGEN BISECTOR.
2//
3// Team organ (Doctor's localizer, sibling of nx_cc_equiv_gate): when
4// a challenger compiler's output misbehaves, this finds WHICH
5// function's codegen carries the defect -- no awk, no shell loops,
6// pure NishiLang file IO + fork/execve/wait4 (sovereign judging law).
7//
8// Method (asm splice): for every function whose body DIFFERS between
9// the two asm files, build a FRANKEN image = base.s with only that
10// one function's body replaced by the donor's, assemble+link it, and
11// run the franken compiler on a probe source.  A function is a
12// BREAKER iff its splice alone flips the probe verdict.  Functions
13// are self-contained ABI units, so single-function splices are valid
14// experiment isolation.
15//
16// Born 2026-06-10 bisecting the awakened-LICM self-host breakage
17// (ledger T#opt-dom-licm-dormant-paths): corpus rows all GREEN,
18// self-host RED -- the defect lives in specific big-function hoists,
19// and this organ names them.
20//
21// Usage: nx_cc_splice_bisect <base.s> <donor.s> [probe.nx]
22//   base.s   asm of the BLESSED compiler compiling some source
23//   donor.s  asm of the CHALLENGER compiling the SAME source
24//   probe.nx source the franken compiler must still compile
25//            (default runtime/_derefcast_minrepro.nx; compile rc 0
26//             + non-empty asm = behaves)
27// Exit 0 iff NO breaker found (prints/logs the per-function table
28// to knowledge/status/cc_splice_bisect.log either way).
29//
30// license_tier: ORIGINAL
31
32import "nx_syscalls.nx"
33
34const SB_MAX_FNS: i64 = 4096
35
36func sb_puts2(logfd: i64, s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
  if logfd > 0 { sys_write(logfd, s, n) }
  return 0
42}
43
44func sb_putn2(logfd: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(28)
  let o: *u8 = sys_mmap(28)
  var m: i64 = v
  var neg: i64 = 0
  if m < 0 { neg = 1; 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 w: i64 = 0
  if neg == 1 { o[0] = 45 as u8; w = 1 }
  var i: i64 = 0
  while i < k { o[w + i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, o, w + k)
  if logfd > 0 { sys_write(logfd, o, w + k) }
  return 0
60}
61
62func sb_putsn2(logfd: i64, s: *u8, n: i64) -> i64 {
  sys_write(1, s, n)
  if logfd > 0 { sys_write(logfd, s, n) }
  return 0
66}
67
68// Is buf[off..] the start of a top-level function label line?
69// Shape: ^[A-Za-z_][A-Za-z0-9_]*:\n  (directives are indented or
70// dot-prefixed; .L local labels are dot-prefixed -- both excluded.)
71// Returns the name length, or 0.
72func sb_label_len(buf: *u8, off: i64, end: i64) -> i64 {
  var c: i64 = buf[off] & 0xff
  var alpha: i64 = 0
  if c >= 65 { if c <= 90  { alpha = 1 } }
  if c >= 97 { if c <= 122 { alpha = 1 } }
  if c == 95 { alpha = 1 }
  if alpha == 0 { return 0 }
  var p: i64 = off
  while p < end {
      c = buf[p] & 0xff
      if c == 58 {                       // ':'
          if p + 1 < end {
              if (buf[p + 1] & 0xff) != 10 { return 0 }
          }
          return p - off
      }
      var ok: i64 = 0
      if c >= 65 { if c <= 90  { ok = 1 } }
      if c >= 97 { if c <= 122 { ok = 1 } }
      if c >= 48 { if c <= 57  { ok = 1 } }
      if c == 95 { ok = 1 }
      if ok == 0 { return 0 }
      p = p + 1
  }
  return 0
97}
98
99// Scan an asm buffer into parallel fn tables.
100// tab layout per entry: name_off, name_len, body_off, body_end.
101// body = from the label line through the byte before the next
102// top-level label (carries .size/.globl of the next fn's preamble --
103// harmless: names are identical on both sides of every splice).
104// Returns the number of functions found.
105func sb_scan(buf: *u8, n: i64, tab: *i64) -> i64 {
  var cnt: i64 = 0
  var off: i64 = 0
  var at_line_start: i64 = 1
  while off < n {
      if at_line_start == 1 {
          let ll: i64 = sb_label_len(buf, off, n)
          if ll > 0 {
              if cnt > 0 {
                  tab[(cnt - 1) * 4 + 3] = off       // close previous body
              }
              if cnt < SB_MAX_FNS {
                  tab[cnt * 4]     = off
                  tab[cnt * 4 + 1] = ll
                  tab[cnt * 4 + 2] = off
                  tab[cnt * 4 + 3] = n
                  cnt = cnt + 1
              }
          }
      }
      if (buf[off] & 0xff) == 10 { at_line_start = 1 }
      if (buf[off] & 0xff) != 10 { at_line_start = 0 }
      off = off + 1
  }
  return cnt
130}
131
132func sb_names_eq(a: *u8, ao: i64, al: i64, b: *u8, bo: i64, bl: i64) -> i64 {
  if al != bl { return 0 }
  var i: i64 = 0
  while i < al {
      if a[ao + i] != b[bo + i] { return 0 }
      i = i + 1
  }
  return 1
140}
141
142func sb_bodies_eq(a: *u8, as_: i64, ae: i64, b: *u8, bs: i64, be: i64) -> i64 {
  if ae - as_ != be - bs { return 0 }
  var i: i64 = 0
  let len: i64 = ae - as_
  while i < len {
      if a[as_ + i] != b[bs + i] { return 0 }
      i = i + 1
  }
  return 1
151}
152
153// fork + redirects + execve; parent waits; returns RAW wait status.
154func sb_run(path: *u8, argv: *i64, envp: *i64, redir_out: i64, redir_err: i64) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      if redir_out >= 0 { sys_dup3(redir_out, 1, 0) }
      if redir_err >= 0 { sys_dup3(redir_err, 2, 0) }
      sys_execve(path, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return st[0]
165}
166
167// Write base with one fn body swapped for the donor's -> /tmp/sb_frank.s
168func sb_write_franken(base: *u8, base_n: i64, bs: i64, be: i64,
                    donor: *u8, ds: i64, de: i64) -> i64 {
  let fd: i64 = sys_openat_wr("/tmp/sb_frank.s\x00" as *u8, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, base, bs)
  sys_write(fd, donor + ds, de - ds)
  sys_write(fd, base + be, base_n - be)
  sys_close(fd)
  return 0
177}
178
179// as + ld + run franken compiler on probe.  Returns:
180//   0 behaves (probe compiles, rc 0, non-empty asm)
181//   1 as-fail, 2 ld-fail, else the RAW probe wait status.
182func sb_try_franken(probe: *u8, envp: *i64, devnull: i64) -> i64 {
  let asbin: *u8 = "/usr/bin/as\x00"
  let a2: *i64 = sys_mmap(8 * 6) as *i64
  a2[0] = asbin as i64
  a2[1] = "/tmp/sb_frank.s\x00" as *u8 as i64
  a2[2] = "-o\x00" as *u8 as i64
  a2[3] = "/tmp/sb_frank.o\x00" as *u8 as i64
  a2[4] = 0
  if sb_run(asbin, a2, envp, 0 - 1, devnull) != 0 { return 1 }
191
  let ldbin: *u8 = "/usr/bin/ld\x00"
  let a3: *i64 = sys_mmap(8 * 6) as *i64
  a3[0] = ldbin as i64
  a3[1] = "/tmp/sb_frank.o\x00" as *u8 as i64
  a3[2] = "-o\x00" as *u8 as i64
  a3[3] = "/tmp/sb_frank.elf\x00" as *u8 as i64
  a3[4] = 0
  if sb_run(ldbin, a3, envp, 0 - 1, devnull) != 0 { return 2 }
200
  let frank: *u8 = "/tmp/sb_frank.elf\x00"
  let a4: *i64 = sys_mmap(8 * 4) as *i64
  a4[0] = frank as i64
  a4[1] = probe as i64
  a4[2] = 0
  let outfd: i64 = sys_openat_wr("/tmp/sb_probe.s\x00" as *u8, 0x1a4)
  let st: i64 = sb_run(frank, a4, envp, outfd, devnull)
  sys_close(outfd)
  if st != 0 { return st }
  // Probe asm must be non-empty (a 0-byte success is a lie).
  let pf: i64 = sys_openat_rd("/tmp/sb_probe.s\x00" as *u8)
  if pf < 0 { return 3 }
  let sz: i64 = sys_lseek(pf, 0, 2)
  sys_close(pf)
  if sz < 64 { return 3 }
  return 0
217}
218
219func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 {
      sb_puts2(0 - 1, "usage: nx_cc_splice_bisect <base.s> <donor.s> [probe.nx]\n\x00" as *u8)
      return 2
  }
  let base_path: *u8 = argv[1] as *u8
  let donor_path: *u8 = argv[2] as *u8
  var probe: *u8 = "runtime/_derefcast_minrepro.nx\x00"
  if argc >= 4 { probe = argv[3] as *u8 }
228
  let bl_p: *i64 = sys_mmap(16) as *i64
  let base: *u8 = sys_read_file(base_path, bl_p)
  let base_n: i64 = bl_p[0]
  let dl_p: *i64 = sys_mmap(16) as *i64
  let donor: *u8 = sys_read_file(donor_path, dl_p)
  let donor_n: i64 = dl_p[0]
  if base_n < 1 { return 3 }
  if donor_n < 1 { return 3 }
237
  let btab: *i64 = sys_mmap(SB_MAX_FNS * 32 + 64) as *i64
  let dtab: *i64 = sys_mmap(SB_MAX_FNS * 32 + 64) as *i64
  let bn: i64 = sb_scan(base, base_n, btab)
  let dn: i64 = sb_scan(donor, donor_n, dtab)
242
  let envp: *i64 = sys_mmap(8 * 2) as *i64
  envp[0] = "PATH=/usr/bin:/bin\x00" as *u8 as i64
  envp[1] = 0
  let devnull: i64 = sys_openat_wr("/dev/null\x00" as *u8, 0x1a4)
  let logfd: i64 = sys_openat_append("knowledge/status/cc_splice_bisect.log\x00" as *u8, 0x1a4)
248
  sb_puts2(logfd, "SPLICE-BISECT epoch=\x00" as *u8)
  sb_putn2(logfd, sys_now_realtime_sec())
  sb_puts2(logfd, " base_fns=\x00" as *u8)
  sb_putn2(logfd, bn)
  sb_puts2(logfd, " donor_fns=\x00" as *u8)
  sb_putn2(logfd, dn)
  sb_puts2(logfd, "\n\x00" as *u8)
256
  var differing: i64 = 0
  var breakers: i64 = 0
  var bi: i64 = 0
  while bi < bn {
      let b_no: i64 = btab[bi * 4]
      let b_nl: i64 = btab[bi * 4 + 1]
      let b_bs: i64 = btab[bi * 4 + 2]
      let b_be: i64 = btab[bi * 4 + 3]
      // find donor fn with same name
      var di: i64 = 0
      var found: i64 = 0 - 1
      while di < dn {
          if sb_names_eq(base, b_no, b_nl, donor, dtab[di * 4], dtab[di * 4 + 1]) == 1 {
              found = di
              di = dn
          }
          di = di + 1
      }
      if found >= 0 {
          let d_bs: i64 = dtab[found * 4 + 2]
          let d_be: i64 = dtab[found * 4 + 3]
          if sb_bodies_eq(base, b_bs, b_be, donor, d_bs, d_be) == 0 {
              differing = differing + 1
              sb_write_franken(base, base_n, b_bs, b_be, donor, d_bs, d_be)
              let rc: i64 = sb_try_franken(probe, envp, devnull)
              sb_puts2(logfd, "SPLICE-BISECT fn=\x00" as *u8)
              sb_putsn2(logfd, base + b_no, b_nl)
              sb_puts2(logfd, " probe_st=\x00" as *u8)
              sb_putn2(logfd, rc)
              if rc == 0 { sb_puts2(logfd, " verdict=BEHAVES\n\x00" as *u8) }
              if rc != 0 {
                  sb_puts2(logfd, " verdict=BREAKER\n\x00" as *u8)
                  breakers = breakers + 1
              }
          }
      }
      bi = bi + 1
  }
295
  sb_puts2(logfd, "SPLICE-BISECT differing=\x00" as *u8)
  sb_putn2(logfd, differing)
  sb_puts2(logfd, " breakers=\x00" as *u8)
  sb_putn2(logfd, breakers)
  if breakers == 0 { sb_puts2(logfd, " verdict=CLEAN\n\x00" as *u8) }
  if breakers != 0 { sb_puts2(logfd, " verdict=LOCALIZED\n\x00" as *u8) }
  if logfd > 0 { sys_close(logfd) }
  if breakers == 0 { return 0 }
  return 1
305}
nx_cc_splice_bisect.nx source

`nx_cc_splice_bisect.nx` source
