From aa8ca479439cb19f2b46e38e25b44fc443ad0427 Mon Sep 17 00:00:00 2001 From: Hojun-Cho Date: Mon, 18 May 2026 19:40:41 +0900 Subject: [PATCH] selfhost+test: route chained N_INDEX outer element size through indexvaluetnode (#24) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Wwstage cgindex's base-inspection (cgenexpr.ww) only computed esz/ signed_elem when base.kind == N_IDENT or N_DOT. For a chained `names[i][k]` (names: **u8) the outer N_INDEX has base.kind == N_INDEX; esz fell through to the default 8 so the outer load emitted `MOVQ (AX), AX` over a 1-byte u8 plus a stray `MOVQ $8, CX; IMULQ CX, AX` scaling on the outer index that cstage doesn't emit. Wrong-width-narrow-load: the byte was read as 8 bytes (reaching into adjacent memory) and the outer offset multiplied by sizeof *u8 instead of sizeof u8. Cstage walks n->lhs->type directly via the typed AST (cmd/w6c/cgen.c idx_eff → eff->sub->size at N_INDEX). Wwstage needed the parallel via indexvaluetnode — return the value-type of an N_INDEX expression by stripping one element layer off base's type, recursing for chained inner. cgindex's else-if chain now adds the N_INDEX arm: call indexvaluetnode + elemsizeofc/ elemissignedc. Class A wwstage cgen UNDER. Surfaced first time the codebase exercised the **T[i][k] shape — through expanddir in selfhost/cmd/ww/main.ww (post-#22 dir-enum, commit 9e0816e). The workaround there split names[i][k] into `let nm: *u8 = names[i]; nm[k]` to route through the bare-pointer index path. Retired in this commit: expanddir uses the natural chained form since the read path is now byte-identical across stages. Bundling justification (rule 11): the workaround retirement is the in-tree verification this fix works — without retiring, neither bootstrap byte-id nor 995_self_rebuild exercises the chained read shape. Test 739_chained_index pins cstage-byte- identical asm for **u8 (MOVZBQ load, 1 inner-stride-8 IMULQ pair, no outer scale) + **i32 (MOVSXD load, inner $8 + outer $4 IMULQ pairs). Sister latents filed (no in-tree consumer, no probe): Task #27 — cgassign chained-write N_INDEX: write path `names[i][k] = v` for **u8 has the same dispatch gap. Selfhost + lib grep is empty. New latent (filed during review) — cgindex N_DOT base on chained index: `obj.mat[i][k]` over a struct-field base falls back to esz=8. indexvaluetnode currently handles N_IDENT + N_INDEX bases only. 113/113 ok. ww2 == ww3 == ww4 byte-id. --- Makefile | 5 + selfhost/cmd/w6c/main.combined.ww | 34 +++- selfhost/cmd/wcc/cgenexpr.ww | 8 +- selfhost/cmd/wcc/cgenutil.ww | 26 +++ selfhost/cmd/ww/main.combined.ww | 10 +- selfhost/cmd/ww/main.ww | 10 +- selfhost/cmd/wwdump/main.combined.ww | 34 +++- test/wcc/739_chained_index.c | 271 +++++++++++++++++++++++++++ 8 files changed, 379 insertions(+), 19 deletions(-) create mode 100644 test/wcc/739_chained_index.c diff --git a/Makefile b/Makefile index d217ea77..80532828 100644 --- a/Makefile +++ b/Makefile @@ -266,6 +266,7 @@ TESTS = $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \ $(BIN)/test_cstage_label_ssot \ $(BIN)/test_direnum \ $(BIN)/test_module_decl \ + $(BIN)/test_chained_index \ $(BIN)/test_fnparams_bare_leaf_shadow \ $(BIN)/test_fnret_bare_leaf_shadow \ $(BIN)/test_param_shadow_mod \ @@ -639,6 +640,10 @@ $(BIN)/test_direnum: test/wcc/737_direnum.c \ $(BIN)/test_module_decl: test/wcc/738_module_decl.c $(LIB)/libwcc.a | $(BIN) $(CC) $(CFLAGS) -Icmd/wcc -o $@ $< -Lout/lib -lwcc +$(BIN)/test_chained_index: test/wcc/739_chained_index.c \ + $(BIN)/w6c $(BIN)/w6c_ww | $(BIN) + $(CC) $(CFLAGS) -o $@ $< + $(BIN)/test_fnparams_bare_leaf_shadow: test/wcc/732_fnparams_bare_leaf_shadow.c \ $(BIN)/w6c $(BIN)/w6c_ww | $(BIN) $(CC) $(CFLAGS) -o $@ $< diff --git a/selfhost/cmd/w6c/main.combined.ww b/selfhost/cmd/w6c/main.combined.ww index a6657284..99d700af 100644 --- a/selfhost/cmd/w6c/main.combined.ww +++ b/selfhost/cmd/w6c/main.combined.ww @@ -8202,6 +8202,32 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = { return slotsize(c, elem); }; +// indexvaluetnode — type node of the value produced by an N_INDEX +// expression. Walks base's type and returns its element. Recurses +// through chained N_INDEX so `names[i][k]` (names: **u8) resolves +// the outer base type to *u8 (the post-inner-index value type), so +// cgindex can compute the outer element size honestly. Mirrors +// cstage's `n->lhs->type` via typed-AST (cmd/w6c/cgen.c idx_eff). +fn indexvaluetnode(c: *cgen, n: *node) *node = { + if (n == nil) { return nil; }; + if (n.kind != nkind.N_INDEX) { return nil; }; + let base: *node = n.lhs; + if (base == nil) { return nil; }; + let bt: *node = nil; + if (base.kind == nkind.N_IDENT) { + let lc: *local = localfindnode(c, base.str); + if (lc != nil) { bt = lc.tnode; } + else { bt = letvartnode(c, base.str); }; + }; + if (base.kind == nkind.N_INDEX) { bt = indexvaluetnode(c, base); }; + if (bt == nil) { return nil; }; + let k: nkind = bt.kind; + if (k == nkind.N_TPTR) { return bt.lhs; }; + if (k == nkind.N_TSLICE) { return bt.lhs; }; + if (k == nkind.N_TARRAY) { return bt.lhs; }; + return nil; +}; + // nodeisunsigned — best-effort cgen-time inference from the AST. We // don't have a typed AST yet, so we walk surface nodes: // nkind.N_INTLIT — never marked unsigned (no tsuffix plumbing yet) @@ -11378,7 +11404,13 @@ fn cgindex(c: *cgen, n: *node) void = { }; } else { if (base.kind == nkind.N_DOT) { esz = indexbaseesz(c, base); - };}; + } else { if (base.kind == nkind.N_INDEX) { + let bt: *node = indexvaluetnode(c, base); + if (bt != nil) { + esz = elemsizeofc(c, bt); + signed_elem = elemissignedc(c, bt); + }; + };};}; }; // Tagged-union element: load slot words into (AX=tag, DX=val0, // CX=val1) matching the tagged-return ABI so call-arg / let / diff --git a/selfhost/cmd/wcc/cgenexpr.ww b/selfhost/cmd/wcc/cgenexpr.ww index 17ed1576..42925d12 100644 --- a/selfhost/cmd/wcc/cgenexpr.ww +++ b/selfhost/cmd/wcc/cgenexpr.ww @@ -680,7 +680,13 @@ fn cgindex(c: *cgen, n: *node) void = { }; } else { if (base.kind == nkind.N_DOT) { esz = indexbaseesz(c, base); - };}; + } else { if (base.kind == nkind.N_INDEX) { + let bt: *node = indexvaluetnode(c, base); + if (bt != nil) { + esz = elemsizeofc(c, bt); + signed_elem = elemissignedc(c, bt); + }; + };};}; }; // Tagged-union element: load slot words into (AX=tag, DX=val0, // CX=val1) matching the tagged-return ABI so call-arg / let / diff --git a/selfhost/cmd/wcc/cgenutil.ww b/selfhost/cmd/wcc/cgenutil.ww index 8c3af4c3..fdaadb11 100644 --- a/selfhost/cmd/wcc/cgenutil.ww +++ b/selfhost/cmd/wcc/cgenutil.ww @@ -1241,6 +1241,32 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = { return slotsize(c, elem); }; +// indexvaluetnode — type node of the value produced by an N_INDEX +// expression. Walks base's type and returns its element. Recurses +// through chained N_INDEX so `names[i][k]` (names: **u8) resolves +// the outer base type to *u8 (the post-inner-index value type), so +// cgindex can compute the outer element size honestly. Mirrors +// cstage's `n->lhs->type` via typed-AST (cmd/w6c/cgen.c idx_eff). +fn indexvaluetnode(c: *cgen, n: *node) *node = { + if (n == nil) { return nil; }; + if (n.kind != nkind.N_INDEX) { return nil; }; + let base: *node = n.lhs; + if (base == nil) { return nil; }; + let bt: *node = nil; + if (base.kind == nkind.N_IDENT) { + let lc: *local = localfindnode(c, base.str); + if (lc != nil) { bt = lc.tnode; } + else { bt = letvartnode(c, base.str); }; + }; + if (base.kind == nkind.N_INDEX) { bt = indexvaluetnode(c, base); }; + if (bt == nil) { return nil; }; + let k: nkind = bt.kind; + if (k == nkind.N_TPTR) { return bt.lhs; }; + if (k == nkind.N_TSLICE) { return bt.lhs; }; + if (k == nkind.N_TARRAY) { return bt.lhs; }; + return nil; +}; + // nodeisunsigned — best-effort cgen-time inference from the AST. We // don't have a typed AST yet, so we walk surface nodes: // nkind.N_INTLIT — never marked unsigned (no tsuffix plumbing yet) diff --git a/selfhost/cmd/ww/main.combined.ww b/selfhost/cmd/ww/main.combined.ww index 29400769..9dc35370 100644 --- a/selfhost/cmd/ww/main.combined.ww +++ b/selfhost/cmd/ww/main.combined.ww @@ -1523,19 +1523,13 @@ fn expanddir(c: *expctx, dirpath: *u8) void = { let dirpkg: *u8 = nil; let i: i32 = 0; for (i < n) { - // Two-step deref+index to avoid wwstage chained `names[i][k]` - // cgen UNDER (task #24 — wwstage cgen chained-index inner - // element size on **T). Wwstage treats inner element as 8B - // (sizeof *u8) instead of 1B (sizeof u8); cstage handles - // via typed-AST natively. Retire once the wwstage fix lands. - let nm: *u8 = names[i]; - let nlen: u64 = cstrlen(nm); + let nlen: u64 = cstrlen(names[i]); let fp: *u8 = amalloc(c.a, dlen + 1u64 + nlen + 1u64): *u8; let k: u64 = 0u64; for (k < dlen) { fp[k] = dirpath[k]; k += 1u64; }; fp[dlen] = 47u8; // '/' k = 0u64; - for (k < nlen) { fp[dlen + 1u64 + k] = nm[k]; k += 1u64; }; + for (k < nlen) { fp[dlen + 1u64 + k] = names[i][k]; k += 1u64; }; fp[dlen + 1u64 + nlen] = 0u8; let pkg: *u8 = peekpackage(c.a, fp); if (pkg != nil) { diff --git a/selfhost/cmd/ww/main.ww b/selfhost/cmd/ww/main.ww index d7cd5f77..4e60d32f 100644 --- a/selfhost/cmd/ww/main.ww +++ b/selfhost/cmd/ww/main.ww @@ -663,19 +663,13 @@ fn expanddir(c: *expctx, dirpath: *u8) void = { let dirpkg: *u8 = nil; let i: i32 = 0; for (i < n) { - // Two-step deref+index to avoid wwstage chained `names[i][k]` - // cgen UNDER (task #24 — wwstage cgen chained-index inner - // element size on **T). Wwstage treats inner element as 8B - // (sizeof *u8) instead of 1B (sizeof u8); cstage handles - // via typed-AST natively. Retire once the wwstage fix lands. - let nm: *u8 = names[i]; - let nlen: u64 = cstrlen(nm); + let nlen: u64 = cstrlen(names[i]); let fp: *u8 = amalloc(c.a, dlen + 1u64 + nlen + 1u64): *u8; let k: u64 = 0u64; for (k < dlen) { fp[k] = dirpath[k]; k += 1u64; }; fp[dlen] = 47u8; // '/' k = 0u64; - for (k < nlen) { fp[dlen + 1u64 + k] = nm[k]; k += 1u64; }; + for (k < nlen) { fp[dlen + 1u64 + k] = names[i][k]; k += 1u64; }; fp[dlen + 1u64 + nlen] = 0u8; let pkg: *u8 = peekpackage(c.a, fp); if (pkg != nil) { diff --git a/selfhost/cmd/wwdump/main.combined.ww b/selfhost/cmd/wwdump/main.combined.ww index 42b3dec3..da434c6d 100644 --- a/selfhost/cmd/wwdump/main.combined.ww +++ b/selfhost/cmd/wwdump/main.combined.ww @@ -8202,6 +8202,32 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = { return slotsize(c, elem); }; +// indexvaluetnode — type node of the value produced by an N_INDEX +// expression. Walks base's type and returns its element. Recurses +// through chained N_INDEX so `names[i][k]` (names: **u8) resolves +// the outer base type to *u8 (the post-inner-index value type), so +// cgindex can compute the outer element size honestly. Mirrors +// cstage's `n->lhs->type` via typed-AST (cmd/w6c/cgen.c idx_eff). +fn indexvaluetnode(c: *cgen, n: *node) *node = { + if (n == nil) { return nil; }; + if (n.kind != nkind.N_INDEX) { return nil; }; + let base: *node = n.lhs; + if (base == nil) { return nil; }; + let bt: *node = nil; + if (base.kind == nkind.N_IDENT) { + let lc: *local = localfindnode(c, base.str); + if (lc != nil) { bt = lc.tnode; } + else { bt = letvartnode(c, base.str); }; + }; + if (base.kind == nkind.N_INDEX) { bt = indexvaluetnode(c, base); }; + if (bt == nil) { return nil; }; + let k: nkind = bt.kind; + if (k == nkind.N_TPTR) { return bt.lhs; }; + if (k == nkind.N_TSLICE) { return bt.lhs; }; + if (k == nkind.N_TARRAY) { return bt.lhs; }; + return nil; +}; + // nodeisunsigned — best-effort cgen-time inference from the AST. We // don't have a typed AST yet, so we walk surface nodes: // nkind.N_INTLIT — never marked unsigned (no tsuffix plumbing yet) @@ -11378,7 +11404,13 @@ fn cgindex(c: *cgen, n: *node) void = { }; } else { if (base.kind == nkind.N_DOT) { esz = indexbaseesz(c, base); - };}; + } else { if (base.kind == nkind.N_INDEX) { + let bt: *node = indexvaluetnode(c, base); + if (bt != nil) { + esz = elemsizeofc(c, bt); + signed_elem = elemissignedc(c, bt); + }; + };};}; }; // Tagged-union element: load slot words into (AX=tag, DX=val0, // CX=val1) matching the tagged-return ABI so call-arg / let / diff --git a/test/wcc/739_chained_index.c b/test/wcc/739_chained_index.c new file mode 100644 index 00000000..69ee8b2d --- /dev/null +++ b/test/wcc/739_chained_index.c @@ -0,0 +1,271 @@ +/* + * 739_chained_index — sentinel for #24. Pins wwstage's cgindex to + * compute the element size of the outer N_INDEX in `arr[i][k]` from + * the value-type of the inner N_INDEX, instead of defaulting to 8. + * + * Pre-fix wwstage cgindex (selfhost/cmd/wcc/cgenexpr.ww) only + * walked `base.kind == N_IDENT` and `base.kind == N_DOT` for the + * esz/signed_elem dispatch. When base was the inner N_INDEX of a + * chained `names[i][k]` shape (names: **u8), esz stayed at the + * default 8 and the load fell through to MOVQ — an 8-byte load over + * a 1-byte u8 element, plus a stray `MOVQ $8, CX; IMULQ CX, AX` on + * the outer index that cstage doesn't emit. + * + * Cstage walks `n->lhs->type` directly (cmd/w6c/cgen.c idx_eff + + * N_INDEX, ~line 6011) — the typed AST already says the post-inner- + * index value is *u8, so eff->sub->size = 1 lands naturally. Wwstage + * needed the mirror via indexvaluetnode. + * + * Class A wwstage cgen UNDER. Surfaced first time the codebase + * exercised the **T[i][k] shape — through the dir-enum work in + * selfhost/cmd/ww/main.ww `expanddir` (task #22, predecessor commit + * 9e0816e). Workaround there split `names[i][k]` into `let nm: *u8 = + * names[i]; nm[k]` to route through the bare-pointer index path. + * + * Sentinel per row: in the `probe` body, assert the final element + * load uses the expected narrow MOV mnemonic, the outer-index scale + * is absent (esz=1) or matches `MOVQ $, CX`, and the cstage + * vs wwstage asm is byte-identical. + */ +#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; +} + +/* `loadmov` = expected mnemonic for the trailing ` (AX), AX` + * (or similar) load at the outer index. `outerscale` = expected esz + * for the outer index (1 → no IMULQ; 4 → `MOVQ $4, CX; IMULQ`). */ +struct row { + const char *label; + const char *src; + const char *loadmov; + int outerscale; +}; + +static const struct row rows[] = { + /* The load-bearing case: **u8 chained-index that the dir-enum + * workaround in selfhost/cmd/ww/main.ww `expanddir` had to dodge. */ + { "chained_u8", + "fn probe(names: **u8) u8 = {\n" + " let i: i32 = 0;\n" + " let k: u64 = 0u64;\n" + " return names[i][k];\n" + "};\n" + "export fn main() i32 = { return 0; };\n", + "MOVZBQ", 1 }, + /* **i32 — 4-byte signed-narrow load on the outer index, IMULQ $4 + * for the outer scaling, IMULQ $8 for the inner *i32 stride. */ + { "chained_i32", + "fn probe(mat: **i32) i32 = {\n" + " let i: i32 = 0;\n" + " let k: u64 = 0u64;\n" + " return mat[i][k];\n" + "};\n" + "export fn main() i32 = { return 0; };\n", + "MOVSXD", 4 }, +}; + +static int +slurp(const char *path, char *buf, size_t cap) +{ + FILE *f = fopen(path, "rb"); + if (!f) return -1; + size_t n = fread(buf, 1, cap - 1, f); + fclose(f); + buf[n] = '\0'; + return (int)n; +} + +static int +emit_s(const char *w6c, const struct row *r, int i, char *out_s, size_t cap) +{ + char src[96], cmd[1024]; + snprintf(src, sizeof src, "/tmp/chidx_%d_%d.ww", getpid(), i); + snprintf(out_s, cap, "/tmp/chidx_%d_%d_%s.s", + getpid(), i, w6c[strlen(w6c) - 1] == 'w' ? "ww" : "c"); + + FILE *f = fopen(src, "wb"); + if (!f) return -1; + fputs(r->src, f); + fclose(f); + + snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", w6c, out_s, src); + int rc = runwait(cmd); + unlink(src); + return rc; +} + +/* Inside `TEXT probe`, the final element load must use the + * expected narrow MOV mnemonic on `(AX), AX`. Pre-fix wwstage + * emitted plain `MOVQ (AX), AX`. */ +static int +check_loadmov(const char *spath, const struct row *r, const char *stage) +{ + char buf[1 << 14]; + if (slurp(spath, buf, sizeof buf) < 0) { + fprintf(stderr, "row[%s][%s]: cannot read %s\n", + r->label, stage, spath); + return -1; + } + const char *fn = strstr(buf, "TEXT probe"); + if (!fn) { + fprintf(stderr, + "row[%s][%s]: no TEXT probe in %s\n", + r->label, stage, spath); + return -1; + } + const char *ret = strstr(fn, "\tRET\n"); + char needle[64]; + snprintf(needle, sizeof needle, "\t%s\t(AX), AX\n", r->loadmov); + const char *m = strstr(fn, needle); + if (!m || (ret && m > ret)) { + fprintf(stderr, + "row[%s][%s]: expected `%s (AX), AX` in probe body\n", + r->label, stage, r->loadmov); + return -1; + } + return 0; +} + +/* Negative: pre-fix wwstage emitted a stray `MOVQ $8, CX; IMULQ CX, + * AX` for the OUTER index of a **u8 chain (because esz defaulted to + * 8). For a u8 outer the correct emit is no scaling at all. Assert + * the count of `MOVQ $8, CX` followed by `IMULQ CX, AX` pairs in the + * probe body matches the expected inner-only count (= 1 for **T; + * the inner index of *T elements always scales by 8). */ +static int +check_inner_scale_only(const char *spath, const struct row *r, + const char *stage) +{ + char buf[1 << 14]; + if (slurp(spath, buf, sizeof buf) < 0) return -1; + const char *fn = strstr(buf, "TEXT probe"); + if (!fn) return -1; + const char *ret = strstr(fn, "\tRET\n"); + if (!ret) ret = fn + strlen(fn); + + int n_inner = 0, n_outer = 0; + const char *p = fn; + while (p < ret) { + const char *inner = strstr(p, "\tMOVQ\t$8, CX\n"); + if (!inner || inner >= ret) break; + const char *next = strstr(inner, "\tIMULQ\tCX, AX\n"); + if (!next || next >= ret) { p = inner + 1; continue; } + n_inner++; + p = next + 1; + } + if (r->outerscale == 1) { + /* Pre-fix wwstage had two `MOVQ $8, CX; IMULQ` pairs (one + * for the outer index that shouldn't scale at all). Cstage + * has one — for the inner *u8 stride only. */ + if (n_inner != 1) { + fprintf(stderr, + "row[%s][%s]: expected exactly 1 inner `MOVQ $8, " + "CX; IMULQ CX, AX` pair (no outer scaling for u8), " + "got %d\n", r->label, stage, n_inner); + return -1; + } + } else { + /* For **i32: inner stride is 8 (sizeof *i32), outer scale is + * 4 (sizeof i32). Assert one `MOVQ $8, CX` for inner and one + * `MOVQ $4, CX` for outer. */ + p = fn; + while (p < ret) { + const char *outer = strstr(p, "\tMOVQ\t$4, CX\n"); + if (!outer || outer >= ret) break; + const char *next = strstr(outer, "\tIMULQ\tCX, AX\n"); + if (!next || next >= ret) { p = outer + 1; continue; } + n_outer++; + p = next + 1; + } + if (n_inner != 1 || n_outer != 1) { + fprintf(stderr, + "row[%s][%s]: expected 1 inner `MOVQ $8` + 1 outer " + "`MOVQ $4` IMULQ pair, got inner=%d outer=%d\n", + r->label, stage, n_inner, n_outer); + return -1; + } + } + return 0; +} + +int +main(void) +{ + const char *bin = getenv("BIN"); + if (!bin) bin = "out/bin"; + char absbin[512]; + if (bin[0] != '/') { + char cwd[256]; + if (getcwd(cwd, sizeof cwd) == NULL) return 1; + snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin); + bin = absbin; + } + + char w6c[640], w6c_ww[640]; + snprintf(w6c, sizeof w6c, "%s/w6c", bin); + snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin); + + int have_ww = (access(w6c_ww, X_OK) == 0); + int n = (int)(sizeof rows / sizeof rows[0]); + int total = 0, fail = 0; + + for (int i = 0; i < n; i++) { + char cs_path[128], ws_path[128]; + + if (emit_s(w6c, &rows[i], i, cs_path, sizeof cs_path) != 0) { + fprintf(stderr, + "chained_index[cstage][%s]: w6c failed\n", + rows[i].label); + fail++; total++; continue; + } + total += 2; + if (check_loadmov(cs_path, &rows[i], "cstage") != 0) fail++; + if (check_inner_scale_only(cs_path, &rows[i], "cstage") != 0) + fail++; + + if (!have_ww) { unlink(cs_path); continue; } + + if (emit_s(w6c_ww, &rows[i], i, ws_path, sizeof ws_path) != 0) { + fprintf(stderr, + "chained_index[wwstage][%s]: w6c_ww failed\n", + rows[i].label); + fail++; total++; + unlink(cs_path); continue; + } + total += 2; + if (check_loadmov(ws_path, &rows[i], "wwstage") != 0) fail++; + if (check_inner_scale_only(ws_path, &rows[i], "wwstage") != 0) + fail++; + + total++; + char cmd[512]; + snprintf(cmd, sizeof cmd, "cmp -s %s %s", cs_path, ws_path); + if (runwait(cmd) != 0) { + fprintf(stderr, + "chained_index[%s]: cstage vs wwstage asm differs\n", + rows[i].label); + fail++; + } + + unlink(cs_path); unlink(ws_path); + } + + if (fail) { + fprintf(stderr, + "chained_index: %d/%d fixtures failed\n", fail, total); + return 1; + } + printf("chained_index: %d/%d ok\n", total, total); + return 0; +}