/* * 809_idx_structlit_store — cstage and wwstage agree, byte-for-byte and * at runtime, that a struct-LITERAL store into an INDEXED element place * (`a[i] = pt{...}`, `cs[i] = capture{...}`, `(*ts)[i].caps[k] = * capture{...}`) and into a DEREF place (`*p = pt{...}`) writes every * field (task #20; ken's p13 array find + prober PG4 slice extension; * gates regex fold-5a's run_thread groupstart capture store, * regex.ha:643-651). * * Pre-fix BOTH stages compiled these byte-identically WRONG (gate-blind * — only a runtime pin can hold this): the N_ASSIGN N_INDEX-lhs arm's * aggregate branch (#270-1b) gated its rhs on ident/dot/deref shapes, * so an N_STRUCTLIT rhs fell to the scalar store tail; cgexpr on a * struct literal emits NOTHING (AX stays 0) and the tail stored ONE * zero word at the element base. Net effect: every literal field * silently dropped, the element's first 8 bytes zeroed — for a * str-leading element (the regex capture shape) that nulls content.ptr * and the next read of the str field SEGFAULTS. The N_UN(STAR) deref * arm (`*p = pt{...}`) had the same fall-to-scalar tail — same class. * * The fix (BOTH stages, converged byte-identical): a struct-lit rhs * aimed at an N_INDEX, N_UN(STAR), or indexed-base N_DOT place * (`a[i].f = pt{...}`, reviewer-20 sibling — the a[i].f legacy arm's * fldstoreop tail had the same silent drop) skips the legacy arms and * routes through the F6 assign-resolver (cgplaceaddr) — the SAME C1.25 * aggregate arm that wires `(*ts)[i].field = capture{...}` N_DOT * places: materialise the literal into a FRESH per-use @placescr slot * (cg_structlit_fill_bp / cgstructlitfillbp: nested literals, str * fields, TK_ELLIPSIS autofill), resolve the place address, word-copy * esz bytes. Close-by-construction: every non-ident place kind (DOT / * INDEX / UN-STAR) now funnels struct-lit stores through that single * arm; ident places keep their enumerated fill paths. Class boundary * for OTHER rhs kinds at these places: tuple-lit/str-lit into INDEX * and DOT places work (pinned below); array-lit rhs at assignment is * unwired for every place kind and now dies LOUD (task #32, build-fail * rows below); tuple-lit through deref truncates (filed #31-E); CALL * rhs into INDEX/UN-STAR places stores only RAX (filed #31-G). * * row | shape | want * ------------------+-----------------------------------------+------ * arr_elem | a[1] = pt{3,4}; a[1].x*10+a[1].y | 34 * arr_neighbor | store a[1]; a[0]/a[2] field-set intact | 82 * arr_var_idx | a[geti()] = pt{...} (runtime index) | 34 * small_elem | 8B one-field elem (esz<=8 word-copy) | 52 * nested_lit | a[1] = outer{ in = inner{3,4}, t=5 } | 45 * partial_ellipsis | prefill 9,9; a[1] = pt{x=3, ...} → y=0 | 30 * alias_lit | type qt = pt; a[1] = qt{3,4} (chase | 34 * | peels the NAMED alias before TY_STRUCT) | * all_default | prefill 9,9; a[1] = pt{} zeroes EVERY | 7 * | word (fill-loop floor) + 7 | * tuple_elem | a[1] = (3,4); copy-out readback | 34 * dotidx_field | a[1].p = pt{3,4} (indexed-base DOT | 34 * | place, reviewer-20 sibling fix) | * slice_elem_str | cs[1] = capture{...} 56B str-leading | 128 * fieldplace_slice | ts[0].caps[1] = capture{...} | 128 * derefspine_slice | (*tsp)[0].caps[1] = capture{...} | 128 * callee_capture | (*ts)[i].caps[k] = capture{...} in a | 197 * | callee w/ *[]thr param; str readback via | * | strings.compare + len + both neighbors | * | (the EXACT fold-5a consumer shape) | * deref_lit | *p = pt{3,4} (N_UN place, same class) | 34 * global_arr | g[1] = pt{3,4}, g: [3]pt module let | 34 * arrlit_idx_loud | a[1] = [3,4] — LOUD build-fail (#32) | -1 * arrlit_deref_loud | *p = [3,4] — LOUD build-fail (#32) | -1 * * global_arr is RUNTIME-ONLY (byteid=0): an uninitialised [N]struct * value-global already diverges on master — wwstage emits a zero * `DATAW main.g(SB)` record (under-sized: 24B for a 48B array), * cstage emits none. Pre-existing, independent of this fix (task #11 * family: value-global data emission); the store/readback this row * pins is symmetric and correct on both stages. The arrlit_* rows pin * task #32's loud boundary (want -1 = driver build MUST fail; pre-#32 * both stages silently zeroed one word); flip them to runtime rows * when #32 wires the fill. */ #include #include #include #include #include #include static int runwait(const char *cmd) { int rc = system(cmd); if (rc == -1) return -1; if (WIFEXITED(rc)) return WEXITSTATUS(rc); return -1; } struct row { const char *label; const char *src; int want; int byteid; }; /* The 56B regex capture shape: str header leading + 4 size fields. * Shared preamble for the slice rows; only the store site differs. */ #define CAPTURE_DEFS \ "package main;\n" \ "type capture = struct {\n" \ "\tcontent: str,\n" \ "\tstart: size,\n" \ "\tstart_bytesize: size,\n" \ "\tend: size,\n" \ "\tend_bytesize: size,\n" \ "};\n" #define CAPTURE_SEED \ "\tlet cs: []capture = [];\n" \ "\tappend(cs, capture { content = \"a\", start = 1: size, " \ "start_bytesize = 1: size, end = 1: size, " \ "end_bytesize = 1: size });\n" \ "\tappend(cs, capture { content = \"b\", start = 2: size, " \ "start_bytesize = 2: size, end = 2: size, " \ "end_bytesize = 2: size });\n" #define CAPTURE_STORE(place) \ "\t" place " = capture { content = \"grp\", start = 3: size, " \ "start_bytesize = 4: size, end = 60: size, " \ "end_bytesize = 61: size };\n" static const struct row rows[] = { { "arr_elem", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [3]pt;\n" "\ta[1] = pt { x = 3u64, y = 4u64 };\n" "\treturn (a[1].x * 10u64 + a[1].y): i32;\n" "};\n", 34, 1 }, { "arr_neighbor", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [3]pt;\n" "\ta[0].x = 7u64; a[2].y = 9u64;\n" "\ta[1] = pt { x = 3u64, y = 4u64 };\n" "\treturn (a[0].x * 10u64 + a[2].y + a[1].x): i32;\n" "};\n", 82, 1 }, { "arr_var_idx", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "fn geti() size = { return 1: size; };\n" "export fn main() i32 = {\n" "\tlet a: [3]pt;\n" "\ta[geti()] = pt { x = 3u64, y = 4u64 };\n" "\treturn (a[1].x * 10u64 + a[1].y): i32;\n" "};\n", 34, 1 }, { "small_elem", "package main;\n" "type one = struct { v: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [2]one;\n" "\ta[0].v = 2u64;\n" "\ta[1] = one { v = 5u64 };\n" "\treturn (a[1].v * 10u64 + a[0].v): i32;\n" "};\n", 52, 1 }, { "nested_lit", "package main;\n" "type inner = struct { a: u64, b: u64 };\n" "type outer = struct { in: inner, t: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [2]outer;\n" "\ta[1] = outer { in = inner { a = 3u64, b = 4u64 }, " "t = 5u64 };\n" "\treturn (a[1].in.b * 10u64 + a[1].t): i32;\n" "};\n", 45, 1 }, { "partial_ellipsis", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [3]pt;\n" "\ta[1].x = 9u64; a[1].y = 9u64;\n" "\ta[1] = pt { x = 3u64, ... };\n" "\treturn (a[1].x * 10u64 + a[1].y): i32;\n" "};\n", 30, 1 }, { "alias_lit", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "type qt = pt;\n" "export fn main() i32 = {\n" "\tlet a: [3]pt;\n" "\ta[1] = qt { x = 3u64, y = 4u64 };\n" "\treturn (a[1].x * 10u64 + a[1].y): i32;\n" "};\n", 34, 1 }, { "all_default", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [3]pt;\n" "\ta[1].x = 9u64; a[1].y = 9u64;\n" "\ta[1] = pt {};\n" "\treturn (a[1].x * 10u64 + a[1].y + 7u64): i32;\n" "};\n", 7, 1 }, { "tuple_elem", "package main;\n" "export fn main() i32 = {\n" "\tlet a: [2](u64, u64);\n" "\ta[1] = (3u64, 4u64);\n" "\tlet t: (u64, u64) = a[1];\n" "\treturn (t.0 * 10u64 + t.1): i32;\n" "};\n", 34, 1 }, { "dotidx_field", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "type box = struct { p: pt, t: u64 };\n" "export fn main() i32 = {\n" "\tlet a: [2]box;\n" "\ta[1].p.x = 9u64; a[1].p.y = 9u64;\n" "\tif (a[1].p.x != 9u64 || a[1].p.y != 9u64) { return 250; };\n" "\ta[1].p = pt { x = 3u64, y = 4u64 };\n" "\treturn (a[1].p.x * 10u64 + a[1].p.y): i32;\n" "};\n", 34, 1 }, { "slice_elem_str", CAPTURE_DEFS "export fn main() i32 = {\n" CAPTURE_SEED CAPTURE_STORE("cs[1]") "\tif (cs[0].start != 1) { return 250; };\n" "\treturn (cs[1].start + cs[1].start_bytesize + cs[1].end + " "cs[1].end_bytesize): i32;\n" "};\n", 128, 1 }, { "fieldplace_slice", CAPTURE_DEFS "type thr = struct { pc: size, caps: []capture };\n" "export fn main() i32 = {\n" CAPTURE_SEED "\tlet ts: []thr = [];\n" "\tappend(ts, thr { pc = 5: size, caps = cs });\n" CAPTURE_STORE("ts[0].caps[1]") "\tif (ts[0].caps[0].start != 1) { return 250; };\n" "\treturn (ts[0].caps[1].start + ts[0].caps[1].start_bytesize + " "ts[0].caps[1].end + ts[0].caps[1].end_bytesize): i32;\n" "};\n", 128, 1 }, { "derefspine_slice", CAPTURE_DEFS "type thr = struct { pc: size, caps: []capture };\n" "export fn main() i32 = {\n" CAPTURE_SEED "\tlet ts: []thr = [];\n" "\tappend(ts, thr { pc = 5: size, caps = cs });\n" "\tlet tsp = &ts;\n" CAPTURE_STORE("(*tsp)[0].caps[1]") "\tif (ts[0].caps[0].start != 1) { return 250; };\n" "\treturn (ts[0].caps[1].start + ts[0].caps[1].start_bytesize + " "ts[0].caps[1].end + ts[0].caps[1].end_bytesize): i32;\n" "};\n", 128, 1 }, /* The fold-5a consumer pin: regex.ha:643-651 verbatim shape — * callee takes *[]thr, double-indexes through the deref spine, * stores the 56B capture literal. Readback covers the str field * (strings.compare + len — pre-fix this SEGFAULTED on the nulled * content.ptr), both neighbor elements (56B store must not * smear), and all four size fields. 3+4+60+61+3*23 = 197. */ { "callee_capture", "package main;\n" "\n" "import strings;\n" "\n" "type capture = struct {\n" "\tcontent: str,\n" "\tstart: size,\n" "\tstart_bytesize: size,\n" "\tend: size,\n" "\tend_bytesize: size,\n" "};\n" "type thr = struct { pc: size, caps: []capture };\n" "fn store(ts: *[]thr, i: size, idx: size) void = {\n" "\t(*ts)[i].caps[idx] = capture {\n" "\t\tcontent = \"grp\",\n" "\t\tstart = 3: size,\n" "\t\tstart_bytesize = 4: size,\n" "\t\tend = 60: size,\n" "\t\tend_bytesize = 61: size,\n" "\t};\n" "};\n" "export fn main() i32 = {\n" "\tlet cs: []capture = [];\n" "\tappend(cs, capture { content = \"a\", start = 1: size, " "start_bytesize = 1: size, end = 1: size, " "end_bytesize = 1: size });\n" "\tappend(cs, capture { content = \"b\", start = 2: size, " "start_bytesize = 2: size, end = 2: size, " "end_bytesize = 2: size });\n" "\tappend(cs, capture { content = \"c\", start = 9: size, " "start_bytesize = 9: size, end = 9: size, " "end_bytesize = 9: size });\n" "\tlet ts: []thr = [];\n" "\tappend(ts, thr { pc = 5: size, caps = cs });\n" "\tstore(&ts, 0: size, 1: size);\n" "\tif (strings.compare(ts[0].caps[1].content, \"grp\") != 0) " "{ return 250; };\n" "\tif (len(ts[0].caps[1].content) != 3) { return 249; };\n" "\tif (ts[0].caps[0].end != 1 || ts[0].caps[2].start != 9) " "{ return 248; };\n" "\tif (strings.compare(ts[0].caps[2].content, \"c\") != 0) " "{ return 247; };\n" "\tlet acc = ts[0].caps[1].start + ts[0].caps[1].start_bytesize\n" "\t\t+ ts[0].caps[1].end + ts[0].caps[1].end_bytesize\n" "\t\t+ ts[0].caps[1].start * 23;\n" "\treturn acc: i32;\n" "};\n", 197, 1 }, { "deref_lit", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "export fn main() i32 = {\n" "\tlet a: pt = pt { x = 1u64, y = 2u64 };\n" "\tlet p: *pt = &a;\n" "\t*p = pt { x = 3u64, y = 4u64 };\n" "\treturn (a.x * 10u64 + a.y): i32;\n" "};\n", 34, 1 }, { "global_arr", "package main;\n" "type pt = struct { x: u64, y: u64 };\n" "let g: [3]pt;\n" "export fn main() i32 = {\n" "\tg[1] = pt { x = 3u64, y = 4u64 };\n" "\treturn (g[1].x * 10u64 + g[1].y): i32;\n" "};\n", 34, 0 }, { "arrlit_idx_loud", "package main;\n" "export fn main() i32 = {\n" "\tlet a: [2][2]u64;\n" "\ta[1] = [3u64, 4u64];\n" "\treturn (a[1][0] * 10u64 + a[1][1]): i32;\n" "};\n", -1, 0 }, { "arrlit_deref_loud", "package main;\n" "export fn main() i32 = {\n" "\tlet a: [2]u64;\n" "\tlet p: *[2]u64 = &a;\n" "\t*p = [3u64, 4u64];\n" "\treturn (a[0] * 10u64 + a[1]): i32;\n" "};\n", -1, 0 }, }; static int run_driver(const char *driver, const struct row *r, int i) { char src[64], tmpdir[64], cmd[1024]; snprintf(src, sizeof src, "/tmp/isls_%d_%d.ww", getpid(), i); snprintf(tmpdir, sizeof tmpdir, "/tmp/isls_%d_d_%d", getpid(), i); FILE *f = fopen(src, "wb"); if (!f) return -1; fputs(r->src, f); fclose(f); mkdir(tmpdir, 0755); snprintf(cmd, sizeof cmd, "cd %s && %s build %s 2>/dev/null", tmpdir, driver, src); if (runwait(cmd) != 0) { /* want == -1 rows pin a LOUD build refusal (task #32). */ if (r->want != -1) fprintf(stderr, "row[%s]: build via %s failed\n", r->label, driver); unlink(src); rmdir(tmpdir); return -1; } const char *base = strrchr(src, '/'); base = base ? base + 1 : src; char outbin[128]; snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base); char *dot = strrchr(outbin, '.'); if (dot && strcmp(dot, ".ww") == 0) *dot = '\0'; int got = runwait(outbin); unlink(src); unlink(outbin); rmdir(tmpdir); return got; } /* asm_byte_identical — generate .s via the driver, once with cstage's * w6c and once with the wwstage compiler (WW_W6C override; w6a/w6l stay * cstage — only the .s is compared), and diff. The driver route — not a * bare `w6c src.ww` — so importing rows (callee_capture pulls strings) * resolve; the driver leaves src.s NEXT TO the source. Pre-fix the asm * was byte-identically WRONG (both stages dropped the fill), so these * rows pin only that the converged fix stays symmetric; the runtime * rows above carry correctness. */ static int asm_byte_identical(const char *bin, const struct row *r, int i) { char src[64], srcs[64], comb[80], srco[64], tmpdir[64]; char cs[64], ws[64], cmd[1024]; snprintf(src, sizeof src, "/tmp/isls_asm_%d_%d.ww", getpid(), i); snprintf(srcs, sizeof srcs, "/tmp/isls_asm_%d_%d.s", getpid(), i); snprintf(srco, sizeof srco, "/tmp/isls_asm_%d_%d.o", getpid(), i); snprintf(comb, sizeof comb, "/tmp/isls_asm_%d_%d.combined.ww", getpid(), i); snprintf(tmpdir, sizeof tmpdir, "/tmp/isls_asm_%d_d_%d", getpid(), i); snprintf(cs, sizeof cs, "/tmp/isls_asm_%d_%d_c.s", getpid(), i); snprintf(ws, sizeof ws, "/tmp/isls_asm_%d_%d_w.s", getpid(), i); FILE *f = fopen(src, "wb"); if (!f) return -1; fputs(r->src, f); fclose(f); mkdir(tmpdir, 0755); snprintf(cmd, sizeof cmd, "cd %s && %s/ww build %s 2>/dev/null", tmpdir, bin, src); if (runwait(cmd) != 0 || rename(srcs, cs) != 0) { fprintf(stderr, "row[%s]: cstage driver .s failed\n", r->label); unlink(src); unlink(srco); unlink(comb); rmdir(tmpdir); return -1; } snprintf(cmd, sizeof cmd, "cd %s && WW_W6C=%s/w6c_ww %s/ww build %s 2>/dev/null", tmpdir, bin, bin, src); if (runwait(cmd) != 0 || rename(srcs, ws) != 0) { fprintf(stderr, "row[%s]: wwstage driver .s failed\n", r->label); unlink(src); unlink(srco); unlink(comb); unlink(cs); rmdir(tmpdir); return -1; } FILE *fc = fopen(cs, "rb"); FILE *fw = fopen(ws, "rb"); int rc = 0; if (!fc || !fw) { rc = -1; } else { for (;;) { int a = fgetc(fc); int b = fgetc(fw); if (a != b) { rc = -1; break; } if (a == EOF) break; } } if (fc) fclose(fc); if (fw) fclose(fw); if (rc != 0) fprintf(stderr, "row[%s]: cstage vs wwstage asm differs\n", r->label); { char outbin[128]; snprintf(outbin, sizeof outbin, "%s/isls_asm_%d_%d", tmpdir, getpid(), i); unlink(outbin); } unlink(src); unlink(srco); unlink(comb); unlink(cs); unlink(ws); rmdir(tmpdir); return rc; } int main(void) { const char *bin = getenv("BIN"); if (!bin) bin = "out/bin"; char absbin[1024]; if (bin[0] != '/') { char cwd[1024]; if (getcwd(cwd, sizeof cwd) == NULL) return 1; snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin); bin = absbin; } char cdrv[1024]; snprintf(cdrv, sizeof cdrv, "%s/ww", bin); char wdrv[1024]; snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin); struct { const char *name; const char *path; int gated_on_existence; } drivers[] = { { "cstage", cdrv, 0 }, { "wwstage", wdrv, 1 }, { NULL, NULL, 0 }, }; int n = (int)(sizeof rows / sizeof rows[0]); int total = 0, fail = 0; for (int d = 0; drivers[d].name; d++) { if (drivers[d].gated_on_existence && access(drivers[d].path, X_OK) != 0) { fprintf(stderr, "idx_structlit_store: skip %s (no %s)\n", drivers[d].name, drivers[d].path); continue; } for (int i = 0; i < n; i++) { int got = run_driver(drivers[d].path, &rows[i], i); total++; if (got != rows[i].want) { fprintf(stderr, "idx_structlit_store[%s][%s]: " "exit=%d want=%d\n", drivers[d].name, rows[i].label, got, rows[i].want); fail++; } } } if (access(wdrv, X_OK) == 0) { for (int i = 0; i < n; i++) { if (!rows[i].byteid) continue; total++; if (asm_byte_identical(bin, &rows[i], i) != 0) fail++; } } if (fail) { fprintf(stderr, "idx_structlit_store: %d/%d fixtures failed\n", fail, total); return 1; } printf("idx_structlit_store: %d/%d ok\n", total, total); return 0; }