From 6fc85f9aaf0dbe67ddfccfe25d870d8919ff9651 Mon Sep 17 00:00:00 2001 From: Hojun-Cho Date: Mon, 1 Jun 2026 19:56:52 +0900 Subject: [PATCH] w6c+wwstage: construct + bind tuple-in-union payload (#242) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A mixed-scalar tuple WRAPPED IN A TAGGED UNION (the (neg, n) shape Hare's strconv parseint returns, ((bool,u64)|invalid|overflow)) miscompiled three ways, all gate-blind (no bootstrap tuple-in-union): (a) cstage CONSTRUCTION: a tuple variant fell through the N_RETURN scalar shuffle, which ZEROED tag + payload — the operands were never packed. Route the tuple variant through the scratch-slot widen path; add a TY_TUPLE arm to cg_widen_tagged_store that packs each element into the union payload at the register-ABI 8B stride + sets the variant tag. (b) wwstage CHECKER: `let (a,b)=t` over a plain tuple ident (the match- bound union payload) left the un-annotated binders UNTYPED, so the bin node reading them was untyped -> asserttyped abort. The element-type distribution only fired for an N_CALL rhs. Consume the rhs tuple type for ANY rhs (mirror cstage check.c:2017). (c) BOTH stages DESTRUCTURE: the register-cursor receive assumes the rhs left every element in AX/DX/CX (a call's tuple-return ABI). For a tuple IDENT cgexpr loads only word0->AX, so the 2nd binder read a STALE DX. Copy each element from the ident's slot at the 8B stride. Construction is correct at ANY variant position (the resolved tag, not a default 0); wwstage resolves it via the typeeq core (flatvariantidxt), not taggedvariantindext whose str/slice shape-fallback would mask a mismatch. Two rule-7 loud-stops cover shapes this slotted packing can't yet handle, on BOTH stages, so neither silently miscompiles: - a tuple with a SysV-eightbyte-sharing narrow pair (e.g. (i32,i32,u64)), caught by the 8+payload > slot-size guard (the eightbyte tuple classification is #243); - a tuple built from a BARE LITERAL element (`true`/`false`, suffix-less `7`). cstage's cg_tag_for_variant can't type the literal (#241), returns -1, and loud-stops. wwstage types `true` as bool and `7` as untyped_int, so flatvariantidxt WOULD resolve the variant — a program cstage rejects but wwstage accepts is the cs!=ww divergence rule 10 forbids. wwstage mirrors cstage's CONDITION (a bare-literal element), not its -1 mechanism, with an explicit guard that aligns the richer side DOWN. Lift BOTH guards together when #241 lands cstage literal typing -> symmetric accept. Test 940_tuple_in_union: 4 K_RUN rows (variant 0, void arm, tuple at variant 1 two ways) x cstage-run + wwstage-run + cs==ww byte-id, plus 2 K_BUILDERR rows (eightbyte-share, bare-literal) asserting a loud stop with the #242 diagnostic on BOTH drivers = 16 ok. --- Makefile | 7 + cmd/w6c/cgen.c | 126 +++++++++- selfhost/cmd/w6c/main.combined.ww | 220 ++++++++++++++++- selfhost/cmd/wcc/cgenstmt.ww | 78 ++++++- selfhost/cmd/wcc/cgenutil.ww | 128 ++++++++++ selfhost/cmd/wcc/check.ww | 14 +- selfhost/cmd/wwdump/main.combined.ww | 220 ++++++++++++++++- test/wcc/940_tuple_in_union_run.c | 337 +++++++++++++++++++++++++++ 8 files changed, 1114 insertions(+), 16 deletions(-) create mode 100644 test/wcc/940_tuple_in_union_run.c diff --git a/Makefile b/Makefile index 7433cfe0..7f9e70a3 100644 --- a/Makefile +++ b/Makefile @@ -291,6 +291,7 @@ TESTS = $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \ $(BIN)/test_tuple_nary_destructure_run \ $(BIN)/test_overcap_tuple_field_store_run \ $(BIN)/test_mixed_scalar_tuple_sret_run \ + $(BIN)/test_tuple_in_union_run \ $(BIN)/test_tuple_elem_slice_len_run \ $(BIN)/test_str_forrange_loopvar_run \ $(BIN)/test_composite_call_arg \ @@ -1187,6 +1188,12 @@ $(BIN)/test_mixed_scalar_tuple_sret_run: test/wcc/940_mixed_scalar_tuple_sret_ru $(LIB)/libwwrt.a | $(BIN) $(CC) $(CFLAGS) -o $@ $< +$(BIN)/test_tuple_in_union_run: test/wcc/940_tuple_in_union_run.c \ + $(BIN)/ww $(BIN)/w6c $(BIN)/w6a $(BIN)/w6l \ + $(BIN)/ww_ww $(BIN)/w6c_ww $(BIN)/w6a_ww $(BIN)/w6l_ww \ + $(LIB)/libwwrt.a | $(BIN) + $(CC) $(CFLAGS) -o $@ $< + $(BIN)/test_composite_call_arg: test/wcc/723_composite_call_arg.c \ $(BIN)/w6c $(BIN)/w6c_ww | $(BIN) $(CC) $(CFLAGS) -o $@ $< diff --git a/cmd/w6c/cgen.c b/cmd/w6c/cgen.c index a23bd6e3..b2ca391e 100644 --- a/cmd/w6c/cgen.c +++ b/cmd/w6c/cgen.c @@ -2034,6 +2034,74 @@ cg_widen_tagged_store(Cg *c, Local **locals_p, Type *dst, Node *src, if (via_outer) goto copy_out; return; } + /* #242: tuple payload. Each element rides ONE register-ABI + * eightbyte — scalar/float a single 8B word, a slice/str its 3-word + * {ptr,len,cap} header (24B) — matching the tagged-return load + * (AX=tag, DX=word0, CX=word1, R8=word2) and the cgmlet receive + * cursor. NOT the packed-by-size t.N field layout (#238). Mirror of + * the struct-literal field-flow below, but 8B-slotted, not field- + * offset. */ + if (su && su->kind == TY_TUPLE && src->kind == N_TUPLE) { + int tag = cg_tag_for_variant(du, st); + /* #242: a tuple built from UNTYPED/literal elements (`(true,7)`) + * leaves the src tuple type un-matchable by type_eq, so the + * variant tag can't resolve — the supported shape is a tuple of + * TYPED expressions (the strconv parseint `(neg, n)` shape). + * Loud-stop rather than silently mis-tag (tag 0) — rule 7. + * Untyped tuple-element coercion is the #241 literal-init + * family. */ + if (tag < 0) + fatal("cg_widen_tagged_store: tuple-in-union variant tag " + "unresolved (untyped/literal tuple element; " + "see #242 / #241)"); + /* #242: this 8B-per-eightbyte packing is correct only when no + * two scalar elements share a SysV eightbyte — e.g. (bool,u64), + * where the sub-8 bool is padded out by u64's 8-alignment. A + * tuple whose natural aligned layout packs two narrows into one + * eightbyte (e.g. (i32,i32,u64)) would overflow the union + * payload the slotted write assumes. Loud-stop (rule 7); the + * SysV eightbyte tuple classification is a deferred follow-up. */ + int total = 0; + for (Node *e = src->list; e; e = e->next) + total += (node_isstr(e) || node_isslice(e)) ? 24 : 8; + if (8 + total > sz) + fatal("cg_widen_tagged_store: tuple-in-union payload needs " + "SysV eightbyte packing (narrow elements share an " + "eightbyte; see #242 follow-up)"); + ins2(c, A_XORQ, areg(D_AX), areg(D_AX)); + for (int k = 0; k < sz; k += 8) + ins2(c, A_MOVQ, areg(D_AX), + amem(D_BP, write_off + k)); + int foff = 0; + for (Node *e = src->list; e; e = e->next) { + int e_isf32 = 0; + int isflt = fld_isfloat(e->type, &e_isf32); + int wide = node_isstr(e) || node_isslice(e); + int esz = e->type ? (int)e->type->size : 8; + cgexpr(c, e, *locals_p); + if (isflt) { + ins2(c, e_isf32 ? A_MOVSS : A_MOVSD, + areg(D_X0), + amem(D_BP, write_off + 8 + foff)); + } else if (wide) { + ins2(c, A_MOVQ, areg(D_AX), + amem(D_BP, write_off + 8 + foff + 0)); + ins2(c, A_MOVQ, areg(D_BX), + amem(D_BP, write_off + 8 + foff + 8)); + ins2(c, A_MOVQ, areg(D_CX), + amem(D_BP, write_off + 8 + foff + 16)); + } else { + ins2(c, fldstoreop(e->type, esz), + areg(D_AX), + amem(D_BP, write_off + 8 + foff)); + } + foff += wide ? 24 : 8; + } + ins2(c, A_MOVQ, aimm(tag < 0 ? 0 : tag), + amem(D_BP, write_off + 0)); + if (via_outer) goto copy_out; + return; + } /* Struct payload: zero the whole slot, then write fields/words * at slot+8+ — keeping the tag word at slot+0 from the zero-fill, * then patch it with the variant tag. */ @@ -8399,12 +8467,19 @@ cgstmt(Cg *c, Node *n, Local **locals, int *frame) int passthrough = istagged && (vu == rt || type_eq(vt, cg_ret_type)); int isstruct = vu && vu->kind == TY_STRUCT; + /* #242: a tuple variant must be PACKED into the union + * payload (tag + per-element words), not shuffled like a + * bare scalar — route it through the scratch-slot widen + * path (cg_widen_tagged_store TY_TUPLE arm). The scalar + * arm below zeroed the whole value (never packed the + * operands). */ + int istuple = vu && vu->kind == TY_TUPLE; if (rt->nullable) { cgexpr(c, n->lhs, *locals); } else if (passthrough) { /* same tagged type: forward AX/DX/CX. */ cgexpr(c, n->lhs, *locals); - } else if (!istagged && !isstruct) { + } else if (!istagged && !isstruct && !istuple) { /* str / slice / scalar variant: synthesise * the tag in AX and shuffle the value into * DX[/CX[/R8]]. Direct register path keeps @@ -9123,6 +9198,55 @@ cgstmt(Cg *c, Node *n, Local **locals, int *frame) * at its NATURAL width (#169). The receive has no single lvalue * dest, so it reuses the same per-fn @sretscr slot a discarded * sret call would; the in-reg path below is unchanged. */ + /* #242: rhs is a tuple already materialised in a local slot (a + * match-bound union payload, `let (a,b)=t`), NOT a register- + * returning call. cgexpr(tuple ident) loads only word0->AX, so + * the register-cursor path below reads DX/CX stale. Copy each + * element from the ident's slot at the register-ABI 8B stride + * (24B for a slice/str header) — the SAME layout the tagged + * construct + match payload-bind write. */ + if (n->rhs && n->rhs->kind == N_IDENT) { + Type *rty = type_chase_named(n->rhs->type); + if (rty && rty->kind == TY_TUPLE) { + int srcoff = localfind(*locals, n->rhs->str); + int lf32b; + int foff = 0; + for (Node *l = n->list; l; l = l->next) { + Type *t = l->type; + Type *u = type_chase_named(t); + int wide = u && (u->kind == TY_SLICE + || u->kind == TY_STR); + int isflt = fld_isfloat(t, &lf32b); + int esz = t ? (int)t->size : 8; + int bsz = wide ? esz : 8; + int off = localoff(c, locals, l->str, + bsz, frame); + if (isflt) { + ins2(c, lf32b ? A_MOVSS : A_MOVSD, + amem(D_BP, srcoff + foff), + areg(D_X0)); + ins2(c, lf32b ? A_MOVSS : A_MOVSD, + areg(D_X0), amem(D_BP, off)); + } else if (wide) { + for (int k = 0; k < esz; k += 8) { + ins2(c, A_MOVQ, + amem(D_BP, srcoff + foff + k), + areg(D_AX)); + ins2(c, A_MOVQ, areg(D_AX), + amem(D_BP, off + k)); + } + } else { + ins2(c, fldloadop(t, esz), + amem(D_BP, srcoff + foff), + areg(D_AX)); + ins2(c, fldstoreop(t, esz), + areg(D_AX), amem(D_BP, off)); + } + foff += wide ? 24 : 8; + } + break; + } + } int sret_recv = (n->rhs && n->rhs->kind == N_CALL) ? cg_sret_retsize(n->rhs->type) : 0; cgexpr(c, n->rhs, *locals); diff --git a/selfhost/cmd/w6c/main.combined.ww b/selfhost/cmd/w6c/main.combined.ww index bb764072..a7bf2c26 100644 --- a/selfhost/cmd/w6c/main.combined.ww +++ b/selfhost/cmd/w6c/main.combined.ww @@ -10721,14 +10721,19 @@ fn resolvewalk(c: *checker, n: *node) void = { if (k == nkind.N_MLET) { if (n.rhs != nil) { resolvewalk(c, n.rhs); }; let pt: *node = nil; - if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) { + // #242: consume the rhs's tuple type for ANY rhs, not just an + // N_CALL — `let (a,b) = t` over a plain tuple ident (e.g. a + // match-bound union payload) must stamp its bindings too, or + // the un-annotated binder stays untyped and asserttyped aborts. + // Mirrors cstage check.c:2017 (cexpr(rhs), unconditional). + if (n.rhs != nil) { // `rt` would shadow the imported lib/rt module // (checkmoduleshadow errors); `rty` avoids it. let rty: *node = exprtype(c, n.rhs, nil); if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) { pt = rty.list; }; }; - }; }; + }; stamptuplebinds(c, n.list, pt, true, "let"); return; }; @@ -10743,12 +10748,13 @@ fn resolvewalk(c: *checker, n: *node) void = { if (k == nkind.N_MASSIGN) { if (n.rhs != nil) { resolvewalk(c, n.rhs); }; let pt: *node = nil; - if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) { + // #242: consume the rhs tuple type for ANY rhs (see N_MLET). + if (n.rhs != nil) { let rty: *node = exprtype(c, n.rhs, nil); if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) { pt = rty.list; }; }; - }; }; + }; let l: *node = n.list; for (l != nil) { resolvewalk(c, l); l = l.next; }; stamptuplebinds(c, n.list, pt, false, ""); @@ -17993,6 +17999,134 @@ fn cgwidentaggedstorebp(c: *cgen, dst: *tinfo, src: *node, slot_off: i32, slot_s }; return; }; + // #242: tuple payload. Each element rides ONE register-ABI + // eightbyte — scalar/float a single 8B word, a slice/str its 3-word + // {ptr,len,cap} header (24B) — matching the tagged-return load + // (AX=tag, DX=word0, CX=word1, R8=word2) and the cgmlet receive + // cursor. NOT the packed-by-size t.N field layout (#238). Mirror of + // cstage cg_widen_tagged_store's TY_TUPLE arm. + if (src != nil) { if (src.kind == nkind.N_TUPLE) { + let stu: *tinfo = src.type_: *tinfo; + for (stu != nil && stu.kind == tykind.TY_NAMED) { stu = stu.under; }; + if (stu != nil) { if (stu.kind == tykind.TY_TUPLE) { + // #242/#241: mirror cstage's loud-stop CONDITION, not its + // -1 mechanism (rule 10, align the RICHER side DOWN). + // wwstage types `true`/`false` as bool and a suffix-less `7` + // as untyped_int, so flatvariantidxt below DOES resolve the + // variant — but cstage's cg_tag_for_variant can't type a bare + // literal element (#241), returns -1, and loud-stops. A + // program cstage rejects, wwstage must also reject. The shape + // cstage can't type: a bool literal (N_TRUE/N_FALSE) or a + // suffix-less numeric literal (untyped_int/untyped_float). + // LIFT BOTH stage guards together when #241 fixes cstage + // literal typing -> symmetric accept. + let bl: *node = src.list; + for (bl != nil) { + let bare: bool = false; + if (bl.kind == nkind.N_TRUE) { bare = true; }; + if (bl.kind == nkind.N_FALSE) { bare = true; }; + if (bl.kind == nkind.N_INTLIT && bl.tsuffix.len == 0) { + bare = true; + }; + if (bl.kind == nkind.N_FLOATLIT && bl.tsuffix.len == 0) { + bare = true; + }; + if (bare) { + let ml: str = "cgwidentaggedstore: tuple-in-union variant tag unresolved (untyped/literal tuple element; see #242 / #241)\n"; + os.write(2, ml.ptr, ml.len: u64); + os.exit(1); + }; + bl = bl.next; + }; + // #242: resolve the variant tag via the typeeq core + // (flatvariantidxt) — NOT taggedvariantindext, whose + // str/slice shape fallback would silently pick tag 0 for an + // unmatched tuple, diverging from cstage cg_tag_for_variant + // (which returns -1) and masking the loud-stop below. + let ttag: i32 = flatvariantidxt(dt, src.type_: *tinfo); + // #242: an untyped/literal tuple element (`(true,7)`) leaves + // the src tuple un-matchable, so the variant tag can't + // resolve — the supported shape is a tuple of TYPED exprs + // (strconv parseint `(neg, n)`). Loud-stop rather than + // silently mis-tag (rule 7); #241 literal-init family. + if (ttag < 0) { + let m1: str = "cgwidentaggedstore: tuple-in-union variant tag unresolved (untyped/literal tuple element; see #242 / #241)\n"; + os.write(2, m1.ptr, m1.len: u64); + os.exit(1); + }; + // #242: this 8B-per-eightbyte packing is correct only when + // no two scalar elements share a SysV eightbyte — e.g. + // (bool,u64). A (i32,i32,u64) would overflow the union + // payload the slotted write assumes. Loud-stop (rule 7); + // SysV eightbyte tuple classification is a deferred + // follow-up. Symmetric with cstage cg_widen_tagged_store. + let ttotal: i32 = 0; + let ce: *node = src.list; + for (ce != nil) { + if (nodeisstr(c, ce) || nodeisslice(c, ce)) { + ttotal += 24; + } else { ttotal += 8; }; + ce = ce.next; + }; + if (8 + ttotal > slot_sz) { + let m2: str = "cgwidentaggedstore: tuple-in-union payload needs SysV eightbyte packing (narrow elements share an eightbyte; see #242 follow-up)\n"; + os.write(2, m2.ptr, m2.len: u64); + os.exit(1); + }; + emitline("\tXORQ\tAX, AX\n"); + let tzk: i32 = 0; + for (tzk < slot_sz) { + emitline("\tMOVQ\tAX, "); + emitoff((slot_off + tzk): i64); + emitline("(BP)\n"); + tzk += 8; + }; + let tfoff: i32 = 0; + let te: *node = src.list; + for (te != nil) { + let isflt: bool = isfloattype(c, te); + let wide: bool = nodeisstr(c, te) || nodeisslice(c, te); + let esz: i32 = 8; + let eti: *tinfo = te.type_: *tinfo; + if (eti != nil) { esz = eti.size: i32; }; + cgexpr(c, te); + if (isflt) { + let mov: str = "MOVSD"; + if (isf32type(c, te)) { mov = "MOVSS"; }; + emitline("\t"); + emitline(mov); + emitline("\tX0, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + } else { if (wide) { + emitline("\tMOVQ\tAX, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + emitline("\tMOVQ\tBX, "); + emitoff((slot_off + 8 + tfoff + 8): i64); + emitline("(BP)\n"); + emitline("\tMOVQ\tCX, "); + emitoff((slot_off + 8 + tfoff + 16): i64); + emitline("(BP)\n"); + } else { + let sop: str = tnodestoreop(c, te, esz); + emitline("\t"); + emitline(sop); + emitline("\tAX, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + }; }; + if (wide) { tfoff += 24; } else { tfoff += 8; }; + te = te.next; + }; + emitline("\tMOVQ\t$"); + emitint(ttag: i64); + emitline(", "); + emitoff(slot_off: i64); + emitline("(BP)\n"); + return; + }; }; + }; }; // Struct payload (literal or ident). let sname: str = rhsstructpayload(c, src); if (sname.len > 0) { @@ -26477,7 +26611,13 @@ fn cgreturn(c: *cgen, n: *node) void = { // INTEGER cursor (ref/qbe/amd64/sysv.c retr L95-108). Both rows // loud-stop at their cap (rule-7): INTEGER 4, SSE 2. The SAME // class split drives the receive sites. - if (rhs.kind == nkind.N_TUPLE) { + // #242: a bare tuple return packs into the register cursor; a + // tuple WRAPPED IN A TAGGED UNION must instead pack into the + // union payload (tag + words) — fall through to the tagged path + // below, which routes it via cgwidentaggedstore. Without this + // guard the bare-tuple arm fired first and dropped the tag, + // returning (AX=word0, DX=word1) with no tag word. + if (rhs.kind == nkind.N_TUPLE && !istaggedtype(c, c.fnret)) { let ssecap: i32 = TUPLE_SSECAP; // X0,X1 per SysV let gptotal: i32 = 0; let ssecount: i32 = 0; @@ -26681,6 +26821,11 @@ fn cgreturn(c: *cgen, n: *node) void = { if (rhstaggedident(c, rhs) != nil) { needswiden = true; }; + // #242: a tuple variant packs into the union + // payload via cgwidentaggedstore's TY_TUPLE arm. + if (rhs.kind == nkind.N_TUPLE) { + needswiden = true; + }; }; }; if (needswiden) { @@ -28095,6 +28240,71 @@ fn cgmlet(c: *cgen, n: *node) void = { let sretrecv: i32 = 0; if (rhs.kind == nkind.N_CALL) { sretrecv = callsretsize(c, rhs); }; + // #242: rhs is a tuple already materialised in a local slot (a match- + // bound union payload, `let (a,b)=t`), NOT a register-returning call. + // cgexpr(tuple ident) loads only word0->AX, so the register cursor + // path below reads DX/CX stale. Copy each element from the ident's + // slot at the register-ABI 8B stride (24B for a slice/str header) — + // the SAME layout the tagged construct + match payload-bind write. + // Mirror of cstage cgen.c N_MLET tuple-ident arm. The binding element + // types ride l.lhs (stamped by the checker's stamptuplebinds). + if (rhs.kind == nkind.N_IDENT) { + let rl: *local = localfindnode(c, rhs.str); + if (rl != nil) { + let rti: *tinfo = rl.tnode.type_: *tinfo; + for (rti != nil && rti.kind == tykind.TY_NAMED) { rti = rti.under; }; + if (rti != nil) { if (rti.kind == tykind.TY_TUPLE) { + let srcoff: i32 = rl.off; + let foff: i32 = 0; + let lb: *node = n.list; + for (lb != nil) { + let tn: *node = lb.lhs; + let isflt: bool = isfloattype(c, tn); + let wide: bool = isstrtype(c, tn) || isslicetype(c, tn); + let esz: i32 = 8; + let eti: *tinfo = nil; + if (tn != nil) { eti = tn.type_: *tinfo; }; + if (eti != nil) { esz = eti.size: i32; }; + let bsz: i32 = 8; + if (wide) { bsz = tyslicesize(): i32; }; + let off: i32 = localadd(c, lb.str, bsz, tn); + if (isflt) { + let mov: str = "MOVSD"; + if (isf32type(c, tn)) { mov = "MOVSS"; }; + emitline("\t"); emitline(mov); emitline("\t"); + emitoff((srcoff + foff): i64); + emitline("(BP), X0\n"); + emitline("\t"); emitline(mov); emitline("\tX0, "); + emitoff(off: i64); emitline("(BP)\n"); + } else { if (wide) { + let k: i32 = 0; + for (k < esz) { + emitline("\tMOVQ\t"); + emitoff((srcoff + foff + k): i64); + emitline("(BP), AX\n"); + emitline("\tMOVQ\tAX, "); + emitoff((off + k): i64); + emitline("(BP)\n"); + k += 8; + }; + } else { + let lop: str = tnodeloadop(c, tn, esz); + let sop: str = tnodestoreop(c, tn, esz); + emitline("\t"); emitline(lop); emitline("\t"); + emitoff((srcoff + foff): i64); + emitline("(BP), AX\n"); + emitline("\t"); emitline(sop); emitline("\tAX, "); + emitoff(off: i64); emitline("(BP)\n"); + }; }; + if (wide) { foff += 24; } else { foff += 8; }; + lb = lb.next; + }; + c.lastwasreturn = 0; + return; + }; }; + }; + }; + cgexpr(c, rhs); if (sretrecv > 0) { diff --git a/selfhost/cmd/wcc/cgenstmt.ww b/selfhost/cmd/wcc/cgenstmt.ww index 295942cb..a5de811b 100644 --- a/selfhost/cmd/wcc/cgenstmt.ww +++ b/selfhost/cmd/wcc/cgenstmt.ww @@ -265,7 +265,13 @@ fn cgreturn(c: *cgen, n: *node) void = { // INTEGER cursor (ref/qbe/amd64/sysv.c retr L95-108). Both rows // loud-stop at their cap (rule-7): INTEGER 4, SSE 2. The SAME // class split drives the receive sites. - if (rhs.kind == nkind.N_TUPLE) { + // #242: a bare tuple return packs into the register cursor; a + // tuple WRAPPED IN A TAGGED UNION must instead pack into the + // union payload (tag + words) — fall through to the tagged path + // below, which routes it via cgwidentaggedstore. Without this + // guard the bare-tuple arm fired first and dropped the tag, + // returning (AX=word0, DX=word1) with no tag word. + if (rhs.kind == nkind.N_TUPLE && !istaggedtype(c, c.fnret)) { let ssecap: i32 = TUPLE_SSECAP; // X0,X1 per SysV let gptotal: i32 = 0; let ssecount: i32 = 0; @@ -469,6 +475,11 @@ fn cgreturn(c: *cgen, n: *node) void = { if (rhstaggedident(c, rhs) != nil) { needswiden = true; }; + // #242: a tuple variant packs into the union + // payload via cgwidentaggedstore's TY_TUPLE arm. + if (rhs.kind == nkind.N_TUPLE) { + needswiden = true; + }; }; }; if (needswiden) { @@ -1883,6 +1894,71 @@ fn cgmlet(c: *cgen, n: *node) void = { let sretrecv: i32 = 0; if (rhs.kind == nkind.N_CALL) { sretrecv = callsretsize(c, rhs); }; + // #242: rhs is a tuple already materialised in a local slot (a match- + // bound union payload, `let (a,b)=t`), NOT a register-returning call. + // cgexpr(tuple ident) loads only word0->AX, so the register cursor + // path below reads DX/CX stale. Copy each element from the ident's + // slot at the register-ABI 8B stride (24B for a slice/str header) — + // the SAME layout the tagged construct + match payload-bind write. + // Mirror of cstage cgen.c N_MLET tuple-ident arm. The binding element + // types ride l.lhs (stamped by the checker's stamptuplebinds). + if (rhs.kind == nkind.N_IDENT) { + let rl: *local = localfindnode(c, rhs.str); + if (rl != nil) { + let rti: *tinfo = rl.tnode.type_: *tinfo; + for (rti != nil && rti.kind == tykind.TY_NAMED) { rti = rti.under; }; + if (rti != nil) { if (rti.kind == tykind.TY_TUPLE) { + let srcoff: i32 = rl.off; + let foff: i32 = 0; + let lb: *node = n.list; + for (lb != nil) { + let tn: *node = lb.lhs; + let isflt: bool = isfloattype(c, tn); + let wide: bool = isstrtype(c, tn) || isslicetype(c, tn); + let esz: i32 = 8; + let eti: *tinfo = nil; + if (tn != nil) { eti = tn.type_: *tinfo; }; + if (eti != nil) { esz = eti.size: i32; }; + let bsz: i32 = 8; + if (wide) { bsz = tyslicesize(): i32; }; + let off: i32 = localadd(c, lb.str, bsz, tn); + if (isflt) { + let mov: str = "MOVSD"; + if (isf32type(c, tn)) { mov = "MOVSS"; }; + emitline("\t"); emitline(mov); emitline("\t"); + emitoff((srcoff + foff): i64); + emitline("(BP), X0\n"); + emitline("\t"); emitline(mov); emitline("\tX0, "); + emitoff(off: i64); emitline("(BP)\n"); + } else { if (wide) { + let k: i32 = 0; + for (k < esz) { + emitline("\tMOVQ\t"); + emitoff((srcoff + foff + k): i64); + emitline("(BP), AX\n"); + emitline("\tMOVQ\tAX, "); + emitoff((off + k): i64); + emitline("(BP)\n"); + k += 8; + }; + } else { + let lop: str = tnodeloadop(c, tn, esz); + let sop: str = tnodestoreop(c, tn, esz); + emitline("\t"); emitline(lop); emitline("\t"); + emitoff((srcoff + foff): i64); + emitline("(BP), AX\n"); + emitline("\t"); emitline(sop); emitline("\tAX, "); + emitoff(off: i64); emitline("(BP)\n"); + }; }; + if (wide) { foff += 24; } else { foff += 8; }; + lb = lb.next; + }; + c.lastwasreturn = 0; + return; + }; }; + }; + }; + cgexpr(c, rhs); if (sretrecv > 0) { diff --git a/selfhost/cmd/wcc/cgenutil.ww b/selfhost/cmd/wcc/cgenutil.ww index f70ed513..c683a622 100644 --- a/selfhost/cmd/wcc/cgenutil.ww +++ b/selfhost/cmd/wcc/cgenutil.ww @@ -2895,6 +2895,134 @@ fn cgwidentaggedstorebp(c: *cgen, dst: *tinfo, src: *node, slot_off: i32, slot_s }; return; }; + // #242: tuple payload. Each element rides ONE register-ABI + // eightbyte — scalar/float a single 8B word, a slice/str its 3-word + // {ptr,len,cap} header (24B) — matching the tagged-return load + // (AX=tag, DX=word0, CX=word1, R8=word2) and the cgmlet receive + // cursor. NOT the packed-by-size t.N field layout (#238). Mirror of + // cstage cg_widen_tagged_store's TY_TUPLE arm. + if (src != nil) { if (src.kind == nkind.N_TUPLE) { + let stu: *tinfo = src.type_: *tinfo; + for (stu != nil && stu.kind == tykind.TY_NAMED) { stu = stu.under; }; + if (stu != nil) { if (stu.kind == tykind.TY_TUPLE) { + // #242/#241: mirror cstage's loud-stop CONDITION, not its + // -1 mechanism (rule 10, align the RICHER side DOWN). + // wwstage types `true`/`false` as bool and a suffix-less `7` + // as untyped_int, so flatvariantidxt below DOES resolve the + // variant — but cstage's cg_tag_for_variant can't type a bare + // literal element (#241), returns -1, and loud-stops. A + // program cstage rejects, wwstage must also reject. The shape + // cstage can't type: a bool literal (N_TRUE/N_FALSE) or a + // suffix-less numeric literal (untyped_int/untyped_float). + // LIFT BOTH stage guards together when #241 fixes cstage + // literal typing -> symmetric accept. + let bl: *node = src.list; + for (bl != nil) { + let bare: bool = false; + if (bl.kind == nkind.N_TRUE) { bare = true; }; + if (bl.kind == nkind.N_FALSE) { bare = true; }; + if (bl.kind == nkind.N_INTLIT && bl.tsuffix.len == 0) { + bare = true; + }; + if (bl.kind == nkind.N_FLOATLIT && bl.tsuffix.len == 0) { + bare = true; + }; + if (bare) { + let ml: str = "cgwidentaggedstore: tuple-in-union variant tag unresolved (untyped/literal tuple element; see #242 / #241)\n"; + os.write(2, ml.ptr, ml.len: u64); + os.exit(1); + }; + bl = bl.next; + }; + // #242: resolve the variant tag via the typeeq core + // (flatvariantidxt) — NOT taggedvariantindext, whose + // str/slice shape fallback would silently pick tag 0 for an + // unmatched tuple, diverging from cstage cg_tag_for_variant + // (which returns -1) and masking the loud-stop below. + let ttag: i32 = flatvariantidxt(dt, src.type_: *tinfo); + // #242: an untyped/literal tuple element (`(true,7)`) leaves + // the src tuple un-matchable, so the variant tag can't + // resolve — the supported shape is a tuple of TYPED exprs + // (strconv parseint `(neg, n)`). Loud-stop rather than + // silently mis-tag (rule 7); #241 literal-init family. + if (ttag < 0) { + let m1: str = "cgwidentaggedstore: tuple-in-union variant tag unresolved (untyped/literal tuple element; see #242 / #241)\n"; + os.write(2, m1.ptr, m1.len: u64); + os.exit(1); + }; + // #242: this 8B-per-eightbyte packing is correct only when + // no two scalar elements share a SysV eightbyte — e.g. + // (bool,u64). A (i32,i32,u64) would overflow the union + // payload the slotted write assumes. Loud-stop (rule 7); + // SysV eightbyte tuple classification is a deferred + // follow-up. Symmetric with cstage cg_widen_tagged_store. + let ttotal: i32 = 0; + let ce: *node = src.list; + for (ce != nil) { + if (nodeisstr(c, ce) || nodeisslice(c, ce)) { + ttotal += 24; + } else { ttotal += 8; }; + ce = ce.next; + }; + if (8 + ttotal > slot_sz) { + let m2: str = "cgwidentaggedstore: tuple-in-union payload needs SysV eightbyte packing (narrow elements share an eightbyte; see #242 follow-up)\n"; + os.write(2, m2.ptr, m2.len: u64); + os.exit(1); + }; + emitline("\tXORQ\tAX, AX\n"); + let tzk: i32 = 0; + for (tzk < slot_sz) { + emitline("\tMOVQ\tAX, "); + emitoff((slot_off + tzk): i64); + emitline("(BP)\n"); + tzk += 8; + }; + let tfoff: i32 = 0; + let te: *node = src.list; + for (te != nil) { + let isflt: bool = isfloattype(c, te); + let wide: bool = nodeisstr(c, te) || nodeisslice(c, te); + let esz: i32 = 8; + let eti: *tinfo = te.type_: *tinfo; + if (eti != nil) { esz = eti.size: i32; }; + cgexpr(c, te); + if (isflt) { + let mov: str = "MOVSD"; + if (isf32type(c, te)) { mov = "MOVSS"; }; + emitline("\t"); + emitline(mov); + emitline("\tX0, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + } else { if (wide) { + emitline("\tMOVQ\tAX, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + emitline("\tMOVQ\tBX, "); + emitoff((slot_off + 8 + tfoff + 8): i64); + emitline("(BP)\n"); + emitline("\tMOVQ\tCX, "); + emitoff((slot_off + 8 + tfoff + 16): i64); + emitline("(BP)\n"); + } else { + let sop: str = tnodestoreop(c, te, esz); + emitline("\t"); + emitline(sop); + emitline("\tAX, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + }; }; + if (wide) { tfoff += 24; } else { tfoff += 8; }; + te = te.next; + }; + emitline("\tMOVQ\t$"); + emitint(ttag: i64); + emitline(", "); + emitoff(slot_off: i64); + emitline("(BP)\n"); + return; + }; }; + }; }; // Struct payload (literal or ident). let sname: str = rhsstructpayload(c, src); if (sname.len > 0) { diff --git a/selfhost/cmd/wcc/check.ww b/selfhost/cmd/wcc/check.ww index 46963096..48d1653d 100644 --- a/selfhost/cmd/wcc/check.ww +++ b/selfhost/cmd/wcc/check.ww @@ -471,14 +471,19 @@ fn resolvewalk(c: *checker, n: *node) void = { if (k == nkind.N_MLET) { if (n.rhs != nil) { resolvewalk(c, n.rhs); }; let pt: *node = nil; - if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) { + // #242: consume the rhs's tuple type for ANY rhs, not just an + // N_CALL — `let (a,b) = t` over a plain tuple ident (e.g. a + // match-bound union payload) must stamp its bindings too, or + // the un-annotated binder stays untyped and asserttyped aborts. + // Mirrors cstage check.c:2017 (cexpr(rhs), unconditional). + if (n.rhs != nil) { // `rt` would shadow the imported lib/rt module // (checkmoduleshadow errors); `rty` avoids it. let rty: *node = exprtype(c, n.rhs, nil); if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) { pt = rty.list; }; }; - }; }; + }; stamptuplebinds(c, n.list, pt, true, "let"); return; }; @@ -493,12 +498,13 @@ fn resolvewalk(c: *checker, n: *node) void = { if (k == nkind.N_MASSIGN) { if (n.rhs != nil) { resolvewalk(c, n.rhs); }; let pt: *node = nil; - if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) { + // #242: consume the rhs tuple type for ANY rhs (see N_MLET). + if (n.rhs != nil) { let rty: *node = exprtype(c, n.rhs, nil); if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) { pt = rty.list; }; }; - }; }; + }; let l: *node = n.list; for (l != nil) { resolvewalk(c, l); l = l.next; }; stamptuplebinds(c, n.list, pt, false, ""); diff --git a/selfhost/cmd/wwdump/main.combined.ww b/selfhost/cmd/wwdump/main.combined.ww index 771fcf19..bbc6a833 100644 --- a/selfhost/cmd/wwdump/main.combined.ww +++ b/selfhost/cmd/wwdump/main.combined.ww @@ -10721,14 +10721,19 @@ fn resolvewalk(c: *checker, n: *node) void = { if (k == nkind.N_MLET) { if (n.rhs != nil) { resolvewalk(c, n.rhs); }; let pt: *node = nil; - if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) { + // #242: consume the rhs's tuple type for ANY rhs, not just an + // N_CALL — `let (a,b) = t` over a plain tuple ident (e.g. a + // match-bound union payload) must stamp its bindings too, or + // the un-annotated binder stays untyped and asserttyped aborts. + // Mirrors cstage check.c:2017 (cexpr(rhs), unconditional). + if (n.rhs != nil) { // `rt` would shadow the imported lib/rt module // (checkmoduleshadow errors); `rty` avoids it. let rty: *node = exprtype(c, n.rhs, nil); if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) { pt = rty.list; }; }; - }; }; + }; stamptuplebinds(c, n.list, pt, true, "let"); return; }; @@ -10743,12 +10748,13 @@ fn resolvewalk(c: *checker, n: *node) void = { if (k == nkind.N_MASSIGN) { if (n.rhs != nil) { resolvewalk(c, n.rhs); }; let pt: *node = nil; - if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) { + // #242: consume the rhs tuple type for ANY rhs (see N_MLET). + if (n.rhs != nil) { let rty: *node = exprtype(c, n.rhs, nil); if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) { pt = rty.list; }; }; - }; }; + }; let l: *node = n.list; for (l != nil) { resolvewalk(c, l); l = l.next; }; stamptuplebinds(c, n.list, pt, false, ""); @@ -17993,6 +17999,134 @@ fn cgwidentaggedstorebp(c: *cgen, dst: *tinfo, src: *node, slot_off: i32, slot_s }; return; }; + // #242: tuple payload. Each element rides ONE register-ABI + // eightbyte — scalar/float a single 8B word, a slice/str its 3-word + // {ptr,len,cap} header (24B) — matching the tagged-return load + // (AX=tag, DX=word0, CX=word1, R8=word2) and the cgmlet receive + // cursor. NOT the packed-by-size t.N field layout (#238). Mirror of + // cstage cg_widen_tagged_store's TY_TUPLE arm. + if (src != nil) { if (src.kind == nkind.N_TUPLE) { + let stu: *tinfo = src.type_: *tinfo; + for (stu != nil && stu.kind == tykind.TY_NAMED) { stu = stu.under; }; + if (stu != nil) { if (stu.kind == tykind.TY_TUPLE) { + // #242/#241: mirror cstage's loud-stop CONDITION, not its + // -1 mechanism (rule 10, align the RICHER side DOWN). + // wwstage types `true`/`false` as bool and a suffix-less `7` + // as untyped_int, so flatvariantidxt below DOES resolve the + // variant — but cstage's cg_tag_for_variant can't type a bare + // literal element (#241), returns -1, and loud-stops. A + // program cstage rejects, wwstage must also reject. The shape + // cstage can't type: a bool literal (N_TRUE/N_FALSE) or a + // suffix-less numeric literal (untyped_int/untyped_float). + // LIFT BOTH stage guards together when #241 fixes cstage + // literal typing -> symmetric accept. + let bl: *node = src.list; + for (bl != nil) { + let bare: bool = false; + if (bl.kind == nkind.N_TRUE) { bare = true; }; + if (bl.kind == nkind.N_FALSE) { bare = true; }; + if (bl.kind == nkind.N_INTLIT && bl.tsuffix.len == 0) { + bare = true; + }; + if (bl.kind == nkind.N_FLOATLIT && bl.tsuffix.len == 0) { + bare = true; + }; + if (bare) { + let ml: str = "cgwidentaggedstore: tuple-in-union variant tag unresolved (untyped/literal tuple element; see #242 / #241)\n"; + os.write(2, ml.ptr, ml.len: u64); + os.exit(1); + }; + bl = bl.next; + }; + // #242: resolve the variant tag via the typeeq core + // (flatvariantidxt) — NOT taggedvariantindext, whose + // str/slice shape fallback would silently pick tag 0 for an + // unmatched tuple, diverging from cstage cg_tag_for_variant + // (which returns -1) and masking the loud-stop below. + let ttag: i32 = flatvariantidxt(dt, src.type_: *tinfo); + // #242: an untyped/literal tuple element (`(true,7)`) leaves + // the src tuple un-matchable, so the variant tag can't + // resolve — the supported shape is a tuple of TYPED exprs + // (strconv parseint `(neg, n)`). Loud-stop rather than + // silently mis-tag (rule 7); #241 literal-init family. + if (ttag < 0) { + let m1: str = "cgwidentaggedstore: tuple-in-union variant tag unresolved (untyped/literal tuple element; see #242 / #241)\n"; + os.write(2, m1.ptr, m1.len: u64); + os.exit(1); + }; + // #242: this 8B-per-eightbyte packing is correct only when + // no two scalar elements share a SysV eightbyte — e.g. + // (bool,u64). A (i32,i32,u64) would overflow the union + // payload the slotted write assumes. Loud-stop (rule 7); + // SysV eightbyte tuple classification is a deferred + // follow-up. Symmetric with cstage cg_widen_tagged_store. + let ttotal: i32 = 0; + let ce: *node = src.list; + for (ce != nil) { + if (nodeisstr(c, ce) || nodeisslice(c, ce)) { + ttotal += 24; + } else { ttotal += 8; }; + ce = ce.next; + }; + if (8 + ttotal > slot_sz) { + let m2: str = "cgwidentaggedstore: tuple-in-union payload needs SysV eightbyte packing (narrow elements share an eightbyte; see #242 follow-up)\n"; + os.write(2, m2.ptr, m2.len: u64); + os.exit(1); + }; + emitline("\tXORQ\tAX, AX\n"); + let tzk: i32 = 0; + for (tzk < slot_sz) { + emitline("\tMOVQ\tAX, "); + emitoff((slot_off + tzk): i64); + emitline("(BP)\n"); + tzk += 8; + }; + let tfoff: i32 = 0; + let te: *node = src.list; + for (te != nil) { + let isflt: bool = isfloattype(c, te); + let wide: bool = nodeisstr(c, te) || nodeisslice(c, te); + let esz: i32 = 8; + let eti: *tinfo = te.type_: *tinfo; + if (eti != nil) { esz = eti.size: i32; }; + cgexpr(c, te); + if (isflt) { + let mov: str = "MOVSD"; + if (isf32type(c, te)) { mov = "MOVSS"; }; + emitline("\t"); + emitline(mov); + emitline("\tX0, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + } else { if (wide) { + emitline("\tMOVQ\tAX, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + emitline("\tMOVQ\tBX, "); + emitoff((slot_off + 8 + tfoff + 8): i64); + emitline("(BP)\n"); + emitline("\tMOVQ\tCX, "); + emitoff((slot_off + 8 + tfoff + 16): i64); + emitline("(BP)\n"); + } else { + let sop: str = tnodestoreop(c, te, esz); + emitline("\t"); + emitline(sop); + emitline("\tAX, "); + emitoff((slot_off + 8 + tfoff): i64); + emitline("(BP)\n"); + }; }; + if (wide) { tfoff += 24; } else { tfoff += 8; }; + te = te.next; + }; + emitline("\tMOVQ\t$"); + emitint(ttag: i64); + emitline(", "); + emitoff(slot_off: i64); + emitline("(BP)\n"); + return; + }; }; + }; }; // Struct payload (literal or ident). let sname: str = rhsstructpayload(c, src); if (sname.len > 0) { @@ -26477,7 +26611,13 @@ fn cgreturn(c: *cgen, n: *node) void = { // INTEGER cursor (ref/qbe/amd64/sysv.c retr L95-108). Both rows // loud-stop at their cap (rule-7): INTEGER 4, SSE 2. The SAME // class split drives the receive sites. - if (rhs.kind == nkind.N_TUPLE) { + // #242: a bare tuple return packs into the register cursor; a + // tuple WRAPPED IN A TAGGED UNION must instead pack into the + // union payload (tag + words) — fall through to the tagged path + // below, which routes it via cgwidentaggedstore. Without this + // guard the bare-tuple arm fired first and dropped the tag, + // returning (AX=word0, DX=word1) with no tag word. + if (rhs.kind == nkind.N_TUPLE && !istaggedtype(c, c.fnret)) { let ssecap: i32 = TUPLE_SSECAP; // X0,X1 per SysV let gptotal: i32 = 0; let ssecount: i32 = 0; @@ -26681,6 +26821,11 @@ fn cgreturn(c: *cgen, n: *node) void = { if (rhstaggedident(c, rhs) != nil) { needswiden = true; }; + // #242: a tuple variant packs into the union + // payload via cgwidentaggedstore's TY_TUPLE arm. + if (rhs.kind == nkind.N_TUPLE) { + needswiden = true; + }; }; }; if (needswiden) { @@ -28095,6 +28240,71 @@ fn cgmlet(c: *cgen, n: *node) void = { let sretrecv: i32 = 0; if (rhs.kind == nkind.N_CALL) { sretrecv = callsretsize(c, rhs); }; + // #242: rhs is a tuple already materialised in a local slot (a match- + // bound union payload, `let (a,b)=t`), NOT a register-returning call. + // cgexpr(tuple ident) loads only word0->AX, so the register cursor + // path below reads DX/CX stale. Copy each element from the ident's + // slot at the register-ABI 8B stride (24B for a slice/str header) — + // the SAME layout the tagged construct + match payload-bind write. + // Mirror of cstage cgen.c N_MLET tuple-ident arm. The binding element + // types ride l.lhs (stamped by the checker's stamptuplebinds). + if (rhs.kind == nkind.N_IDENT) { + let rl: *local = localfindnode(c, rhs.str); + if (rl != nil) { + let rti: *tinfo = rl.tnode.type_: *tinfo; + for (rti != nil && rti.kind == tykind.TY_NAMED) { rti = rti.under; }; + if (rti != nil) { if (rti.kind == tykind.TY_TUPLE) { + let srcoff: i32 = rl.off; + let foff: i32 = 0; + let lb: *node = n.list; + for (lb != nil) { + let tn: *node = lb.lhs; + let isflt: bool = isfloattype(c, tn); + let wide: bool = isstrtype(c, tn) || isslicetype(c, tn); + let esz: i32 = 8; + let eti: *tinfo = nil; + if (tn != nil) { eti = tn.type_: *tinfo; }; + if (eti != nil) { esz = eti.size: i32; }; + let bsz: i32 = 8; + if (wide) { bsz = tyslicesize(): i32; }; + let off: i32 = localadd(c, lb.str, bsz, tn); + if (isflt) { + let mov: str = "MOVSD"; + if (isf32type(c, tn)) { mov = "MOVSS"; }; + emitline("\t"); emitline(mov); emitline("\t"); + emitoff((srcoff + foff): i64); + emitline("(BP), X0\n"); + emitline("\t"); emitline(mov); emitline("\tX0, "); + emitoff(off: i64); emitline("(BP)\n"); + } else { if (wide) { + let k: i32 = 0; + for (k < esz) { + emitline("\tMOVQ\t"); + emitoff((srcoff + foff + k): i64); + emitline("(BP), AX\n"); + emitline("\tMOVQ\tAX, "); + emitoff((off + k): i64); + emitline("(BP)\n"); + k += 8; + }; + } else { + let lop: str = tnodeloadop(c, tn, esz); + let sop: str = tnodestoreop(c, tn, esz); + emitline("\t"); emitline(lop); emitline("\t"); + emitoff((srcoff + foff): i64); + emitline("(BP), AX\n"); + emitline("\t"); emitline(sop); emitline("\tAX, "); + emitoff(off: i64); emitline("(BP)\n"); + }; }; + if (wide) { foff += 24; } else { foff += 8; }; + lb = lb.next; + }; + c.lastwasreturn = 0; + return; + }; }; + }; + }; + cgexpr(c, rhs); if (sretrecv > 0) { diff --git a/test/wcc/940_tuple_in_union_run.c b/test/wcc/940_tuple_in_union_run.c new file mode 100644 index 00000000..12a193ac --- /dev/null +++ b/test/wcc/940_tuple_in_union_run.c @@ -0,0 +1,337 @@ +/* + * 940_tuple_in_union_run — project #242: a mixed-scalar tuple WRAPPED IN A + * TAGGED UNION must construct, match-bind, and destructure IDENTICALLY in + * both stages and round-trip every element. BARE tuples already worked + * (#240/#83); only the union-wrapped variant was broken. + * + * Three SILENT, gate-blind (no bootstrap tuple-in-union) cs!=ww divergences + * met here, all on the `(neg, n)`-shape tuple Hare's strconv parseint returns + * (`((bool, u64) | invalid | overflow)`, stou.ha): + * + * (a) cstage CONSTRUCTION (cgen.c N_RETURN tagged arm): a tuple variant fell + * through the scalar shuffle, which ZEROED the whole value (MOVQ $0 to + * tag + payload) — the operands were never packed. Fix: route the tuple + * variant through the scratch-slot widen path (cg_widen_tagged_store's + * new TY_TUPLE arm), packing each element into the union payload + tag. + * + * (b) wwstage CHECKER (check.ww N_MLET): `let (a,b)=t` over a plain tuple + * ident (the match-bound union payload) left the un-annotated binders + * UNTYPED — the bin node reading them was untyped → asserttyped abort. + * The element-type distribution only fired for an N_CALL rhs. Fix: + * consume the rhs tuple type for ANY rhs (mirror cstage check.c:2017). + * + * (c) BOTH stages DESTRUCTURE (N_MLET / cgmlet): the register-cursor receive + * assumes the rhs left every element in AX/DX/CX (a call's tuple-return + * ABI). For a tuple IDENT cgexpr loads only word0->AX, so the 2nd binder + * read a STALE DX. Fix: copy each element from the ident's slot at the + * register-ABI 8B stride. + * + * Construction is correct at ANY variant position (the variant tag, not a + * default-0) — `tuple_tag1` and `tuple_after_int` place the tuple at index 1. + * + * SCOPE (rule 7 loud-stops, PINNED by the K_BUILDERR rows): a tuple built + * from a BARE LITERAL element (cstage mis-types `true`/`false`/untyped `7` → + * tag unresolved, #241 literal-init family; wwstage types them but mirrors + * cstage's CONDITION down per rule 10) and a tuple whose narrow elements + * SHARE a SysV eightbyte (e.g. (i32,i32,u64), needs eightbyte classification, + * #243) both loud-stop in cgen on BOTH stages rather than silently + * miscompile. The K_RUN rows build their tuple from TYPED expressions — the + * supported, byte-identical shape. + * + * K_RUN rows: build+run exit 0 on BOTH drivers AND cs==ww byte-identical. + * K_BUILDERR rows: build FAILS with the #242 diagnostic on BOTH drivers. + * NNN<950, self-contained (/tmp, no imports), so rule-14's selfhost-sibling + * race does not apply (903/940/945 precedent). + */ +#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; +} + +static int +slurp_eq(const char *a, const char *b) +{ + FILE *fa = fopen(a, "rb"); + FILE *fb = fopen(b, "rb"); + if (!fa || !fb) { if (fa) fclose(fa); if (fb) fclose(fb); return -1; } + int rc = 0; + for (;;) { + int ca = fgetc(fa), cb = fgetc(fb); + if (ca != cb) { rc = -1; break; } + if (ca == EOF) break; + } + fclose(fa); fclose(fb); + return rc; +} + +static int +file_contains(const char *path, const char *needle) +{ + FILE *f = fopen(path, "rb"); + if (!f) return 0; + char buf[8192]; + size_t n = fread(buf, 1, sizeof buf - 1, f); + fclose(f); + buf[n] = '\0'; + return strstr(buf, needle) != NULL; +} + +#define K_RUN 0 /* build+run both drivers, exit==want, + cs==ww byte-id */ +#define K_BUILDERR 1 /* build must FAIL with experr on BOTH drivers (rule 7) */ + +struct row { const char *label; const char *src; int kind; int want; + const char *experr; }; + +static const struct row rows[] = { + /* canonical #242 case: (bool,u64) at variant 0, match-bind + + * destructure, both elements checked. */ + { "bool_u64", + "package main;\n" + "fn mku(x: u64, s: bool) ((bool, u64) | void) = { return (s, x); };\n" + "export fn main() i32 = {\n" + " match (mku(7u64, true)) {\n" + " case let t: (bool, u64) => {\n" + " let (sg, u) = t;\n" + " if (u != 7u64) { return 1; };\n" + " if (!sg) { return 2; };\n" + " return 0;\n" + " };\n" + " case void => { return 3; };\n" + " };\n" + " return 4;\n" + "};\n", K_RUN, 0, NULL }, + /* the void variant: bare `return;` packs the void tag, the match + * takes the void arm. The tuple branch still compiles (typed vars). */ + { "void_arm", + "package main;\n" + "fn mku(ok: bool, x: u64, s: bool) ((bool, u64) | void) = {\n" + " if (ok) { return (s, x); };\n" + " return;\n" + "};\n" + "export fn main() i32 = {\n" + " match (mku(false, 1u64, true)) {\n" + " case let t: (bool, u64) => { return 1; };\n" + " case void => { return 0; };\n" + " };\n" + " return 2;\n" + "};\n", K_RUN, 0, NULL }, + /* tuple at variant 1 (`(void | (bool,u64))`): the construct must emit + * tag 1, not a default 0 — and the match must dispatch to it. */ + { "tuple_tag1", + "package main;\n" + "fn mku(x: u64, s: bool) (void | (bool, u64)) = { return (s, x); };\n" + "export fn main() i32 = {\n" + " match (mku(9u64, true)) {\n" + " case void => { return 50; };\n" + " case let t: (bool, u64) => {\n" + " let (sg, u) = t;\n" + " if (u != 9u64) { return 1; };\n" + " if (!sg) { return 2; };\n" + " return 0;\n" + " };\n" + " };\n" + " return 4;\n" + "};\n", K_RUN, 0, NULL }, + /* tuple variant 1 of `(int | (bool,u64))`, selected at runtime, built + * from typed locals (the parseint shape: an int-or-tuple result). */ + { "tuple_after_int", + "package main;\n" + "fn mk(which: bool) (int | (bool, u64)) = {\n" + " let s: bool = true;\n" + " let v: u64 = 88u64;\n" + " if (which) { return (s, v); };\n" + " return 5;\n" + "};\n" + "export fn main() i32 = {\n" + " match (mk(true)) {\n" + " case let n: int => { return 1; };\n" + " case let t: (bool, u64) => {\n" + " let (sg, u) = t;\n" + " if (u != 88u64) { return 2; };\n" + " if (!sg) { return 3; };\n" + " return 0;\n" + " };\n" + " };\n" + " return 4;\n" + "};\n", K_RUN, 0, NULL }, + /* rule-7 loud-stop (i): a tuple whose narrow elements SHARE a SysV + * eightbyte ((i32,i32,u64) — i32@0,i32@4,u64@8 packs to 16B, but the + * 8B-slotted write needs 24B) overflows the union payload. Both stages + * MUST loud-stop (eightbyte classification is the #243 follow-up), not + * silently miscompile. Typed params -> the tag resolves; the SIZE guard + * fires. */ + { "eightbyte_share", + "package main;\n" + "fn f(a: i32, b: i32, c: u64) ((i32, i32, u64) | void) = {\n" + " return (a, b, c);\n" + "};\n" + "export fn main() i32 = { return 0; };\n", + K_BUILDERR, 0, "needs SysV eightbyte packing" }, + /* rule-7 loud-stop (ii): a tuple built from a BARE LITERAL element + * (`true`). cstage's cg_tag_for_variant can't type the literal (#241) + * so it returns -1 and loud-stops; wwstage types `true` as bool and + * WOULD resolve the tag, so it mirrors cstage's CONDITION with an + * explicit bare-literal guard (rule 10 — align the richer side DOWN). + * Both stages MUST loud-stop with the SAME diagnostic. Lift both guards + * together when #241 lands cstage literal typing. */ + { "bool_literal", + "package main;\n" + "fn f(x: u64) ((bool, u64) | void) = { return (true, x); };\n" + "export fn main() i32 = { return 0; };\n", + K_BUILDERR, 0, "variant tag unresolved (untyped/literal tuple element" }, +}; + +/* build+run via a driver (ww / ww_ww); returns 0 pass, nonzero fail. */ +static int +run_driver(const char *driver, const struct row *r, int i) +{ + char src[96], tmpdir[96], errf[96], cmd[1024]; + snprintf(src, sizeof src, "/tmp/tiu_%d_%d.ww", getpid(), i); + snprintf(tmpdir, sizeof tmpdir, "/tmp/tiu_%d_d_%d", getpid(), i); + snprintf(errf, sizeof errf, "/tmp/tiu_%d_e_%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 >/dev/null 2>%s", + tmpdir, driver, src, errf); + int brc = runwait(cmd); + + if (r->kind == K_BUILDERR) { + int ok = (brc != 0) + && (r->experr == NULL || file_contains(errf, r->experr)); + if (!ok) + fprintf(stderr, "row[%s]: %s expected loud #242 builderr " + "(brc=%d)\n", r->label, driver, brc); + unlink(src); unlink(errf); rmdir(tmpdir); + return ok ? 0 : 1; + } + + if (brc != 0) { + fprintf(stderr, "row[%s]: build via %s failed\n", + r->label, driver); + unlink(src); unlink(errf); rmdir(tmpdir); + return -1; + } + + const char *base = strrchr(src, '/'); + base = base ? base + 1 : src; + char outbin[256]; + 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); unlink(errf); rmdir(tmpdir); + if (got != r->want) { + fprintf(stderr, "row[%s]: %s exit %d, want %d\n", + r->label, driver, got, r->want); + return 1; + } + return 0; +} + +/* cs==ww .s byte-id (rule 10). */ +static int +byteid(const char *w6c, const char *w6c_ww, const struct row *r, int i) +{ + char src[96], cs_s[96], ws_s[96], cmd[1024]; + snprintf(src, sizeof src, "/tmp/tiu_bi_%d_%d.ww", getpid(), i); + snprintf(cs_s, sizeof cs_s, "/tmp/tiu_bi_%d_%d_cs.s", getpid(), i); + snprintf(ws_s, sizeof ws_s, "/tmp/tiu_bi_%d_%d_ww.s", getpid(), i); + + FILE *f = fopen(src, "wb"); + if (!f) return -1; + fputs(r->src, f); + fclose(f); + + int rc = 0; + snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", w6c, cs_s, src); + if (runwait(cmd) != 0) { fprintf(stderr, "row[%s]: w6c failed\n", r->label); rc = 1; } + else { + snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", w6c_ww, ws_s, src); + if (runwait(cmd) != 0) { fprintf(stderr, "row[%s]: w6c_ww failed\n", r->label); rc = 1; } + else if (slurp_eq(cs_s, ws_s) != 0) { + fprintf(stderr, "row[%s]: cstage/wwstage .s DIFFER " + "(#242 tuple-in-union construct/destructure regression)\n", + r->label); + rc = 1; + } + } + unlink(src); unlink(cs_s); unlink(ws_s); + return rc; +} + +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 cdrv[640], wdrv[640], w6c[640], w6c_ww[640]; + snprintf(cdrv, sizeof cdrv, "%s/ww", bin); + snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin); + snprintf(w6c, sizeof w6c, "%s/w6c", bin); + snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin); + + struct { const char *name; const char *path; int gated; } + 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 && access(drivers[d].path, X_OK) != 0) { + fprintf(stderr, "tuple_in_union: skip %s (no %s)\n", + drivers[d].name, drivers[d].path); + continue; + } + for (int i = 0; i < n; i++) { + total++; + if (run_driver(drivers[d].path, &rows[i], i) != 0) fail++; + } + } + + /* cs==ww byte-id for the K_RUN rows only; a K_BUILDERR row emits no + * .s on either stage (both loud-stop), so byte-id does not apply. */ + if (access(w6c_ww, X_OK) == 0) { + for (int i = 0; i < n; i++) { + if (rows[i].kind != K_RUN) continue; + total++; + if (byteid(w6c, w6c_ww, &rows[i], i) != 0) fail++; + } + } + + if (fail) { + fprintf(stderr, "tuple_in_union: %d/%d checks failed\n", + fail, total); + return 1; + } + printf("tuple_in_union: %d/%d ok\n", total, total); + return 0; +}