_offc_deref_store_probe.nx source
↩ module page · 115 lines · 3155 B
1// Matrix probe for T#sovereign-deref-store-001.
2//
3// Tests `*ptr = expr` across every binding source for `ptr`. Each
4// case writes a known sentinel and reads it back; main returns
5// (case_a_works | case_b_works<<1 | ...) so each bit indicates
6// whether nxc.elf produced a working store for that case.
7//
8// Expected: 0xFF (all 8 cases return true) under a correct compiler.
9// Anything less means at least one *ptr = expr path is silently
10// dropping the store.
11//
12// Sentinels: case k writes 100 + k.
13
14import "syscalls.nx"
15
16// ---- helpers used as binding sources ----
17
18func returns_ptr() -> *i64 {
19 let r: *u8 = sys_mmap(64)
20 return r as *i64
21}
22
23func returns_ptr_via_arg(buf: *i64) -> *i64 {
24 return buf // identity; same kind of binding source
25}
26
27// ---- 8 cases ----
28
29func case_a(buf_in: *i64) -> i64 {
30 // (a) ptr is a function PARAMETER.
31 let buf: *i64 = buf_in
32 *buf = 100
33 if buf[0] == 100 { return 1 }
34 return 0
35}
36
37func case_b() -> i64 {
38 // (b) ptr is bound from a function call (the suspect case).
39 let buf: *i64 = returns_ptr()
40 *buf = 101
41 if buf[0] == 101 { return 1 }
42 return 0
43}
44
45func case_c() -> i64 {
46 // (c) ptr is bound from a CAST of mmap'd buffer.
47 let raw: *u8 = sys_mmap(64)
48 let buf: *i64 = raw as *i64
49 *buf = 102
50 if buf[0] == 102 { return 1 }
51 return 0
52}
53
54func case_d() -> i64 {
55 // (d) ptr is bound from arithmetic on another pointer.
56 let raw: *u8 = sys_mmap(64)
57 let base: i64 = raw as i64
58 let buf: *i64 = (base + 8) as *i64
59 *buf = 103
60 if buf[0] == 103 { return 1 }
61 return 0
62}
63
64func case_e() -> i64 {
65 // (e) ptr is re-bound from another let.
66 let buf0: *i64 = returns_ptr()
67 let buf: *i64 = buf0
68 *buf = 104
69 if buf[0] == 104 { return 1 }
70 return 0
71}
72
73func case_f() -> i64 {
74 // (f) deref-store immediately assigns from another deref.
75 let p: *i64 = returns_ptr()
76 let q: *i64 = returns_ptr()
77 *p = 105
78 *q = *p // RHS is a deref
79 if q[0] == 105 { return 1 }
80 return 0
81}
82
83func case_g() -> i64 {
84 // (g) deref-store with binop on RHS using *p itself.
85 let p: *i64 = returns_ptr()
86 *p = 100
87 *p = *p + 6 // both LHS and RHS deref the same pointer
88 if p[0] == 106 { return 1 }
89 return 0
90}
91
92func case_h() -> i64 {
93 // (h) ptr bound from identity-call.
94 let raw: *u8 = sys_mmap(64)
95 let buf: *i64 = returns_ptr_via_arg(raw as *i64)
96 *buf = 107
97 if buf[0] == 107 { return 1 }
98 return 0
99}
100
101func main() -> i64 {
102 let raw_a: *u8 = sys_mmap(64)
103 let buf_a: *i64 = raw_a as *i64
104
105 var bits: i64 = 0
106 if case_a(buf_a) != 0 { bits = bits | 1 }
107 if case_b() != 0 { bits = bits | 2 }
108 if case_c() != 0 { bits = bits | 4 }
109 if case_d() != 0 { bits = bits | 8 }
110 if case_e() != 0 { bits = bits | 16 }
111 if case_f() != 0 { bits = bits | 32 }
112 if case_g() != 0 { bits = bits | 64 }
113 if case_h() != 0 { bits = bits | 128 }
114 return bits // expect 0xFF = 255
115}