nx_smoke_regalloc_step.nx source
↩ module page · 83 lines · 2784 B
1// Replay regalloc_function step-by-step on a binop function,
2// exiting with a different code at each checkpoint. Whichever
3// code we exit with tells us the LAST step that completed.
4
5// nx_safety_envelope:
6// intended_use: AUTO_APPLIED -- primitive-specific tuning queued
7// sil_target: SIL1
8// evidence: [bulk_applied_2026-05-16, see-file-comment-for-detail]
9// verdict: NOT_YET_EVALUATED
10
11import "nx_syscalls.nx"
12import "nx_types.nx"
13import "nx_ir.nx"
14import "nx_regalloc.nx"
15const K_MAGIC_4096: i64 = 4096
16
17func main() -> i64 {
18 let m_raw: *u8 = sys_mmap(256)
19 let m: *Module = m_raw as *Module
20 m.functions = 0 as *Function
21 m.n_functions = 0
22 let f: *Function = ir_function_new(m, "x" as *u8, 1, ir_type_i64())
23 let b: *BasicBlock = ir_block_new(f)
24 let c1: i64 = ir_const_i64(f, 10)
25 let c2: i64 = ir_const_i64(f, 20)
26 ir_emit_binop(b, OP_ADD, c1, c2, ir_type_i64())
27
28 // -- inline regalloc_function steps --
29 let intv_raw: *u8 = sys_mmap(f.n_values * 48 + 16)
30 let intv: *Interval = intv_raw as *Interval
31 let calls_raw: *u8 = sys_mmap(K_MAGIC_4096)
32 let calls: *i64 = calls_raw as *i64
33 let bb_start_raw: *u8 = sys_mmap(f.n_blocks * 8 + 16)
34 let bb_start: *i64 = bb_start_raw as *i64
35 let bb_end_raw: *u8 = sys_mmap(f.n_blocks * 8 + 16)
36 let bb_end: *i64 = bb_end_raw as *i64
37 let nc_raw: *u8 = sys_mmap(16)
38 let nc_ptr: *i64 = nc_raw as *i64
39 *nc_ptr = 0
40 build_intervals(f, intv, calls, nc_ptr, bb_start, bb_end)
41 mark_crosses_call(intv, f.n_values, calls, *nc_ptr)
42
43 let ids_raw: *u8 = sys_mmap(f.n_values * 8 + 16)
44 let ids: *i64 = ids_raw as *i64
45 var n_sorted: i64 = 0
46 var v: i64 = 0
47 while v < f.n_values {
48 let iv: *Interval = intv_at(intv, v)
49 if iv.start >= 0 {
50 ids[n_sorted] = v
51 n_sorted = n_sorted + 1
52 }
53 v = v + 1
54 }
55 sort_by_start(ids, n_sorted, intv)
56
57 let mask_raw: *u8 = sys_mmap(16)
58 let mask: *i64 = mask_raw as *i64
59 *mask = 0
60 let spill_bytes: i64 = linear_scan(intv, ids, n_sorted, mask)
61
62 let locs_raw: *u8 = sys_mmap(K_MAGIC_4096)
63 let locs: *ValueLoc = locs_raw as *ValueLoc
64 let lbase: i64 = locs as i64
65 // outer if + TWO nested ifs (the original failing pattern)
66 var ki: i64 = 0
67 while ki < f.n_values {
68 let iv2: *Interval = intv_at(intv, ki)
69 let l: *ValueLoc = (lbase + ki * 16) as *ValueLoc
70 if iv2.start >= 0 {
71 if iv2.reg >= 0 {
72 l.kind = 0
73 l.idx = iv2.reg
74 }
75 if iv2.reg < 0 {
76 l.kind = 1
77 l.idx = iv2.slot
78 }
79 }
80 ki = ki + 1
81 }
82 return __syscall(93, 100, 0, 0, 0, 0, 0)
83}