nx_cc_evidence.nx source

1// nx_cc_evidence.nx -- INDEPENDENT-OBJECTIVE evidence gate for the compiler rung. Does NOT accept any asserted 2// number: it BUILDS gcc's fannkuch, RUNS both the sovereign ELF and gcc's ELF, captures their REAL stdout, 3// verifies the checksums AGREE (differential correctness vs the incumbent -- catches bugs/poison), and computes 4// the speed score FROM the captured microseconds. Independent (gcc grades us), objective (us, reproducible), 5// differential (both must compute checksum 556355), real benchmark (CLBG fannkuch-11). This is the caliber the 6// SOTA ledger must require; a capability without evidence like this has NO position, only a claim. 7import "nx_syscalls.nx" 8import "nx_itoa_lib.nx" // shared MSB-first emitter (zero-alloc) 9const G_MAGIC_556355: i64 = 556355 10const G_MODE: i64 = 0x1a4 11const BUFSZ: i64 = 16384 12 13func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 14// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer 15// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the 16// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls). 17// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign. 18func g_putn(v: i64) -> i64 { nxi_out(v); return 0 } 19 20func g_run(path: *u8, argv: *i64, envp: *i64, redir_out: i64) -> i64 { 21 let pid: i64 = sys_fork() 22 if pid == 0 { 23 if redir_out >= 0 { sys_dup3(redir_out, 1, 0) } 24 sys_execve(path, argv, envp) 25 sys_exit(127) 26 } 27 let st: *i64 = sys_mmap(16) as *i64 28 sys_wait4(pid, st, 0) 29 let sig: i64 = st[0] & 0x7f 30 if sig != 0 { return 128 + sig } 31 return (st[0] >> 8) & 0xff 32} 33func g_slurp(path: *u8, buf: *u8) -> i64 { 34 let fd: i64 = sys_openat_rd(path) 35 if fd < 0 { return 0 } 36 var total: i64 = 0 37 var n: i64 = sys_read(fd, (buf + total) as *u8, BUFSZ - 1 - total) 38 while n > 0 { total = total + n; n = sys_read(fd, (buf + total) as *u8, BUFSZ - 1 - total) } 39 sys_close(fd); buf[total] = 0 as u8; return total 40} 41func g_match_at(buf: *u8, i: i64, key: *u8) -> i64 { var j: i64=0; while key[j]!=(0 as u8){ if buf[i+j]!=key[j]{return 0} j=j+1 } return 1 } 42func g_parse_after(buf: *u8, blen: i64, key: *u8, nf: i64) -> i64 { 43 var i: i64=0; var hit: i64=0-1 44 while i<blen { if hit<0 { if g_match_at(buf,i,key)==1 { hit=i } } i=i+1 } 45 if hit<0 { return nf } 46 var p: i64=hit; while key[p-hit]!=(0 as u8){ p=p+1 } 47 var val: i64=0; var any: i64=0; var go: i64=1 48 while go==1 { let ch: i64=buf[p] as i64; if ch<48{go=0}; if ch>57{go=0}; if go==1 { val=val*10+(ch-48); any=1; p=p+1 } } 49 if any==0 { return nf } 50 return val 51} 52func main() -> i64 { 53 g_puts("=== COMPILER RUNG: independent-objective evidence (nx_cc vs gcc -O2, live) ===\n" as *u8) 54 let envp: *i64 = sys_mmap(32) as *i64 55 envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0 56 // (1) BUILD gcc's fannkuch from the identical-algorithm C oracle -> /tmp/fk_gcc 57 let ga: *i64 = sys_mmap(64) as *i64 58 ga[0]="/usr/bin/gcc" as *u8 as i64; ga[1]="-O2" as *u8 as i64; ga[2]="fannkuch_ref.c" as *u8 as i64 59 ga[3]="-o" as *u8 as i64; ga[4]="/tmp/fk_gcc" as *u8 as i64; ga[5]=0 60 let brc: i64 = g_run("/usr/bin/gcc" as *u8, ga, envp, 0-1) 61 if brc != 0 { g_puts("verdict=RED reason=gcc-build-failed rc=" as *u8); g_putn(brc); g_puts("\n" as *u8); sys_exit(1); return 1 } 62 // (2) RUN sovereign ELF, capture stdout 63 let sfd: i64 = sys_openat_wr("/tmp/ev_sov.txt" as *u8, G_MODE) 64 let sa: *i64 = sys_mmap(16) as *i64; sa[0]="/tmp/nx_fkbench.sov.elf" as *u8 as i64; sa[1]=0 65 g_run("/tmp/nx_fkbench.sov.elf" as *u8, sa, envp, sfd); sys_close(sfd) 66 let sbuf: *u8 = sys_mmap(BUFSZ); let slen: i64 = g_slurp("/tmp/ev_sov.txt" as *u8, sbuf) 67 let sov_chk: i64 = g_parse_after(sbuf, slen, "checksum=" as *u8, 0-1) 68 let sov_us: i64 = g_parse_after(sbuf, slen, "sov_us=" as *u8, 0-1) 69 // (3) RUN gcc ELF, capture stdout 70 let gfd: i64 = sys_openat_wr("/tmp/ev_gcc.txt" as *u8, G_MODE) 71 let gr: *i64 = sys_mmap(16) as *i64; gr[0]="/tmp/fk_gcc" as *u8 as i64; gr[1]=0 72 g_run("/tmp/fk_gcc" as *u8, gr, envp, gfd); sys_close(gfd) 73 let gbuf: *u8 = sys_mmap(BUFSZ); let glen: i64 = g_slurp("/tmp/ev_gcc.txt" as *u8, gbuf) 74 let gcc_chk: i64 = g_parse_after(gbuf, glen, "checksum=" as *u8, 0-1) 75 let gcc_us: i64 = g_parse_after(gbuf, glen, "c_us=" as *u8, 0-1) 76 // (4) evidence + differential + score-from-real-numbers 77 g_puts(" RAW: sov checksum=" as *u8); g_putn(sov_chk); g_puts(" sov_us=" as *u8); g_putn(sov_us) 78 g_puts(" | gcc checksum=" as *u8); g_putn(gcc_chk); g_puts(" gcc_us=" as *u8); g_putn(gcc_us); g_puts("\n" as *u8) 79 if sov_chk != gcc_chk { g_puts("verdict=RED reason=DIFFERENTIAL-MISMATCH (ours disagrees with gcc = bug/poison; NO position)\n" as *u8); sys_exit(1); return 1 } 80 if sov_chk != G_MAGIC_556355 { g_puts("verdict=RED reason=wrong-golden-checksum\n" as *u8); sys_exit(1); return 1 } 81 if sov_us <= 0 { g_puts("verdict=RED reason=no-sov-timing\n" as *u8); sys_exit(1); return 1 } 82 let score: i64 = gcc_us * 1000 / sov_us 83 g_puts(" DIFFERENTIAL-CORRECT (both compute 556355). score=" as *u8); g_putn(score) 84 g_puts(" permille of gcc-O2 speed (1000=match). gcc is " as *u8); g_putn(sov_us*100/gcc_us); g_puts("% faster-ratio x0.01\n" as *u8) 85 if score >= 1000 { g_puts("verdict=GREEN-SOTA: matched/exceeded gcc -- REAL independent evidence.\n" as *u8) } 86 else { g_puts("verdict=EVIDENCE-RECORDED: score " as *u8); g_putn(score); g_puts("/1000 -- we are BEHIND gcc, measured honestly. This is a real position; the debt is exact.\n" as *u8) } 87 return 0 88}