Hojun-Cho
1a57de6ffe
local_zeroinit_test.ww takes the 840/944 zero-init seam (dirty-frame prime and probe share one @test because the runtime forks per test); alias_cgen_b6, alloc_nested_field, array_static_init, and strarray_static gain the rows their retired wrappers held; the remaining files re-point reject-row citations at the r788_* and stage-matrix fixtures.
92 lines
3.6 KiB
Plaintext
92 lines
3.6 KiB
Plaintext
// alloc_nested_field_test — a nested aggregate field VALUE inside an
|
|
// alloc(struct-literal) heap init must survive (C7c, task #6). The
|
|
// alloc(value) field-fill loop had only float/str/scalar arms; a field
|
|
// whose value is itself an N_STRUCTLIT / N_ARRLIT fell to the scalar
|
|
// tail, so cgexpr(inner-literal) left AX=0 and the loop stored $0 over
|
|
// the whole inner slot — silently dropping every inner leaf (byte-id-
|
|
// gate-blind: both stages emitted the same wrong fill). The fix routes
|
|
// the heap fill through the shared cg_structlit_fill / cgstructlitfill
|
|
// helper in DST_PTR_SP mode (base reloaded from the pushed heap ptr at
|
|
// (SP)), which recurses to arbitrary depth.
|
|
//
|
|
// The nested-field rows read the heap struct back via `let o: T = *p` so
|
|
// they isolate heap filling from chained pointer traversal. The alias-head and
|
|
// exact direct control both read p.x/p.y: together they preserve the old #26
|
|
// wrapper's alias-vs-non-alias comparison. Every row asserts the affected
|
|
// values independently.
|
|
|
|
package alloc_nested_field_test;
|
|
|
|
type Inner = struct { q: i64 };
|
|
type Outer = struct { x: Inner, y: i64 };
|
|
|
|
type Mid = struct { lo: i64, inner: Inner, hi: i64 };
|
|
type Nest = struct { a: i64, mid: Mid, b: i64 };
|
|
|
|
type WithArr = struct { lead: i64, arr: [3]i64, trail: i64 };
|
|
|
|
type TwoNest = struct { head: i64, s: Inner, arr: [2]i64, tail: i64 };
|
|
|
|
type AliasPoint = struct { x: i64, y: i64 };
|
|
type AliasPt = AliasPoint;
|
|
|
|
@test fn alias_named_struct() void = {
|
|
let p: *AliasPt = alloc(AliasPt{ x = 1, y = 2 })!;
|
|
assert(p.x == 1);
|
|
assert(p.y == 2);
|
|
};
|
|
|
|
@test fn direct_named_struct_control() void = {
|
|
let p: *AliasPoint = alloc(AliasPoint{ x = 1, y = 2 })!;
|
|
assert(p.x == 1);
|
|
assert(p.y == 2);
|
|
};
|
|
|
|
@test fn depth1_nested_struct() void = {
|
|
// Inner{q=10} is the field VALUE of x; pre-fix x.q dropped to 0.
|
|
let p = alloc(Outer{ x = Inner{ q = 10 }, y = 5 })!;
|
|
let o: Outer = *p;
|
|
assert(o.x.q == 10); // the dropped leaf
|
|
assert(o.y == 5); // trailing sibling, must not clobber
|
|
};
|
|
|
|
@test fn depth2_nested_struct() void = {
|
|
// Outer{ mid = Mid{ inner = Inner{q} } } — two levels of nesting.
|
|
// Every inner leaf lands at base + accumulated offset.
|
|
let p = alloc(Nest{ a = 1, mid = Mid{ lo = 2, inner = Inner{ q = 3 }, hi = 4 }, b = 5 })!;
|
|
let o: Nest = *p;
|
|
assert(o.a == 1); // lead sibling
|
|
assert(o.mid.lo == 2); // inner lead sibling
|
|
assert(o.mid.inner.q == 3); // depth-2 dropped leaf
|
|
assert(o.mid.hi == 4); // inner trail sibling
|
|
assert(o.b == 5); // trail sibling
|
|
};
|
|
|
|
@test fn nested_array_field() void = {
|
|
// arr = [10,20,30] is an N_ARRLIT field VALUE; pre-fix every
|
|
// element dropped (scalar tail stored word0 only). lead/trail
|
|
// bracket the array to prove the element stores stay in bounds.
|
|
let p = alloc(WithArr{ lead = 7, arr = [10, 20, 30], trail = 9 })!;
|
|
let o: WithArr = *p;
|
|
assert(o.lead == 7); // lead sibling
|
|
assert(o.arr[0] == 10); // dropped elements
|
|
assert(o.arr[1] == 20);
|
|
assert(o.arr[2] == 30);
|
|
assert(o.trail == 9); // trail sibling
|
|
};
|
|
|
|
@test fn multi_nested_fields() void = {
|
|
// Two ADJACENT nested-aggregate fields (nested STRUCT s, then nested
|
|
// ARRAY arr) bracketed by scalar siblings — proves the heap-base
|
|
// reload after a full nested recursion serves the NEXT nested field's
|
|
// recursion, not only a trailing scalar (every other row follows a
|
|
// nested field with a scalar). pre-fix both s.q and the arr elems drop.
|
|
let p = alloc(TwoNest{ head = 1, s = Inner{ q = 2 }, arr = [3, 4], tail = 5 })!;
|
|
let o: TwoNest = *p;
|
|
assert(o.head == 1); // lead sibling
|
|
assert(o.s.q == 2); // nested-struct leaf
|
|
assert(o.arr[0] == 3); // nested-array elems, after a nested struct
|
|
assert(o.arr[1] == 4);
|
|
assert(o.tail == 5); // trail sibling
|
|
};
|