Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

w6c+wwstage: cgexpr materializes tuple rvalues + unwrap-shift for tuple-payload destructure (#241)

Browse Source 
cgexpr could not produce a tuple VALUE, so a destructure / let bind of an
RVALUE tuple read garbage past the first element (cstage) or left an untyped
binder aborting wwstage's asserttyped gate — a DANGEROUS gate-blind cs!=ww,
and the strconv-int blocker (Hare's stoi64/stou64 require
`let (sign, u) = parseint(s, base)?`). Three feeders, all routed at the same
SysV register-return cursor the cgmlet/cgmassign consumers already read:

  - an N_TUPLE literal fell to the `cgexpr_int(0)` / `MOVQ $0, AX` default;
  - a tuple-typed IDENT loaded only word0 into AX (`yield t`, `return t`,
    `let q = t`), leaving DX/CX stale;
  - the `?`/`!` unwrap of a tuple-in-union payload lifted only word0->AX,
    stranding word1 in CX (the scalar/str success ABI).

Fix (both stages, byte-identical per rule 10):

  - cgexpr packs an N_TUPLE literal into the cursor (cg_tuple_lit_to_cursor /
    cgtuplelittocursor — a byte-identical reuse of cgreturn's in-register
    N_TUPLE arm) and a tuple IDENT from its slot at the register-ABI stride
    (cg_tuple_slot_to_cursor / cgtupleslottocursor);
  - the ?/! unwrap shifts a tuple success payload down one integer reg past
    the tag (cg_tagged_tuple_payload_shift / cgtaggedtuplepayloadshift),
    loud-stopping a float/slice/str payload element (the SysV per-eightbyte
    tagged-tuple-payload classification is #243);
  - wwstage's checker recovers the popped match-arm binder type for a
    `yield <binder>` operand (matchyieldtype's scope-free fallback to the
    arm's declared type), so the destructured binders stamp — cstage reads
    the operand's already-stamped ->type, wwstage caches only a tinfo.

Over-cap rvalue-tuple materialisation (no slot to sret a bare expression
value into) loud-stops both stages — the #10 follow-up.

NOT closed (distinct root, deferred to #238/task #6): single-var
`let q = (true, 9u64)` then `q.N` — the N_LET tuple-init sz==16||32 gate
drops a narrow-first mixed tuple, and the N_DOT tuple-field PACKED-offset
reader disagrees with tuple_store's 8B stride. Not the rvalue-into-cursor
fix and not a strconv blocker (strconv destructures); documented at the test
header.

Test 945_rvalue_tuple_destructure_run: literal destructure, match-yield
destructure, and the ?-call strconv shape, each run + cs==ww byte-id on both
drivers (9 checks). Embedded w6c/wwdump combined.ww regenerated.
This commit is contained in:
Hojun-Cho
2026-06-01 21:27:49 +09:00
parent 6fc85f9aaf
commit 5d023c0ef0
8 changed files with 1229 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Makefile
View File

@@ -289,6 +289,7 @@ TESTS = $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \
$(BIN)/test_subslice_ptresz_run \
$(BIN)/test_deref_slice_store_run \
$(BIN)/test_tuple_nary_destructure_run \
$(BIN)/test_rvalue_tuple_destructure_run \
$(BIN)/test_overcap_tuple_field_store_run \
$(BIN)/test_mixed_scalar_tuple_sret_run \
$(BIN)/test_tuple_in_union_run \
@@ -1164,6 +1165,14 @@ $(BIN)/test_tuple_nary_destructure_run: test/wcc/945_tuple_nary_destructure_run.
$(LIB)/libwwrt.a | $(BIN)
$(CC) $(CFLAGS) -o $@ $<
# #241: materialise an RVALUE tuple (literal / match-yield / ?-call payload)
# into the register cursor before a destructure (run + cs==ww byte-id).
$(BIN)/test_rvalue_tuple_destructure_run: test/wcc/945_rvalue_tuple_destructure_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 $@ $<
# #234: over-cap tuple sret store into a local struct field / indexed local
# (run + cs==ww byte-id), deferred forms loud-stop (builderr both drivers).
$(BIN)/test_overcap_tuple_field_store_run: test/wcc/940_overcap_tuple_field_store_run.c \

191
cmd/w6c/cgen.c
View File

@@ -2568,6 +2568,163 @@ cg_structlit_fill_bp(Cg *c, Local **locals_p, Type *lu, Node *lit, int bp_off)
cg_structlit_fill(c, locals_p, lu, lit, DST_BP, 0, NULL, bp_off);
}
/* cg_tuple_lit_to_cursor — #241: materialise an N_TUPLE literal's elements
* into the SysV register-return cursor — integer words L→R over tuple_rseq
* (AX,DX,CX,R8), floats over tuple_sse_seq (X0,X1), a slice/str's
* {ptr,len,cap} header over three consecutive INTEGER regs — the SAME ABI a
* tuple-returning CALL leaves, which every tuple consumer (tuple_store at
* the N_LET/N_MLET sites) already reads. cgexpr otherwise can't make a tuple
* value (the default arm zeroed AX), so a literal/yield rvalue tuple bound
* or destructured read garbage past word0. Each element's cgexpr clobbers
* AX/X0, so integer words spill L→R and pop into the cursor reversed, floats
* spill to @tupfscr and reload by SSE index — INDEPENDENT counters (ref/qbe/
* amd64/sysv.c retr). Byte-identical extraction of cgreturn's N_TUPLE arm,
* now shared with cgexpr. Over-cap loud-stops (rule 7); a bare expression
* value can't sret, so the >cap rvalue-tuple materialisation is the #10
* follow-up. */
static void
cg_tuple_lit_to_cursor(Cg *c, Local **locals, Node *tuple)
{
int f32;
int gptotal = 0, ssecount = 0;
for (Node *e = tuple->list; e; e = e->next) {
if (fld_isfloat(e->type, &f32))
ssecount++;
else
gptotal += tuple_ebytes(node_isstr(e)
|| node_isslice(e));
}
if (gptotal > TUPLE_GPCAP || ssecount > TUPLE_SSECAP)
fatal("tuple literal exceeds register-return ABI capacity "
"(integer %d/%d, SSE %d/%d); over-cap rvalue-tuple "
"materialisation is the #10 sret follow-up",
gptotal, TUPLE_GPCAP, ssecount, TUPLE_SSECAP);
int fscr = 0;
if (ssecount > 0) {
if (cg_tupfscr != 0)
fscr = cg_tupfscr;
else {
fscr = local_alloc(c, locals, "@tupfscr",
TUPLE_SSECAP * 8, cg_frame);
cg_tupfscr = fscr;
}
}
int sseidx = 0;
for (Node *e = tuple->list; e; e = e->next) {
int isflt = fld_isfloat(e->type, &f32);
cgexpr(c, e, *locals);
if (isflt) {
ins2(c, f32 ? A_MOVSS : A_MOVSD, areg(D_X0),
amem(D_BP, fscr + sseidx * 8));
sseidx++;
continue;
}
ins1(c, A_PUSHQ, areg(D_AX));
if (node_isstr(e) || node_isslice(e)) {
ins1(c, A_PUSHQ, areg(D_BX));
ins1(c, A_PUSHQ, areg(D_CX));
}
}
for (int i = gptotal - 1; i >= 0; i--)
ins1(c, A_POPQ, areg(tuple_rseq[i]));
int j = 0;
for (Node *e = tuple->list; e; e = e->next) {
if (!fld_isfloat(e->type, &f32))
continue;
ins2(c, f32 ? A_MOVSS : A_MOVSD,
amem(D_BP, fscr + j * 8),
areg(tuple_sse_seq[j]));
j++;
}
}
/* cg_tuple_slot_to_cursor — #241: load a tuple already materialised in a
* BP-relative slot (a tuple-typed IDENT: a let-bound tuple, a match-bound
* union payload) into the SAME register-return cursor. The slot uses the
* register-ABI stride the tuple-init / #242 destructure write (a scalar 8B,
* a slice/str its 3-word header), NOT the packed t.N field layout (#238).
* All sources are memory, so each word loads straight into its cursor reg —
* no spill dance (unlike the literal arm whose element cgexpr clobbers). So
* `yield t` / `return t` / `let q = t` over a tuple ident leave the whole
* tuple in the cursor, not just word0 in AX. Over-cap loud-stops (rule 7;
* the #10 sret follow-up). */
static void
cg_tuple_slot_to_cursor(Cg *c, int srcoff, Type *tu)
{
int f32;
int gptotal = 0, ssecount = 0;
for (Tparam *p = tu->params; p; p = p->next) {
Type *pu = type_chase_named(p->type);
int wide = pu && (pu->kind == TY_SLICE || pu->kind == TY_STR);
if (fld_isfloat(p->type, &f32))
ssecount++;
else
gptotal += tuple_ebytes(wide);
}
if (gptotal > TUPLE_GPCAP || ssecount > TUPLE_SSECAP)
fatal("tuple ident exceeds register-return ABI capacity "
"(integer %d/%d, SSE %d/%d); over-cap rvalue-tuple "
"materialisation is the #10 sret follow-up",
gptotal, TUPLE_GPCAP, ssecount, TUPLE_SSECAP);
int gp = 0, sse = 0, foff = 0;
for (Tparam *p = tu->params; p; p = p->next) {
Type *pu = type_chase_named(p->type);
int wide = pu && (pu->kind == TY_SLICE || pu->kind == TY_STR);
int isflt = fld_isfloat(p->type, &f32);
if (isflt) {
ins2(c, f32 ? A_MOVSS : A_MOVSD,
amem(D_BP, srcoff + foff),
areg(tuple_sse_seq[sse]));
sse++;
foff += 8;
} else if (wide) {
for (int k = 0; k < 3; k++)
ins2(c, A_MOVQ,
amem(D_BP, srcoff + foff + k * 8),
areg(tuple_rseq[gp + k]));
gp += 3;
foff += (int)pu->size;
} else {
ins2(c, A_MOVQ, amem(D_BP, srcoff + foff),
areg(tuple_rseq[gp]));
gp += 1;
foff += 8;
}
}
}
/* cg_tagged_tuple_payload_shift — #241: a `?`-unwrapped tuple payload is an
* rvalue tuple that must fill the register cursor the let/destructure
* consumer reads. A tagged return leaves AX=tag, DX=word0, CX=word1,
* R8=word2; the scalar/str unwrap lifts only word0->AX, stranding word1+ in
* CX/R8. Shift the whole payload DOWN one INTEGER reg so element i lands in
* tuple_rseq[i]. A float/slice/str payload element rides a different SysV
* class (X regs / 3-word header) the flat down-shift can't place — loud-stop
* (rule 7); the per-eightbyte tagged-tuple-payload classification is the
* #243 follow-up. */
static void
cg_tagged_tuple_payload_shift(Cg *c, Type *tup)
{
static const int seq[] = { D_AX, D_DX, D_CX, D_R8 };
int f32;
int words = 0;
for (Tparam *p = tup->params; p; p = p->next) {
Type *pu = type_chase_named(p->type);
int wide = pu && (pu->kind == TY_SLICE || pu->kind == TY_STR);
if (fld_isfloat(p->type, &f32) || wide)
fatal("tuple-in-union ? unwrap: float/slice/str payload "
"element needs SysV per-eightbyte classification "
"(see #243); only integer tuple payloads supported");
words += tuple_ebytes(0);
}
/* tag occupies AX, so only DX/CX/R8 carry payload words. */
if (words > (int)nelem(seq) - 1)
fatal("tuple-in-union ? unwrap payload exceeds the 3 integer "
"return regs past the tag (%d words); see #10/#243", words);
for (int i = 0; i < words; i++)
ins2(c, A_MOVQ, areg(seq[i + 1]), areg(seq[i]));
}
static void
cgexpr(Cg *c, Node *n, Local *locals)
{
@@ -2612,7 +2769,13 @@ cgexpr(Cg *c, Node *n, Local *locals)
case N_IDENT: {
int off = localfind(locals, n->str);
if (off != 0) {
if (node_isfloat(n)) {
Type *itu = type_chase_named(n->type);
if (itu && itu->kind == TY_TUPLE) {
/* #241: a tuple ident is a value — leave the whole
* tuple in the register cursor (`yield t` / `return
* t` / `let q = t`), not just word0 in AX. */
cg_tuple_slot_to_cursor(c, off, itu);
} else if (node_isfloat(n)) {
int op = op_for(n, A_MOVSD, A_MOVSS);
ins2(c, op, amem(D_BP, off), areg(D_X0));
} else if (node_isstr(n)) {
@@ -6635,6 +6798,16 @@ cgexpr(Cg *c, Node *n, Local *locals)
ins1(c, A_POPQ, areg(D_BP));
ins0(c, A_RET);
label(c, cont);
{
/* #241: a tuple success payload is an rvalue tuple — fill
* the cursor (shift past the tag) so the destructure /
* let consumer reads every element, not just word0. */
Type *stu = type_chase_named(succ_t);
if (stu && stu->kind == TY_TUPLE) {
cg_tagged_tuple_payload_shift(c, stu);
break;
}
}
if (success_is_str) {
/* str IS []u8: success value arrives in the tagged
* ABI as DX=ptr, CX=len, R8=cap (slot 32B). Move len
@@ -6677,6 +6850,15 @@ cgexpr(Cg *c, Node *n, Local *locals)
ins2(c, A_MOVQ, aimm(60), areg(D_AX));
ins0(c, A_SYSCALL);
label(c, cont);
{
/* #241: tuple success payload fills the cursor (shift past
* the tag) — same rvalue-tuple-into-cursor story. */
Type *stu = type_chase_named(succ_t);
if (stu && stu->kind == TY_TUPLE) {
cg_tagged_tuple_payload_shift(c, stu);
break;
}
}
if (success_is_str) {
/* str IS []u8: success arrives DX=ptr, CX=len, R8=cap
* (slot 32B). Move len out before cap clobbers CX
@@ -7965,6 +8147,13 @@ cgexpr(Cg *c, Node *n, Local *locals)
}
break;
}
case N_TUPLE:
/* #241: a literal tuple rvalue `(a, b)` is a value — pack its
* elements into the register cursor (mirror cgreturn's N_TUPLE
* arm) so a let-bind / destructure consumer reads every element,
* not just AX = 0 from the default arm below. */
cg_tuple_lit_to_cursor(c, &locals, n);
break;
default:
cgexpr_int(c, 0);
break;

270
selfhost/cmd/w6c/main.combined.ww
View File

@@ -11340,30 +11340,46 @@ fn astunsized(c: *checker, t: *node) bool = {
// descend into a nested N_MATCH — each match opens its own yield
// scope. exprtype is idempotent on already-stamped nodes (tinfocache
// path at L467) so re-entering it on the yield operand here is safe.
fn matchyieldtype(c: *checker, body: *node) *node = {
// bname/btype carry the enclosing arm's case-binding name + declared type
// node. #241: when exprtype can't re-derive a `yield <binder>` operand —
// the arm binder's scope is already popped by the time exprtype(N_MATCH)
// runs post-order (resolvewalk's N_MCASE restores c.cur before this), so
// scopelookup of the bare binder ident returns nil — the yielded type IS
// the binding type (btype). cstage avoids this by reading the operand's
// already-stamped ->type (check.c:122) rather than re-running cexpr; wwstage
// caches only node.type_ (a tinfo, not a type NODE), so this binder-typed
// fallback is the node-form recovery for the dominant match-bind-then-yield
// idiom (Hare's parseint `case let t => yield t`).
fn matchyieldtype(c: *checker, body: *node, bname: str, btype: *node) *node = {
if (body == nil) { return nil; };
let k: nkind = body.kind;
if (k == nkind.N_YIELD) {
if (body.lhs == nil) { return nil; };
return exprtype(c, body.lhs, nil);
let t: *node = exprtype(c, body.lhs, nil);
if (t != nil) { return t; };
if (body.lhs.kind == nkind.N_IDENT && bname.len > 0
&& streq(body.lhs.str, bname)) {
return btype;
};
return nil;
};
if (k == nkind.N_MATCH) { return nil; };
if (k == nkind.N_BLOCK) {
let s: *node = body.list;
for (s != nil) {
let t: *node = matchyieldtype(c, s);
let t: *node = matchyieldtype(c, s, bname, btype);
if (t != nil) { return t; };
s = s.next;
};
return nil;
};
if (k == nkind.N_IF) {
let t: *node = matchyieldtype(c, body.body);
let t: *node = matchyieldtype(c, body.body, bname, btype);
if (t != nil) { return t; };
return matchyieldtype(c, body.els);
return matchyieldtype(c, body.els, bname, btype);
};
if (k == nkind.N_FOR || k == nkind.N_FORRANGE) {
return matchyieldtype(c, body.body);
return matchyieldtype(c, body.body, bname, btype);
};
return nil;
};
@@ -13154,7 +13170,10 @@ fn exprtype(c: *checker, e: *node, hint: *node) *node = {
let yt: *node = nil;
let cs: *node = e.list;
for (cs != nil) {
let t: *node = matchyieldtype(c, cs.body);
// cs.str/cs.lhs = the arm's case-binding name + declared
// type (the N_MCASE binder); fed to matchyieldtype's #241
// scope-popped `yield <binder>` fallback.
let t: *node = matchyieldtype(c, cs.body, cs.str, cs.lhs);
if (t != nil) { yt = t; break; };
cs = cs.next;
};
@@ -19045,6 +19064,14 @@ fn cgexpr(c: *cgen, n: *node) void = {
if (k == nkind.N_TRYUNW) { cgtryunw(c, n); return; };
if (k == nkind.N_TYPETEST) { cgtypetest(c, n); return; };
if (k == nkind.N_TYPEASSERT) { cgtypeassert(c, n); return; };
if (k == nkind.N_TUPLE) {
// #241: a literal tuple rvalue `(a, b)` is a value — pack its
// elements into the register cursor (mirror cgreturn's N_TUPLE
// arm) so a let-bind / destructure consumer reads every element,
// not just AX = 0 from the default arm below.
cgtuplelittocursor(c, n);
return;
};
// Default fallback: produce a deterministic AX = 0. Mirrors
// the C cgen's `default: cgexpr_int(c, 0)` branch, which is
// what `return eof{};` (N_STRUCTLIT with an empty !void
@@ -19073,6 +19100,27 @@ fn cgtagvariantidx(c: *cgen, tagged: *node, vt: *node) i32 = {
return flatvariantidx(c, tagged, vt);
};
// cgtrytupleshift — #241: if the `?`/`!` operand's success variant (tag 0)
// is a tuple, the unwrapped payload is an rvalue tuple that must fill the
// register cursor (shift past the tag), and the scalar/str MOVQ DX,AX tail
// is skipped. Returns true when it emitted the shift. Reads the operand's
// stamped tagged result tinfo (n.lhs.type_) — the success variant is the
// first param, matching the `CMPQ $0` success-tag convention.
fn cgtrytupleshift(c: *cgen, n: *node) bool = {
if (n.lhs == nil) { return false; };
let ou: *tinfo = n.lhs.type_: *tinfo;
for (ou != nil && ou.kind == tykind.TY_NAMED) { ou = ou.under; };
if (ou == nil) { return false; };
if (ou.kind != tykind.TY_TAGGED) { return false; };
if (ou.params == nil) { return false; };
let sv: *tinfo = ou.params.type_;
for (sv != nil && sv.kind == tykind.TY_NAMED) { sv = sv.under; };
if (sv == nil) { return false; };
if (sv.kind != tykind.TY_TUPLE) { return false; };
cgtaggedtuplepayloadshift(c, sv);
return true;
};
// cgtryprop — `e?` propagates the error variant up the stack.
// Success tag = 0 (#216 tracks the legacy/flag-aware success-tag
// divergence — out of scope here, success check stays `CMPQ $0`).
@@ -19136,6 +19184,10 @@ fn cgtryprop(c: *cgen, n: *node) void = {
};
emitline("\tMOVQ\tBP, SP\n\tPOPQ\tBP\n\tRET\n");
emitlabel(cl);
// #241: a tuple success payload is an rvalue tuple — fill the cursor
// (shift past the tag) so the destructure / let consumer reads every
// element, not just word0. Success variant = tag 0 (first param).
if (cgtrytupleshift(c, n)) { return; };
// Success: unwrap value. Tag-only result was AX; the rest of
// the codegen expects the success value in AX (and BX for str).
// AX=tag, DX=val0, CX=val1 from the call ABI. For str success,
@@ -19199,6 +19251,9 @@ fn cgtryunw(c: *cgen, n: *node) void = {
emitline("\n");
emitline("\tMOVQ\t$1, DI\n\tMOVQ\t$60, AX\n\tSYSCALL\n");
emitlabel(cl);
// #241: tuple success payload fills the cursor (shift past the tag) —
// same rvalue-tuple-into-cursor story as cgtryprop.
if (cgtrytupleshift(c, n)) { return; };
// Unwrap success value. (Same shuffle pattern as cgtryprop.)
let succisstr: bool = false;
if (n.lhs != nil) {
@@ -19577,6 +19632,16 @@ fn cgident(c: *cgen, n: *node) void = {
let lc: *local = localfindnode(c, nm);
if (lc != nil) {
let off: i32 = lc.off;
// #241: a tuple ident is a value — leave the whole tuple in the
// register cursor (`yield t` / `return t` / `let q = t`), not
// just word0 in AX. Mirror of cstage cgexpr N_IDENT tuple arm.
let itu: *tinfo = nil;
if (lc.tnode != nil) { itu = lc.tnode.type_: *tinfo; };
for (itu != nil && itu.kind == tykind.TY_NAMED) { itu = itu.under; };
if (itu != nil) { if (itu.kind == tykind.TY_TUPLE) {
cgtupleslottocursor(c, off, itu);
return;
}; };
// Float local: MOVSS / MOVSD into X0. Skips the AX shuffle
// so consumers (cgbin, cgcast, return) pick up the SSE value
// directly.
@@ -26592,6 +26657,197 @@ fn tupstore(c: *cgen, gpcur: i32, ssecur: i32, off: i32, wide: bool, tn: *node)
emitline("(BP)\n");
};
// cgtuplelittocursor — #241: materialise an N_TUPLE literal's elements into
// the SysV register-return cursor (integer words L->R over tupreg AX/DX/CX/
// R8, floats over tupsse X0/X1, a slice/str's {ptr,len,cap} over three
// consecutive INTEGER regs) — the SAME ABI a tuple-returning call leaves,
// which every tuple consumer (tupstore at cgmlet/cgmassign) reads. cgexpr
// otherwise falls to its `MOVQ $0, AX` default for a tuple, so a literal
// rvalue tuple bound or destructured read garbage past word0. Byte-identical
// extraction of cgreturn's in-register N_TUPLE arm (cgenstmt.ww), now shared
// with cgexpr. Over-cap loud-stops (rule 7); a bare expression value can't
// sret, so the >cap rvalue-tuple materialisation is the #10 follow-up.
fn cgtuplelittocursor(c: *cgen, tuple: *node) void = {
let ssecap: i32 = TUPLE_SSECAP;
let gptotal: i32 = 0;
let ssecount: i32 = 0;
let e: *node = tuple.list;
for (e != nil) {
if (isfloattype(c, e)) {
ssecount = ssecount + 1;
} else {
let wide: bool = nodeisstr(c, e) || nodeisslice(c, e);
gptotal = gptotal + tupebytes(wide);
};
e = e.next;
};
if (gptotal > TUPLE_GPCAP || ssecount > ssecap) {
let msg: str = "tuple literal exceeds register-return ABI capacity (integer AX,DX,CX,R8 / SSE X0,X1); over-cap rvalue-tuple materialisation is the #10 sret follow-up\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let fscr: i32 = 0;
if (ssecount > 0) {
fscr = localadd(c, "@tupfscr", ssecap * 8, nil);
};
let sseidx: i32 = 0;
e = tuple.list;
for (e != nil) {
let isflt: bool = isfloattype(c, e);
cgexpr(c, e);
if (isflt) {
let mov: str = "MOVSD";
if (isf32type(c, e)) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\tX0, ");
emitoff((fscr + sseidx * 8): i64);
emitline("(BP)\n");
sseidx = sseidx + 1;
} else {
emitline("\tPUSHQ\tAX\n");
if (nodeisstr(c, e) || nodeisslice(c, e)) {
emitline("\tPUSHQ\tBX\n");
emitline("\tPUSHQ\tCX\n");
};
};
e = e.next;
};
let i: i32 = gptotal - 1;
for (i >= 0) {
emitline("\tPOPQ\t");
emitline(tupreg(i));
emitline("\n");
i = i - 1;
};
let j: i32 = 0;
e = tuple.list;
for (e != nil) {
if (isfloattype(c, e)) {
let mov: str = "MOVSD";
if (isf32type(c, e)) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\t");
emitoff((fscr + j * 8): i64);
emitline("(BP), ");
emitline(tupsse(j));
emitline("\n");
j = j + 1;
};
e = e.next;
};
};
// cgtupleslottocursor — #241: load a tuple already materialised in a BP-
// relative slot (a tuple-typed IDENT: a let-bound tuple, a match-bound union
// payload) into the SAME register cursor. The slot uses the register-ABI
// stride the tuple-init / #242 destructure write (a scalar 8B, a slice/str
// its 3-word header), NOT the packed t.N field layout (#238). All sources
// are memory, so each word loads straight into its cursor reg. So `yield t`
// / `return t` / `let q = t` over a tuple ident leave the whole tuple in the
// cursor, not just word0 in AX. Over-cap loud-stops (rule 7; #10). Mirror of
// cstage cg_tuple_slot_to_cursor.
fn cgtupleslottocursor(c: *cgen, srcoff: i32, tu: *tinfo) void = {
let gptotal: i32 = 0;
let ssecount: i32 = 0;
let el: *ttupleelem = tu.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
if (et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64)) {
ssecount = ssecount + 1;
} else {
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
gptotal = gptotal + tupebytes(wide);
};
el = el.tnext;
};
if (gptotal > TUPLE_GPCAP || ssecount > TUPLE_SSECAP) {
let msg: str = "tuple ident exceeds register-return ABI capacity (integer AX,DX,CX,R8 / SSE X0,X1); over-cap rvalue-tuple materialisation is the #10 sret follow-up\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let gp: i32 = 0;
let sse: i32 = 0;
let foff: i32 = 0;
el = tu.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
let isflt: bool = et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64);
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
if (isflt) {
let mov: str = "MOVSD";
if (et.kind == tykind.TY_F32) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\t");
emitoff((srcoff + foff): i64);
emitline("(BP), ");
emitline(tupsse(sse));
emitline("\n");
sse = sse + 1;
foff += 8;
} else { if (wide) {
let k: i32 = 0;
for (k < 3) {
emitline("\tMOVQ\t");
emitoff((srcoff + foff + k * 8): i64);
emitline("(BP), ");
emitline(tupreg(gp + k));
emitline("\n");
k += 1;
};
gp += 3;
foff += et.size: i32;
} else {
emitline("\tMOVQ\t");
emitoff((srcoff + foff): i64);
emitline("(BP), ");
emitline(tupreg(gp));
emitline("\n");
gp += 1;
foff += 8;
}; };
el = el.tnext;
};
};
// cgtaggedtuplepayloadshift — #241: a `?`-unwrapped tuple payload is an
// rvalue tuple that must fill the register cursor. The tagged return leaves
// AX=tag, DX=word0, CX=word1, R8=word2; the scalar/str unwrap lifts only
// word0->AX, stranding word1+ in CX/R8. Shift the whole payload DOWN one
// INTEGER reg so element i lands in tupreg(i). Float/slice/str payload
// elements ride a different SysV class — loud-stop (rule 7; the per-
// eightbyte tagged-tuple-payload classification is the #243 follow-up).
// Mirror of cstage cg_tagged_tuple_payload_shift.
fn cgtaggedtuplepayloadshift(c: *cgen, tup: *tinfo) void = {
let words: i32 = 0;
let el: *ttupleelem = tup.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
let isflt: bool = et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64);
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
if (isflt || wide) {
let msg: str = "tuple-in-union ? unwrap: float/slice/str payload element needs SysV per-eightbyte classification (see #243); only integer tuple payloads supported\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
words = words + 1;
el = el.tnext;
};
if (words > 3) {
let msg: str = "tuple-in-union ? unwrap payload exceeds the 3 integer return regs past the tag; see #10/#243\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let i: i32 = 0;
for (i < words) {
emitline("\tMOVQ\t");
emitline(tupreg(i + 1));
emitline(", ");
emitline(tupreg(i));
emitline("\n");
i = i + 1;
};
};
fn cgreturn(c: *cgen, n: *node) void = {
rundefers(c);
let rhs: *node = n.lhs;

46
selfhost/cmd/wcc/cgenexpr.ww
View File

@@ -127,6 +127,14 @@ fn cgexpr(c: *cgen, n: *node) void = {
if (k == nkind.N_TRYUNW) { cgtryunw(c, n); return; };
if (k == nkind.N_TYPETEST) { cgtypetest(c, n); return; };
if (k == nkind.N_TYPEASSERT) { cgtypeassert(c, n); return; };
if (k == nkind.N_TUPLE) {
// #241: a literal tuple rvalue `(a, b)` is a value — pack its
// elements into the register cursor (mirror cgreturn's N_TUPLE
// arm) so a let-bind / destructure consumer reads every element,
// not just AX = 0 from the default arm below.
cgtuplelittocursor(c, n);
return;
};
// Default fallback: produce a deterministic AX = 0. Mirrors
// the C cgen's `default: cgexpr_int(c, 0)` branch, which is
// what `return eof{};` (N_STRUCTLIT with an empty !void
@@ -155,6 +163,27 @@ fn cgtagvariantidx(c: *cgen, tagged: *node, vt: *node) i32 = {
return flatvariantidx(c, tagged, vt);
};
// cgtrytupleshift — #241: if the `?`/`!` operand's success variant (tag 0)
// is a tuple, the unwrapped payload is an rvalue tuple that must fill the
// register cursor (shift past the tag), and the scalar/str MOVQ DX,AX tail
// is skipped. Returns true when it emitted the shift. Reads the operand's
// stamped tagged result tinfo (n.lhs.type_) — the success variant is the
// first param, matching the `CMPQ $0` success-tag convention.
fn cgtrytupleshift(c: *cgen, n: *node) bool = {
if (n.lhs == nil) { return false; };
let ou: *tinfo = n.lhs.type_: *tinfo;
for (ou != nil && ou.kind == tykind.TY_NAMED) { ou = ou.under; };
if (ou == nil) { return false; };
if (ou.kind != tykind.TY_TAGGED) { return false; };
if (ou.params == nil) { return false; };
let sv: *tinfo = ou.params.type_;
for (sv != nil && sv.kind == tykind.TY_NAMED) { sv = sv.under; };
if (sv == nil) { return false; };
if (sv.kind != tykind.TY_TUPLE) { return false; };
cgtaggedtuplepayloadshift(c, sv);
return true;
};
// cgtryprop — `e?` propagates the error variant up the stack.
// Success tag = 0 (#216 tracks the legacy/flag-aware success-tag
// divergence — out of scope here, success check stays `CMPQ $0`).
@@ -218,6 +247,10 @@ fn cgtryprop(c: *cgen, n: *node) void = {
};
emitline("\tMOVQ\tBP, SP\n\tPOPQ\tBP\n\tRET\n");
emitlabel(cl);
// #241: a tuple success payload is an rvalue tuple — fill the cursor
// (shift past the tag) so the destructure / let consumer reads every
// element, not just word0. Success variant = tag 0 (first param).
if (cgtrytupleshift(c, n)) { return; };
// Success: unwrap value. Tag-only result was AX; the rest of
// the codegen expects the success value in AX (and BX for str).
// AX=tag, DX=val0, CX=val1 from the call ABI. For str success,
@@ -281,6 +314,9 @@ fn cgtryunw(c: *cgen, n: *node) void = {
emitline("\n");
emitline("\tMOVQ\t$1, DI\n\tMOVQ\t$60, AX\n\tSYSCALL\n");
emitlabel(cl);
// #241: tuple success payload fills the cursor (shift past the tag) —
// same rvalue-tuple-into-cursor story as cgtryprop.
if (cgtrytupleshift(c, n)) { return; };
// Unwrap success value. (Same shuffle pattern as cgtryprop.)
let succisstr: bool = false;
if (n.lhs != nil) {
@@ -659,6 +695,16 @@ fn cgident(c: *cgen, n: *node) void = {
let lc: *local = localfindnode(c, nm);
if (lc != nil) {
let off: i32 = lc.off;
// #241: a tuple ident is a value — leave the whole tuple in the
// register cursor (`yield t` / `return t` / `let q = t`), not
// just word0 in AX. Mirror of cstage cgexpr N_IDENT tuple arm.
let itu: *tinfo = nil;
if (lc.tnode != nil) { itu = lc.tnode.type_: *tinfo; };
for (itu != nil && itu.kind == tykind.TY_NAMED) { itu = itu.under; };
if (itu != nil) { if (itu.kind == tykind.TY_TUPLE) {
cgtupleslottocursor(c, off, itu);
return;
}; };
// Float local: MOVSS / MOVSD into X0. Skips the AX shuffle
// so consumers (cgbin, cgcast, return) pick up the SSE value
// directly.

191
selfhost/cmd/wcc/cgenstmt.ww
View File

@@ -246,6 +246,197 @@ fn tupstore(c: *cgen, gpcur: i32, ssecur: i32, off: i32, wide: bool, tn: *node)
emitline("(BP)\n");
};
// cgtuplelittocursor — #241: materialise an N_TUPLE literal's elements into
// the SysV register-return cursor (integer words L->R over tupreg AX/DX/CX/
// R8, floats over tupsse X0/X1, a slice/str's {ptr,len,cap} over three
// consecutive INTEGER regs) — the SAME ABI a tuple-returning call leaves,
// which every tuple consumer (tupstore at cgmlet/cgmassign) reads. cgexpr
// otherwise falls to its `MOVQ $0, AX` default for a tuple, so a literal
// rvalue tuple bound or destructured read garbage past word0. Byte-identical
// extraction of cgreturn's in-register N_TUPLE arm (cgenstmt.ww), now shared
// with cgexpr. Over-cap loud-stops (rule 7); a bare expression value can't
// sret, so the >cap rvalue-tuple materialisation is the #10 follow-up.
fn cgtuplelittocursor(c: *cgen, tuple: *node) void = {
let ssecap: i32 = TUPLE_SSECAP;
let gptotal: i32 = 0;
let ssecount: i32 = 0;
let e: *node = tuple.list;
for (e != nil) {
if (isfloattype(c, e)) {
ssecount = ssecount + 1;
} else {
let wide: bool = nodeisstr(c, e) || nodeisslice(c, e);
gptotal = gptotal + tupebytes(wide);
};
e = e.next;
};
if (gptotal > TUPLE_GPCAP || ssecount > ssecap) {
let msg: str = "tuple literal exceeds register-return ABI capacity (integer AX,DX,CX,R8 / SSE X0,X1); over-cap rvalue-tuple materialisation is the #10 sret follow-up\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let fscr: i32 = 0;
if (ssecount > 0) {
fscr = localadd(c, "@tupfscr", ssecap * 8, nil);
};
let sseidx: i32 = 0;
e = tuple.list;
for (e != nil) {
let isflt: bool = isfloattype(c, e);
cgexpr(c, e);
if (isflt) {
let mov: str = "MOVSD";
if (isf32type(c, e)) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\tX0, ");
emitoff((fscr + sseidx * 8): i64);
emitline("(BP)\n");
sseidx = sseidx + 1;
} else {
emitline("\tPUSHQ\tAX\n");
if (nodeisstr(c, e) || nodeisslice(c, e)) {
emitline("\tPUSHQ\tBX\n");
emitline("\tPUSHQ\tCX\n");
};
};
e = e.next;
};
let i: i32 = gptotal - 1;
for (i >= 0) {
emitline("\tPOPQ\t");
emitline(tupreg(i));
emitline("\n");
i = i - 1;
};
let j: i32 = 0;
e = tuple.list;
for (e != nil) {
if (isfloattype(c, e)) {
let mov: str = "MOVSD";
if (isf32type(c, e)) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\t");
emitoff((fscr + j * 8): i64);
emitline("(BP), ");
emitline(tupsse(j));
emitline("\n");
j = j + 1;
};
e = e.next;
};
};
// cgtupleslottocursor — #241: load a tuple already materialised in a BP-
// relative slot (a tuple-typed IDENT: a let-bound tuple, a match-bound union
// payload) into the SAME register cursor. The slot uses the register-ABI
// stride the tuple-init / #242 destructure write (a scalar 8B, a slice/str
// its 3-word header), NOT the packed t.N field layout (#238). All sources
// are memory, so each word loads straight into its cursor reg. So `yield t`
// / `return t` / `let q = t` over a tuple ident leave the whole tuple in the
// cursor, not just word0 in AX. Over-cap loud-stops (rule 7; #10). Mirror of
// cstage cg_tuple_slot_to_cursor.
fn cgtupleslottocursor(c: *cgen, srcoff: i32, tu: *tinfo) void = {
let gptotal: i32 = 0;
let ssecount: i32 = 0;
let el: *ttupleelem = tu.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
if (et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64)) {
ssecount = ssecount + 1;
} else {
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
gptotal = gptotal + tupebytes(wide);
};
el = el.tnext;
};
if (gptotal > TUPLE_GPCAP || ssecount > TUPLE_SSECAP) {
let msg: str = "tuple ident exceeds register-return ABI capacity (integer AX,DX,CX,R8 / SSE X0,X1); over-cap rvalue-tuple materialisation is the #10 sret follow-up\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let gp: i32 = 0;
let sse: i32 = 0;
let foff: i32 = 0;
el = tu.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
let isflt: bool = et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64);
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
if (isflt) {
let mov: str = "MOVSD";
if (et.kind == tykind.TY_F32) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\t");
emitoff((srcoff + foff): i64);
emitline("(BP), ");
emitline(tupsse(sse));
emitline("\n");
sse = sse + 1;
foff += 8;
} else { if (wide) {
let k: i32 = 0;
for (k < 3) {
emitline("\tMOVQ\t");
emitoff((srcoff + foff + k * 8): i64);
emitline("(BP), ");
emitline(tupreg(gp + k));
emitline("\n");
k += 1;
};
gp += 3;
foff += et.size: i32;
} else {
emitline("\tMOVQ\t");
emitoff((srcoff + foff): i64);
emitline("(BP), ");
emitline(tupreg(gp));
emitline("\n");
gp += 1;
foff += 8;
}; };
el = el.tnext;
};
};
// cgtaggedtuplepayloadshift — #241: a `?`-unwrapped tuple payload is an
// rvalue tuple that must fill the register cursor. The tagged return leaves
// AX=tag, DX=word0, CX=word1, R8=word2; the scalar/str unwrap lifts only
// word0->AX, stranding word1+ in CX/R8. Shift the whole payload DOWN one
// INTEGER reg so element i lands in tupreg(i). Float/slice/str payload
// elements ride a different SysV class — loud-stop (rule 7; the per-
// eightbyte tagged-tuple-payload classification is the #243 follow-up).
// Mirror of cstage cg_tagged_tuple_payload_shift.
fn cgtaggedtuplepayloadshift(c: *cgen, tup: *tinfo) void = {
let words: i32 = 0;
let el: *ttupleelem = tup.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
let isflt: bool = et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64);
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
if (isflt || wide) {
let msg: str = "tuple-in-union ? unwrap: float/slice/str payload element needs SysV per-eightbyte classification (see #243); only integer tuple payloads supported\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
words = words + 1;
el = el.tnext;
};
if (words > 3) {
let msg: str = "tuple-in-union ? unwrap payload exceeds the 3 integer return regs past the tag; see #10/#243\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let i: i32 = 0;
for (i < words) {
emitline("\tMOVQ\t");
emitline(tupreg(i + 1));
emitline(", ");
emitline(tupreg(i));
emitline("\n");
i = i + 1;
};
};
fn cgreturn(c: *cgen, n: *node) void = {
rundefers(c);
let rhs: *node = n.lhs;

33
selfhost/cmd/wcc/check.ww
View File

@@ -1090,30 +1090,46 @@ fn astunsized(c: *checker, t: *node) bool = {
// descend into a nested N_MATCH — each match opens its own yield
// scope. exprtype is idempotent on already-stamped nodes (tinfocache
// path at L467) so re-entering it on the yield operand here is safe.
fn matchyieldtype(c: *checker, body: *node) *node = {
// bname/btype carry the enclosing arm's case-binding name + declared type
// node. #241: when exprtype can't re-derive a `yield <binder>` operand —
// the arm binder's scope is already popped by the time exprtype(N_MATCH)
// runs post-order (resolvewalk's N_MCASE restores c.cur before this), so
// scopelookup of the bare binder ident returns nil — the yielded type IS
// the binding type (btype). cstage avoids this by reading the operand's
// already-stamped ->type (check.c:122) rather than re-running cexpr; wwstage
// caches only node.type_ (a tinfo, not a type NODE), so this binder-typed
// fallback is the node-form recovery for the dominant match-bind-then-yield
// idiom (Hare's parseint `case let t => yield t`).
fn matchyieldtype(c: *checker, body: *node, bname: str, btype: *node) *node = {
if (body == nil) { return nil; };
let k: nkind = body.kind;
if (k == nkind.N_YIELD) {
if (body.lhs == nil) { return nil; };
return exprtype(c, body.lhs, nil);
let t: *node = exprtype(c, body.lhs, nil);
if (t != nil) { return t; };
if (body.lhs.kind == nkind.N_IDENT && bname.len > 0
&& streq(body.lhs.str, bname)) {
return btype;
};
return nil;
};
if (k == nkind.N_MATCH) { return nil; };
if (k == nkind.N_BLOCK) {
let s: *node = body.list;
for (s != nil) {
let t: *node = matchyieldtype(c, s);
let t: *node = matchyieldtype(c, s, bname, btype);
if (t != nil) { return t; };
s = s.next;
};
return nil;
};
if (k == nkind.N_IF) {
let t: *node = matchyieldtype(c, body.body);
let t: *node = matchyieldtype(c, body.body, bname, btype);
if (t != nil) { return t; };
return matchyieldtype(c, body.els);
return matchyieldtype(c, body.els, bname, btype);
};
if (k == nkind.N_FOR || k == nkind.N_FORRANGE) {
return matchyieldtype(c, body.body);
return matchyieldtype(c, body.body, bname, btype);
};
return nil;
};
@@ -2904,7 +2920,10 @@ fn exprtype(c: *checker, e: *node, hint: *node) *node = {
let yt: *node = nil;
let cs: *node = e.list;
for (cs != nil) {
let t: *node = matchyieldtype(c, cs.body);
// cs.str/cs.lhs = the arm's case-binding name + declared
// type (the N_MCASE binder); fed to matchyieldtype's #241
// scope-popped `yield <binder>` fallback.
let t: *node = matchyieldtype(c, cs.body, cs.str, cs.lhs);
if (t != nil) { yt = t; break; };
cs = cs.next;
};

270
selfhost/cmd/wwdump/main.combined.ww
View File

@@ -11340,30 +11340,46 @@ fn astunsized(c: *checker, t: *node) bool = {
// descend into a nested N_MATCH — each match opens its own yield
// scope. exprtype is idempotent on already-stamped nodes (tinfocache
// path at L467) so re-entering it on the yield operand here is safe.
fn matchyieldtype(c: *checker, body: *node) *node = {
// bname/btype carry the enclosing arm's case-binding name + declared type
// node. #241: when exprtype can't re-derive a `yield <binder>` operand —
// the arm binder's scope is already popped by the time exprtype(N_MATCH)
// runs post-order (resolvewalk's N_MCASE restores c.cur before this), so
// scopelookup of the bare binder ident returns nil — the yielded type IS
// the binding type (btype). cstage avoids this by reading the operand's
// already-stamped ->type (check.c:122) rather than re-running cexpr; wwstage
// caches only node.type_ (a tinfo, not a type NODE), so this binder-typed
// fallback is the node-form recovery for the dominant match-bind-then-yield
// idiom (Hare's parseint `case let t => yield t`).
fn matchyieldtype(c: *checker, body: *node, bname: str, btype: *node) *node = {
if (body == nil) { return nil; };
let k: nkind = body.kind;
if (k == nkind.N_YIELD) {
if (body.lhs == nil) { return nil; };
return exprtype(c, body.lhs, nil);
let t: *node = exprtype(c, body.lhs, nil);
if (t != nil) { return t; };
if (body.lhs.kind == nkind.N_IDENT && bname.len > 0
&& streq(body.lhs.str, bname)) {
return btype;
};
return nil;
};
if (k == nkind.N_MATCH) { return nil; };
if (k == nkind.N_BLOCK) {
let s: *node = body.list;
for (s != nil) {
let t: *node = matchyieldtype(c, s);
let t: *node = matchyieldtype(c, s, bname, btype);
if (t != nil) { return t; };
s = s.next;
};
return nil;
};
if (k == nkind.N_IF) {
let t: *node = matchyieldtype(c, body.body);
let t: *node = matchyieldtype(c, body.body, bname, btype);
if (t != nil) { return t; };
return matchyieldtype(c, body.els);
return matchyieldtype(c, body.els, bname, btype);
};
if (k == nkind.N_FOR || k == nkind.N_FORRANGE) {
return matchyieldtype(c, body.body);
return matchyieldtype(c, body.body, bname, btype);
};
return nil;
};
@@ -13154,7 +13170,10 @@ fn exprtype(c: *checker, e: *node, hint: *node) *node = {
let yt: *node = nil;
let cs: *node = e.list;
for (cs != nil) {
let t: *node = matchyieldtype(c, cs.body);
// cs.str/cs.lhs = the arm's case-binding name + declared
// type (the N_MCASE binder); fed to matchyieldtype's #241
// scope-popped `yield <binder>` fallback.
let t: *node = matchyieldtype(c, cs.body, cs.str, cs.lhs);
if (t != nil) { yt = t; break; };
cs = cs.next;
};
@@ -19045,6 +19064,14 @@ fn cgexpr(c: *cgen, n: *node) void = {
if (k == nkind.N_TRYUNW) { cgtryunw(c, n); return; };
if (k == nkind.N_TYPETEST) { cgtypetest(c, n); return; };
if (k == nkind.N_TYPEASSERT) { cgtypeassert(c, n); return; };
if (k == nkind.N_TUPLE) {
// #241: a literal tuple rvalue `(a, b)` is a value — pack its
// elements into the register cursor (mirror cgreturn's N_TUPLE
// arm) so a let-bind / destructure consumer reads every element,
// not just AX = 0 from the default arm below.
cgtuplelittocursor(c, n);
return;
};
// Default fallback: produce a deterministic AX = 0. Mirrors
// the C cgen's `default: cgexpr_int(c, 0)` branch, which is
// what `return eof{};` (N_STRUCTLIT with an empty !void
@@ -19073,6 +19100,27 @@ fn cgtagvariantidx(c: *cgen, tagged: *node, vt: *node) i32 = {
return flatvariantidx(c, tagged, vt);
};
// cgtrytupleshift — #241: if the `?`/`!` operand's success variant (tag 0)
// is a tuple, the unwrapped payload is an rvalue tuple that must fill the
// register cursor (shift past the tag), and the scalar/str MOVQ DX,AX tail
// is skipped. Returns true when it emitted the shift. Reads the operand's
// stamped tagged result tinfo (n.lhs.type_) — the success variant is the
// first param, matching the `CMPQ $0` success-tag convention.
fn cgtrytupleshift(c: *cgen, n: *node) bool = {
if (n.lhs == nil) { return false; };
let ou: *tinfo = n.lhs.type_: *tinfo;
for (ou != nil && ou.kind == tykind.TY_NAMED) { ou = ou.under; };
if (ou == nil) { return false; };
if (ou.kind != tykind.TY_TAGGED) { return false; };
if (ou.params == nil) { return false; };
let sv: *tinfo = ou.params.type_;
for (sv != nil && sv.kind == tykind.TY_NAMED) { sv = sv.under; };
if (sv == nil) { return false; };
if (sv.kind != tykind.TY_TUPLE) { return false; };
cgtaggedtuplepayloadshift(c, sv);
return true;
};
// cgtryprop — `e?` propagates the error variant up the stack.
// Success tag = 0 (#216 tracks the legacy/flag-aware success-tag
// divergence — out of scope here, success check stays `CMPQ $0`).
@@ -19136,6 +19184,10 @@ fn cgtryprop(c: *cgen, n: *node) void = {
};
emitline("\tMOVQ\tBP, SP\n\tPOPQ\tBP\n\tRET\n");
emitlabel(cl);
// #241: a tuple success payload is an rvalue tuple — fill the cursor
// (shift past the tag) so the destructure / let consumer reads every
// element, not just word0. Success variant = tag 0 (first param).
if (cgtrytupleshift(c, n)) { return; };
// Success: unwrap value. Tag-only result was AX; the rest of
// the codegen expects the success value in AX (and BX for str).
// AX=tag, DX=val0, CX=val1 from the call ABI. For str success,
@@ -19199,6 +19251,9 @@ fn cgtryunw(c: *cgen, n: *node) void = {
emitline("\n");
emitline("\tMOVQ\t$1, DI\n\tMOVQ\t$60, AX\n\tSYSCALL\n");
emitlabel(cl);
// #241: tuple success payload fills the cursor (shift past the tag) —
// same rvalue-tuple-into-cursor story as cgtryprop.
if (cgtrytupleshift(c, n)) { return; };
// Unwrap success value. (Same shuffle pattern as cgtryprop.)
let succisstr: bool = false;
if (n.lhs != nil) {
@@ -19577,6 +19632,16 @@ fn cgident(c: *cgen, n: *node) void = {
let lc: *local = localfindnode(c, nm);
if (lc != nil) {
let off: i32 = lc.off;
// #241: a tuple ident is a value — leave the whole tuple in the
// register cursor (`yield t` / `return t` / `let q = t`), not
// just word0 in AX. Mirror of cstage cgexpr N_IDENT tuple arm.
let itu: *tinfo = nil;
if (lc.tnode != nil) { itu = lc.tnode.type_: *tinfo; };
for (itu != nil && itu.kind == tykind.TY_NAMED) { itu = itu.under; };
if (itu != nil) { if (itu.kind == tykind.TY_TUPLE) {
cgtupleslottocursor(c, off, itu);
return;
}; };
// Float local: MOVSS / MOVSD into X0. Skips the AX shuffle
// so consumers (cgbin, cgcast, return) pick up the SSE value
// directly.
@@ -26592,6 +26657,197 @@ fn tupstore(c: *cgen, gpcur: i32, ssecur: i32, off: i32, wide: bool, tn: *node)
emitline("(BP)\n");
};
// cgtuplelittocursor — #241: materialise an N_TUPLE literal's elements into
// the SysV register-return cursor (integer words L->R over tupreg AX/DX/CX/
// R8, floats over tupsse X0/X1, a slice/str's {ptr,len,cap} over three
// consecutive INTEGER regs) — the SAME ABI a tuple-returning call leaves,
// which every tuple consumer (tupstore at cgmlet/cgmassign) reads. cgexpr
// otherwise falls to its `MOVQ $0, AX` default for a tuple, so a literal
// rvalue tuple bound or destructured read garbage past word0. Byte-identical
// extraction of cgreturn's in-register N_TUPLE arm (cgenstmt.ww), now shared
// with cgexpr. Over-cap loud-stops (rule 7); a bare expression value can't
// sret, so the >cap rvalue-tuple materialisation is the #10 follow-up.
fn cgtuplelittocursor(c: *cgen, tuple: *node) void = {
let ssecap: i32 = TUPLE_SSECAP;
let gptotal: i32 = 0;
let ssecount: i32 = 0;
let e: *node = tuple.list;
for (e != nil) {
if (isfloattype(c, e)) {
ssecount = ssecount + 1;
} else {
let wide: bool = nodeisstr(c, e) || nodeisslice(c, e);
gptotal = gptotal + tupebytes(wide);
};
e = e.next;
};
if (gptotal > TUPLE_GPCAP || ssecount > ssecap) {
let msg: str = "tuple literal exceeds register-return ABI capacity (integer AX,DX,CX,R8 / SSE X0,X1); over-cap rvalue-tuple materialisation is the #10 sret follow-up\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let fscr: i32 = 0;
if (ssecount > 0) {
fscr = localadd(c, "@tupfscr", ssecap * 8, nil);
};
let sseidx: i32 = 0;
e = tuple.list;
for (e != nil) {
let isflt: bool = isfloattype(c, e);
cgexpr(c, e);
if (isflt) {
let mov: str = "MOVSD";
if (isf32type(c, e)) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\tX0, ");
emitoff((fscr + sseidx * 8): i64);
emitline("(BP)\n");
sseidx = sseidx + 1;
} else {
emitline("\tPUSHQ\tAX\n");
if (nodeisstr(c, e) || nodeisslice(c, e)) {
emitline("\tPUSHQ\tBX\n");
emitline("\tPUSHQ\tCX\n");
};
};
e = e.next;
};
let i: i32 = gptotal - 1;
for (i >= 0) {
emitline("\tPOPQ\t");
emitline(tupreg(i));
emitline("\n");
i = i - 1;
};
let j: i32 = 0;
e = tuple.list;
for (e != nil) {
if (isfloattype(c, e)) {
let mov: str = "MOVSD";
if (isf32type(c, e)) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\t");
emitoff((fscr + j * 8): i64);
emitline("(BP), ");
emitline(tupsse(j));
emitline("\n");
j = j + 1;
};
e = e.next;
};
};
// cgtupleslottocursor — #241: load a tuple already materialised in a BP-
// relative slot (a tuple-typed IDENT: a let-bound tuple, a match-bound union
// payload) into the SAME register cursor. The slot uses the register-ABI
// stride the tuple-init / #242 destructure write (a scalar 8B, a slice/str
// its 3-word header), NOT the packed t.N field layout (#238). All sources
// are memory, so each word loads straight into its cursor reg. So `yield t`
// / `return t` / `let q = t` over a tuple ident leave the whole tuple in the
// cursor, not just word0 in AX. Over-cap loud-stops (rule 7; #10). Mirror of
// cstage cg_tuple_slot_to_cursor.
fn cgtupleslottocursor(c: *cgen, srcoff: i32, tu: *tinfo) void = {
let gptotal: i32 = 0;
let ssecount: i32 = 0;
let el: *ttupleelem = tu.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
if (et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64)) {
ssecount = ssecount + 1;
} else {
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
gptotal = gptotal + tupebytes(wide);
};
el = el.tnext;
};
if (gptotal > TUPLE_GPCAP || ssecount > TUPLE_SSECAP) {
let msg: str = "tuple ident exceeds register-return ABI capacity (integer AX,DX,CX,R8 / SSE X0,X1); over-cap rvalue-tuple materialisation is the #10 sret follow-up\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let gp: i32 = 0;
let sse: i32 = 0;
let foff: i32 = 0;
el = tu.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
let isflt: bool = et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64);
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
if (isflt) {
let mov: str = "MOVSD";
if (et.kind == tykind.TY_F32) { mov = "MOVSS"; };
emitline("\t"); emitline(mov); emitline("\t");
emitoff((srcoff + foff): i64);
emitline("(BP), ");
emitline(tupsse(sse));
emitline("\n");
sse = sse + 1;
foff += 8;
} else { if (wide) {
let k: i32 = 0;
for (k < 3) {
emitline("\tMOVQ\t");
emitoff((srcoff + foff + k * 8): i64);
emitline("(BP), ");
emitline(tupreg(gp + k));
emitline("\n");
k += 1;
};
gp += 3;
foff += et.size: i32;
} else {
emitline("\tMOVQ\t");
emitoff((srcoff + foff): i64);
emitline("(BP), ");
emitline(tupreg(gp));
emitline("\n");
gp += 1;
foff += 8;
}; };
el = el.tnext;
};
};
// cgtaggedtuplepayloadshift — #241: a `?`-unwrapped tuple payload is an
// rvalue tuple that must fill the register cursor. The tagged return leaves
// AX=tag, DX=word0, CX=word1, R8=word2; the scalar/str unwrap lifts only
// word0->AX, stranding word1+ in CX/R8. Shift the whole payload DOWN one
// INTEGER reg so element i lands in tupreg(i). Float/slice/str payload
// elements ride a different SysV class — loud-stop (rule 7; the per-
// eightbyte tagged-tuple-payload classification is the #243 follow-up).
// Mirror of cstage cg_tagged_tuple_payload_shift.
fn cgtaggedtuplepayloadshift(c: *cgen, tup: *tinfo) void = {
let words: i32 = 0;
let el: *ttupleelem = tup.tupleelems;
for (el != nil) {
let et: *tinfo = el.type_;
for (et != nil && et.kind == tykind.TY_NAMED) { et = et.under; };
let isflt: bool = et != nil && (et.kind == tykind.TY_F32 || et.kind == tykind.TY_F64);
let wide: bool = et != nil && (et.kind == tykind.TY_SLICE || et.kind == tykind.TY_STR);
if (isflt || wide) {
let msg: str = "tuple-in-union ? unwrap: float/slice/str payload element needs SysV per-eightbyte classification (see #243); only integer tuple payloads supported\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
words = words + 1;
el = el.tnext;
};
if (words > 3) {
let msg: str = "tuple-in-union ? unwrap payload exceeds the 3 integer return regs past the tag; see #10/#243\n";
os.write(2, msg.ptr, msg.len: u64);
os.exit(1);
};
let i: i32 = 0;
for (i < words) {
emitline("\tMOVQ\t");
emitline(tupreg(i + 1));
emitline(", ");
emitline(tupreg(i));
emitline("\n");
i = i + 1;
};
};
fn cgreturn(c: *cgen, n: *node) void = {
rundefers(c);
let rhs: *node = n.lhs;

241
test/wcc/945_rvalue_tuple_destructure_run.c Normal file
View File

@@ -0,0 +1,241 @@
/*
* 945_rvalue_tuple_destructure_run — project #241: materialise an RVALUE
* tuple into the register cursor before a destructure / let bind.
*
* cgexpr could not produce a tuple VALUE: a literal `(a, b)` fell to the
* `cgexpr_int(0)` / `MOVQ $0, AX` default, a tuple-typed IDENT loaded only
* word0 into AX, and the `?`/`!` unwrap of a tuple-in-union payload lifted
* only word0->AX (stranding word1 in CX). So `let (x, y) = <rvalue tuple>`
* read GARBAGE past the first element (cstage), and the un-typed binder left
* wwstage's checker aborting (asserttyped). DANGEROUS gate-blind cs!=ww — the
* strconv blocker (`let (sign, u) = parseint(s, base)?`).
*
* Fix (both stages, byte-identical per rule 10): cgexpr packs an N_TUPLE
* literal and a tuple IDENT into the SysV register-return cursor (the SAME
* ABI a tuple-returning call leaves, which the cgmlet/cgmassign consumers
* already read); the ?/! unwrap shifts a tuple success payload down one
* integer reg past the tag. wwstage's checker recovers the popped match-arm
* binder type for a `yield <binder>` (scope-free, via the arm's declared
* type) so the destructured binders stamp.
*
* Rows assert BOTH elements on BOTH drivers AND cs==ww byte-identical:
* literal_destructure `let (a, b) = (true, 11u64)`
* match_yield `let (sg, u) = match (mk()) { case let t => yield t }`
* trycall_strconv `let (sign, u) = parseint(base)?` (the strconv shape)
*
* NOT covered (separate root, deferred): single-var `let q = (true, 9u64)`
* then `q.N` rides #238 — the N_LET tuple-init sz==16||32 gate + the N_DOT
* tuple-field PACKED-offset reader vs tuple_store's 8B stride disagree for a
* narrow-first tuple. Out of scope for #241 (the rvalue-into-cursor fix); see
* task #6 / proj #238.
*
* All K_RUN: build+run exit 0 on BOTH drivers AND cs==ww byte-identical.
* NNN<950, self-contained (/tmp, no imports), so rule-14's selfhost-sibling
* race does not apply (903/940/945 precedent).
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
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;
}
struct row { const char *label; const char *src; int want; };
static const struct row rows[] = {
{ "literal_destructure",
"package main;\n"
"export fn main() i32 = {\n"
" let (a, b) = (true, 11u64);\n"
" if (b != 11u64) { return 1; };\n"
" if (!a) { return 2; };\n"
" return 0;\n"
"};\n", 0 },
{ "match_yield",
"package main;\n"
"type myerr = !void;\n"
"fn mk(x: u64, s: bool) ((bool, u64) | myerr) = { return (s, x); };\n"
"export fn main() i32 = {\n"
" let (sg, u) = match (mk(6u64, true)) {\n"
" case let t: (bool, u64) => yield t;\n"
" case myerr => { return 9; };\n"
" };\n"
" if (u != 6u64) { return 1; };\n"
" if (!sg) { return 2; };\n"
" return 0;\n"
"};\n", 0 },
{ "trycall_strconv",
"package main;\n"
"type invalid = !void;\n"
"fn parseint(base: int) ((bool, u64) | invalid) = {\n"
" let sg: bool = true;\n"
" let n: u64 = 42u64;\n"
" return (sg, n);\n"
"};\n"
"fn stoi(base: int) (u64 | invalid) = {\n"
" let (sign, u) = parseint(base)?;\n"
" if (!sign) { return 0u64; };\n"
" return u;\n"
"};\n"
"export fn main() i32 = {\n"
" match (stoi(10)) {\n"
" case let v: u64 => { if (v != 42u64) { return 1; }; };\n"
" case invalid => { return 2; };\n"
" };\n"
" return 0;\n"
"};\n", 0 },
};
/* 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/rvtd_%d_%d.ww", getpid(), i);
snprintf(tmpdir, sizeof tmpdir, "/tmp/rvtd_%d_d_%d", getpid(), i);
snprintf(errf, sizeof errf, "/tmp/rvtd_%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 (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/rvtd_bi_%d_%d.ww", getpid(), i);
snprintf(cs_s, sizeof cs_s, "/tmp/rvtd_bi_%d_%d_cs.s", getpid(), i);
snprintf(ws_s, sizeof ws_s, "/tmp/rvtd_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 "
"(rule-10 byte-id)\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, "rvalue_tuple_destructure: 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++;
}
}
if (access(w6c_ww, X_OK) == 0) {
for (int i = 0; i < n; i++) {
total++;
if (byteid(w6c, w6c_ww, &rows[i], i) != 0) fail++;
}
}
if (fail) {
fprintf(stderr, "rvalue_tuple_destructure: %d/%d checks failed\n",
fail, total);
return 1;
}
printf("rvalue_tuple_destructure: %d/%d ok\n", total, total);
return 0;
}