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

w6c+w6c_ww: *[N]T indexing strides by element, not whole array (#61 A+B)

Browse Source 
Indexing through a pointer-to-array auto-derefs, so esz and the element
classification must come from the pointee array's ELEMENT (cstage
idx_eff semantics, cgen.c:1163). Two halves of one root class:

A (wwstage-only, cs!=ww, cstage runtime-correct): elemsizeofc's #270-2
nested-array block treated an N_TPTR pointee-array like a [N][M]T outer
index and returned the whole-array size — every p[i] read/write/
compound scaled by N*size(T), and the same wrong element belief reached
the store-width chooser (var-idx write emitted an N*8B aggregate copy
sourced at the 8B rhs slot: caller-frame smash, the siphash round()
corruption). Fixed via two wwstage choke-points mirroring idx_eff:
idxeffti (tinfo: NAMED peel + TY_PTR->TY_ARRAY drill; feeds elemsizeofc
and elemissignedc/elemisfloatc/elemisf32c) and idxelemtn (node: element
tnode with the same drill; feeds every cgindex/cgassign/nodeisstr/
match-scrutinee elemtn resolution).

B (BOTH stages identically wrong, byte-id-BLIND): the TK_AMP &base[i]
arm read bu->sub->size without the ptr peel (&p[3]-&a[0] = 96, not 24).
cstage now routes esz through idx_eff.

A and B are FUSED by the pre-existing routing topology, not by choice
(rule 11): wwstage's TK_AMP arm already reads its esz via elemsizeofc
(selfhost/cmd/wcc/cgenexpr.ww:4095, the #11 addr-of twin of the #10
cgindex fix), so fixing A's choke-point flips wwstage's half of B in
the same stroke. A standalone A leaves &p[i] transiently cs!=ww;
B-first is the mirror transient; carving the TK_AMP caller out of the
fixed choke-point to preserve the wrong stride for one commit would be
a deliberate known-wrong intermediate (rule-7, vetoed by rob). One
choke-point, two enrolled routes — un-fusable without a red
intermediate.

Close-by-construction proof-grep (both stages): every remaining raw
sub->size index-stride read is TY_ARRAY-gated, a slice-only builtin
(delete/insert), a checker-stamped element tinfo (indexresult already
decays *[N]T, check.ww:2277-2284), or a non-index context (tuple
slots, let-init elements). Two true residuals filed with site+symptom
instead of silently absorbed: N_SLICE through *[N]T does not decay
(LOUD type error, Hare divergence; team task #18) and non-ident
cast-expression index bases keep wwstage's 8B-default esz (pre-existing
#74-style cluster; team task #19). cstage's N_INDEX read-side
str/slice header gates also move from u->sub to esub (identical for
every non-ptr-to-array base; honest for *[N]str — pre-fix BOTH stages
were runtime-wrong there, differently).

949_ptrarr_index_run pins the class at runtime + byte-id: {1,2,4,8}B
elems, const+var idx, param/local/cast bases, read/write/compound,
neighbor guards, &p[i] pointer-difference, siphash-round mix shape.
989_lib_byteid: siphash_test graduates #59.7 DIVERGE -> ID (ratchet
tripped loud pre-update; no other #59.x pin flipped in the same run).
(*p)[i] (sub-bug C) follows separately.
This commit is contained in:
Hojun-Cho
2026-06-04 22:03:33 +09:00
parent 95fea97868
commit eea3e197c2
10 changed files with 739 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile
View File

@@ -430,6 +430,7 @@ TESTS = $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \
$(BIN)/test_floatarr_run \
$(BIN)/test_deref_narrow_run \
$(BIN)/test_idx_compound_run \
$(BIN)/test_ptrarr_index_run \
$(BIN)/test_dotbase_arr_run \
$(BIN)/test_dotbase_addr_slice_run \
$(BIN)/test_structlit_arrfield_run \
@@ -1843,6 +1844,11 @@ $(BIN)/test_idx_compound_run: test/wcc/948_idx_compound_run.c $(BIN)/ww \
$(LIB)/libwwrt.a | $(BIN)
$(CC) $(CFLAGS) -o $@ $<
$(BIN)/test_ptrarr_index_run: test/wcc/949_ptrarr_index_run.c $(BIN)/ww \
$(BIN)/w6c $(BIN)/w6c_ww $(BIN)/w6a $(BIN)/w6l \
$(LIB)/libwwrt.a | $(BIN)
$(CC) $(CFLAGS) -o $@ $<
$(BIN)/test_dotbase_arr_run: test/wcc/949_dotbase_arr_run.c $(BIN)/ww \
$(BIN)/w6c $(BIN)/w6c_ww $(BIN)/w6a $(BIN)/w6l \
$(LIB)/libwwrt.a | $(BIN)

25
cmd/w6c/cgen.c
View File

@@ -3826,14 +3826,21 @@ cgexpr(Cg *c, Node *n, Local *locals)
/* Fall through to silent-drop fallback below. */
}
if (opnd && opnd->kind == N_INDEX) {
/* &base[i] = base + i*esz, no dereference. */
/* &base[i] = base + i*esz, no dereference.
* esz via idx_eff (#61): `&p[i]` on `p: *[N]T`
* strides the pointee array's ELEMENT — the
* undrilled bu->sub here was the whole [N]T
* (&p[i]-&p[0] = i*N*size(T), wild pointer).
* Base load still keys off bu (is_arr stays
* false for the ptr → MOVQ of p's value). */
Node *base = opnd->lhs;
Node *idx = opnd->rhs;
Type *bt = base ? base->type : NULL;
Type *bu = (bt && bt->kind == TY_NAMED)
? bt->under : bt;
int esz = (bu && bu->sub)
? (int)bu->sub->size : 1;
Type *eff = idx_eff(bt);
int esz = (eff && eff->sub)
? (int)eff->sub->size : 1;
cgexpr(c, idx, locals); /* idx → AX */
if (esz > 1) {
ins2(c, A_MOVQ, aimm(esz),
@@ -10259,8 +10266,11 @@ cgexpr(Cg *c, Node *n, Local *locals)
* word must survive. Kind-gate on type_isstr||type_isslice,
* never size==24: a >16B struct is 24B+ too but takes the
* struct-copy path, not this 3-word header load (#10).
* Base is BX. */
if (u->sub && (type_isstr(u->sub) || type_isslice(u->sub))) {
* Gate on esub (= idx_eff'd element, #61), not u->sub —
* for `*[N]str` u->sub is the ARRAY and the gate missed,
* falling to a 1-word load that dropped len/cap. esub ==
* u->sub for every non-ptr-to-array base. Base is BX. */
if (esub && (type_isstr(esub) || type_isslice(esub))) {
cgslicehdr(c, D_BX);
break;
}
@@ -10329,8 +10339,9 @@ cgexpr(Cg *c, Node *n, Local *locals)
break;
/* str/slice element via fallback base: load the full (ptr, len,
* cap) header into (AX, BX, CX). Kind-gate on type_isstr||
* type_isslice, never size==24 (see Site A). Base is AX. */
if (u && u->sub && (type_isstr(u->sub) || type_isslice(u->sub))) {
* type_isslice, never size==24 (see Site A). esub, not u->sub
* (#61 — see the ident arm). Base is AX. */
if (esub && (type_isstr(esub) || type_isslice(esub))) {
cgslicehdr(c, D_AX);
break;
}

5
cmd/wcc/check.c
View File

@@ -1776,6 +1776,11 @@ cexpr(Checker *c, Node *n)
return n->type = base;
if (u && u->kind == TY_STR)
return n->type = ty_str;
/* Retained divergence: *[N]T does NOT decay here —
* `p[lo:hi]` types as [][N]T (C-pointer-slicing), unlike
* the index route (idx_eff) and unlike Hare. Loud on the
* usual []T annotation; for-range likewise. Team task #18
* (#61-residual A). */
if (u && u->kind == TY_PTR && u->sub)
return n->type = type_slice(c->a, u->sub);
return n->type = err(c, n->pos, "cannot slice %s",

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

@@ -13443,6 +13443,11 @@ fn exprtype(c: *checker, e: *node, hint: *node) *node = {
return tn;
};
};
// Retained divergence: *[N]T does NOT decay here —
// `p[lo:hi]` types as [][N]T (C-pointer-slicing), unlike
// the index route (idxeffti) and unlike Hare. Loud on the
// usual []T annotation; for-range likewise. Team task #18
// (#61-residual A).
if (bu.kind == nkind.N_TPTR && bu.lhs != nil) {
let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
sl.lhs = bu.lhs;
@@ -16942,11 +16947,9 @@ fn nodeisstr(c: *cgen, n: *node) bool = {
if (lc != nil) { bt = lc.tnode; }
else { bt = letvartnode(c, base.str); };
if (bt != nil) {
let elem: *node = nil;
let bk: nkind = bt.kind;
if (bk == nkind.N_TARRAY) { elem = bt.lhs; };
if (bk == nkind.N_TSLICE) { elem = bt.lhs; };
if (bk == nkind.N_TPTR) { elem = bt.lhs; };
// idxelemtn: `*[N]T` drills to the pointee
// array's element (#61).
let elem: *node = idxelemtn(bt);
if (elem != nil) {
return isstrtype(c, elem);
};
@@ -16988,11 +16991,8 @@ fn nodeisstr(c: *cgen, n: *node) bool = {
if (streq(fi.fname, fld)) {
let ft: *node = fi.tnode;
if (ft != nil) {
let elem: *node = nil;
let fk: nkind = ft.kind;
if (fk == nkind.N_TPTR) { elem = ft.lhs; };
if (fk == nkind.N_TSLICE) { elem = ft.lhs; };
if (fk == nkind.N_TARRAY) { elem = ft.lhs; };
// idxelemtn: `*[N]T` drill (#61).
let elem: *node = idxelemtn(ft);
if (elem != nil) {
return isstrtype(c, elem);
};
@@ -17040,8 +17040,6 @@ fn typeis8byteprimitive(c: *cgen, t: *node) bool = {
// the stamped tinfo so alias/enum recursion lives in lib/ww/typ.ww.
fn elemissignedc(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
// #65 Phase-N step-2 cleanup: peel TY_NAMED before the .sub read.
// #64 now flows per-decl NAMED wrappers, so a NAMED-of-(`*T`/`[]T`/
// `[N]T`) reaching here would read NAMED.sub (nil) instead of the
@@ -17049,7 +17047,10 @@ fn elemissignedc(c: *cgen, t: *node) bool = {
// before the eff->sub read (:3518-3520). Byte-id-neutral: every
// aliased indexable in-tree has a u8 element (typeissigned=false
// either way). Transitive peel matches the #63 idiom.
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti additionally drills `*[N]T` to the pointee array (#61)
// so a signed-narrow element behind a pointer-to-array still
// sign-extends on load.
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeissigned(ti.sub);
};
@@ -17064,9 +17065,8 @@ fn elemissignedc(c: *cgen, t: *node) bool = {
// (the unstamped-base trap that broke the exprfloatkind collapse, #121).
fn elemisfloatc(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti = TY_NAMED peel + the `*[N]T` drill (#61).
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeisfloat(ti.sub);
};
@@ -17075,9 +17075,8 @@ fn elemisfloatc(c: *cgen, t: *node) bool = {
// so cgindex picks MOVSS over MOVSD at the #119 element load.
fn elemisf32c(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti = TY_NAMED peel + the `*[N]T` drill (#61).
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeisf32(ti.sub);
};
@@ -17211,6 +17210,46 @@ export fn localloadop(c: *cgen, tnode: *node) str = {
return loadopsz(sigd, sz);
};
// idxeffti — element-effective tinfo for indexing. `*[N]T` auto-derefs
// at an index base, so its esz/element classification must come from
// the pointee ARRAY (stride T), not from the pointer (whose .sub is
// the whole [N]T — the #61 stride bug, N*size(T) off target per index
// step). One peel choke-point: every tinfo-keyed index-element answer
// (elemsizeofc / elemissignedc / elemisfloatc / elemisf32c) routes
// through here. Mirrors cstage idx_eff (cmd/w6c/cgen.c:1163).
fn idxeffti(t0: *tinfo) *tinfo = {
let t: *tinfo = t0;
for (t != nil && t.kind == tykind.TY_NAMED) { t = t.under; };
if (t != nil && t.kind == tykind.TY_PTR) {
let p: *tinfo = t.sub;
for (p != nil && p.kind == tykind.TY_NAMED) { p = p.under; };
if (p != nil && p.kind == tykind.TY_ARRAY) { return p; };
};
return t;
};
// idxelemtn — element type-NODE for an indexable base tnode, the
// node-keyed companion of idxeffti for the cgen arms that classify
// the element structurally (istaggedtype / isstrtype / isslicetype /
// isfloattype / tnodestoreop). Same `*[N]T` drill: the pointee array's
// OWN element, never the array (#61 — an undrilled elemtn made the
// store-width chooser believe the element IS `[N]T` and emit an
// N*8-byte aggregate copy from an 8B source: caller-frame smash).
// nil for non-indexable kinds (str N_TNAME: callers want nil so
// tnodestoreop falls to the u8 byte store).
fn idxelemtn(tn: *node) *node = {
if (tn == nil) { return nil; };
let k: nkind = tn.kind;
if (k != nkind.N_TARRAY && k != nkind.N_TSLICE
&& k != nkind.N_TPTR) { return nil; };
let elem: *node = tn.lhs;
if (k == nkind.N_TPTR && elem != nil
&& elem.kind == nkind.N_TARRAY) {
return elem.lhs;
};
return elem;
};
// elemsizeof — given the type node of an indexable (`*T`, `[]T`,
// `[N]T`, `str`), return the byte size of one element (1 for u8/i8/
// bool/str-byte, 8 otherwise — same shape as C cgen's esz fallback).
@@ -17280,9 +17319,15 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = {
// sub-array stride $12. Mirror cstage esz = idx_eff(bt)->sub->size
// (cmd/w6c/cgen.c:4923): the element-array tinfo's natural size
// (sub.size*elen, type.c:121) IS the outer stride.
// N_TPTR is excluded (#61): a pointee-array is NOT a nested
// element — `p[i]` on `*[N]T` auto-derefs and strides the array's
// OWN element (idx_eff peels TY_PTR→TY_ARRAY before the .sub
// read). Routing it through this whole-sub-array rule scaled
// every index by N*size(T) — the siphash round() corruption. The
// `*[N][M]T` outer stride still resolves below via idxeffti
// (pointee array's .sub = [M]T, its natural size).
let nk: nkind = t.kind;
let nest: *node = nil;
if (nk == nkind.N_TPTR) { nest = t.lhs; };
if (nk == nkind.N_TSLICE) { nest = t.lhs; };
if (nk == nkind.N_TARRAY) { nest = t.lhs; };
if (nest != nil && nest.kind == nkind.N_TARRAY) {
@@ -17303,20 +17348,16 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = {
// and the local-array-init STORE (frame-smash). Peel TY_NAMED on the
// indexable and on its element, matching the #270-2 nested-array block
// above. Structural slotsize fallback stays for the t.type_==nil case.
let ti: *tinfo = t.type_: *tinfo;
// idxeffti folds that peel together with the `*[N]T` TY_PTR→
// TY_ARRAY drill (#61) so .sub is the array's element, never the
// whole pointee array.
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti != nil) {
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
if (ti != nil) {
let esub: *tinfo = ti.sub;
for (esub != nil && esub.kind == tykind.TY_NAMED) { esub = esub.under; };
if (esub != nil) { return esub.size: i32; };
};
let esub: *tinfo = ti.sub;
for (esub != nil && esub.kind == tykind.TY_NAMED) { esub = esub.under; };
if (esub != nil) { return esub.size: i32; };
};
let k: nkind = t.kind;
let elem: *node = nil;
if (k == nkind.N_TPTR) { elem = t.lhs; };
if (k == nkind.N_TSLICE) { elem = t.lhs; };
if (k == nkind.N_TARRAY) { elem = t.lhs; };
let elem: *node = idxelemtn(t);
if (elem == nil) { return direct; };
if (elem.kind == nkind.N_TNAME) {
let ps: i32 = primsize(elem.str);
@@ -18209,11 +18250,8 @@ fn matchscrutt(c: *cgen, scrut: *node) *node = {
if (bl != nil) { btn = bl.tnode; }
else { btn = letvartnode(c, ibase.str); };
if (btn == nil) { return nil; };
let bk: nkind = btn.kind;
let etn: *node = nil;
if (bk == nkind.N_TARRAY) { etn = btn.lhs; };
if (bk == nkind.N_TSLICE) { etn = btn.lhs; };
if (bk == nkind.N_TPTR) { etn = btn.lhs; };
// idxelemtn: `*[N]T` drills to the pointee array's element (#61).
let etn: *node = idxelemtn(btn);
if (etn == nil) { return nil; };
return resolvetagged(c, etn);
};
@@ -21805,6 +21843,9 @@ fn cgindex(c: *cgen, n: *node) void = {
// path when the base is a bare ident (mem.ww shape).
let base: *node = n.lhs;
let idx: *node = n.rhs;
// Direct non-ident index bases that match none of the typed arms
// below (e.g. a cast-expression base) keep this 8B default —
// cs!=ww for narrow elements. Team task #19 (#61-residual B).
let esz: i32 = 8;
let signed_elem: bool = false;
// #119: float element loads route to MOVSS/MOVSD into X0, not the
@@ -21928,22 +21969,14 @@ fn cgindex(c: *cgen, n: *node) void = {
if (base.kind == nkind.N_IDENT) {
let bl: *local = baselocal;
let etn: *node = nil;
// idxelemtn drills `*[N]T` to the pointee array's own
// element (#61) — an undrilled etn classified the whole
// array, missing tagged/str/slice elements behind a
// pointer-to-array base.
if (bl != nil) {
let btn: *node = bl.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { etn = btn.lhs; };
if (bk == nkind.N_TSLICE) { etn = btn.lhs; };
if (bk == nkind.N_TPTR) { etn = btn.lhs; };
};
etn = idxelemtn(bl.tnode);
} else {
let tn: *node = letvartnode(c, base.str);
if (tn != nil) {
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) { etn = tn.lhs; };
if (bk == nkind.N_TSLICE) { etn = tn.lhs; };
if (bk == nkind.N_TPTR) { etn = tn.lhs; };
};
etn = idxelemtn(letvartnode(c, base.str));
};
if (istaggedtype(c, etn)) {
if (!isnullabletype(etn)) {
@@ -27162,13 +27195,12 @@ fn cgassign(c: *cgen, n: *node) void = {
baselocal = localfindnode(c, bn);
if (baselocal != nil) {
esz = elemsizeofc(c, baselocal.tnode);
let btn: *node = baselocal.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { elemtn = btn.lhs; };
if (bk == nkind.N_TSLICE) { elemtn = btn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = btn.lhs; };
};
// idxelemtn drills `*[N]T` to the pointee
// array's element (#61): an undrilled elemtn
// made the width chooser believe the element
// IS the whole array (N*8B aggregate copy
// from an 8B source — frame smash).
elemtn = idxelemtn(baselocal.tnode);
} else {
// #11: store/compound twin of the #10 cgindex
// read fix. A global str/slice element store hit
@@ -27190,14 +27222,13 @@ fn cgassign(c: *cgen, n: *node) void = {
if (tn != nil) {
globalname = bn;
esz = elemsizeofc(c, tn);
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) {
// idxelemtn: `*[N]T` drill, see the
// local branch above (#61).
elemtn = idxelemtn(tn);
if (tn.kind == nkind.N_TARRAY) {
isglobalarr = true;
elemtn = tn.lhs;
} else {
isglobalptr = true;
if (bk == nkind.N_TSLICE) { elemtn = tn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = tn.lhs; };
};
};
};
@@ -27609,13 +27640,12 @@ fn cgassign(c: *cgen, n: *node) void = {
baselocal = localfindnode(c, bn);
if (baselocal != nil) {
esz = elemsizeofc(c, baselocal.tnode);
let btn: *node = baselocal.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { elemtn = btn.lhs; };
if (bk == nkind.N_TSLICE) { elemtn = btn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = btn.lhs; };
};
// idxelemtn drills `*[N]T` to the pointee
// array's element (#61): an undrilled elemtn
// made the width chooser believe the element
// IS the whole array (N*8B aggregate copy
// from an 8B source — frame smash).
elemtn = idxelemtn(baselocal.tnode);
} else {
// #11: store/compound twin of the #10 cgindex
// read fix. A global str/slice element store hit
@@ -27637,14 +27667,13 @@ fn cgassign(c: *cgen, n: *node) void = {
if (tn != nil) {
globalname = bn;
esz = elemsizeofc(c, tn);
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) {
// idxelemtn: `*[N]T` drill, see the
// local branch above (#61).
elemtn = idxelemtn(tn);
if (tn.kind == nkind.N_TARRAY) {
isglobalarr = true;
elemtn = tn.lhs;
} else {
isglobalptr = true;
if (bk == nkind.N_TSLICE) { elemtn = tn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = tn.lhs; };
};
};
};
@@ -27795,12 +27824,10 @@ fn cgassign(c: *cgen, n: *node) void = {
let lc: *local = localfindnode(c, idxbase.str);
if (lc != nil) { if (lc.tnode != nil) {
let tn: *node = lc.tnode;
let elemt: *node = nil;
let baseisarray: bool = false;
let tk: nkind = tn.kind;
if (tk == nkind.N_TSLICE) { elemt = tn.lhs; };
if (tk == nkind.N_TARRAY) { elemt = tn.lhs; baseisarray = true; };
if (tk == nkind.N_TPTR) { elemt = tn.lhs; };
// idxelemtn: `*[N]T` drills to the pointee
// array's element (#61).
let elemt: *node = idxelemtn(tn);
let baseisarray: bool = tn.kind == nkind.N_TARRAY;
let sname: str;
sname.ptr = nil; sname.len = 0;
let viaptr: bool = false;

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

@@ -1471,6 +1471,9 @@ fn cgindex(c: *cgen, n: *node) void = {
// path when the base is a bare ident (mem.ww shape).
let base: *node = n.lhs;
let idx: *node = n.rhs;
// Direct non-ident index bases that match none of the typed arms
// below (e.g. a cast-expression base) keep this 8B default —
// cs!=ww for narrow elements. Team task #19 (#61-residual B).
let esz: i32 = 8;
let signed_elem: bool = false;
// #119: float element loads route to MOVSS/MOVSD into X0, not the
@@ -1594,22 +1597,14 @@ fn cgindex(c: *cgen, n: *node) void = {
if (base.kind == nkind.N_IDENT) {
let bl: *local = baselocal;
let etn: *node = nil;
// idxelemtn drills `*[N]T` to the pointee array's own
// element (#61) — an undrilled etn classified the whole
// array, missing tagged/str/slice elements behind a
// pointer-to-array base.
if (bl != nil) {
let btn: *node = bl.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { etn = btn.lhs; };
if (bk == nkind.N_TSLICE) { etn = btn.lhs; };
if (bk == nkind.N_TPTR) { etn = btn.lhs; };
};
etn = idxelemtn(bl.tnode);
} else {
let tn: *node = letvartnode(c, base.str);
if (tn != nil) {
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) { etn = tn.lhs; };
if (bk == nkind.N_TSLICE) { etn = tn.lhs; };
if (bk == nkind.N_TPTR) { etn = tn.lhs; };
};
etn = idxelemtn(letvartnode(c, base.str));
};
if (istaggedtype(c, etn)) {
if (!isnullabletype(etn)) {
@@ -6828,13 +6823,12 @@ fn cgassign(c: *cgen, n: *node) void = {
baselocal = localfindnode(c, bn);
if (baselocal != nil) {
esz = elemsizeofc(c, baselocal.tnode);
let btn: *node = baselocal.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { elemtn = btn.lhs; };
if (bk == nkind.N_TSLICE) { elemtn = btn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = btn.lhs; };
};
// idxelemtn drills `*[N]T` to the pointee
// array's element (#61): an undrilled elemtn
// made the width chooser believe the element
// IS the whole array (N*8B aggregate copy
// from an 8B source — frame smash).
elemtn = idxelemtn(baselocal.tnode);
} else {
// #11: store/compound twin of the #10 cgindex
// read fix. A global str/slice element store hit
@@ -6856,14 +6850,13 @@ fn cgassign(c: *cgen, n: *node) void = {
if (tn != nil) {
globalname = bn;
esz = elemsizeofc(c, tn);
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) {
// idxelemtn: `*[N]T` drill, see the
// local branch above (#61).
elemtn = idxelemtn(tn);
if (tn.kind == nkind.N_TARRAY) {
isglobalarr = true;
elemtn = tn.lhs;
} else {
isglobalptr = true;
if (bk == nkind.N_TSLICE) { elemtn = tn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = tn.lhs; };
};
};
};
@@ -7275,13 +7268,12 @@ fn cgassign(c: *cgen, n: *node) void = {
baselocal = localfindnode(c, bn);
if (baselocal != nil) {
esz = elemsizeofc(c, baselocal.tnode);
let btn: *node = baselocal.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { elemtn = btn.lhs; };
if (bk == nkind.N_TSLICE) { elemtn = btn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = btn.lhs; };
};
// idxelemtn drills `*[N]T` to the pointee
// array's element (#61): an undrilled elemtn
// made the width chooser believe the element
// IS the whole array (N*8B aggregate copy
// from an 8B source — frame smash).
elemtn = idxelemtn(baselocal.tnode);
} else {
// #11: store/compound twin of the #10 cgindex
// read fix. A global str/slice element store hit
@@ -7303,14 +7295,13 @@ fn cgassign(c: *cgen, n: *node) void = {
if (tn != nil) {
globalname = bn;
esz = elemsizeofc(c, tn);
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) {
// idxelemtn: `*[N]T` drill, see the
// local branch above (#61).
elemtn = idxelemtn(tn);
if (tn.kind == nkind.N_TARRAY) {
isglobalarr = true;
elemtn = tn.lhs;
} else {
isglobalptr = true;
if (bk == nkind.N_TSLICE) { elemtn = tn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = tn.lhs; };
};
};
};
@@ -7461,12 +7452,10 @@ fn cgassign(c: *cgen, n: *node) void = {
let lc: *local = localfindnode(c, idxbase.str);
if (lc != nil) { if (lc.tnode != nil) {
let tn: *node = lc.tnode;
let elemt: *node = nil;
let baseisarray: bool = false;
let tk: nkind = tn.kind;
if (tk == nkind.N_TSLICE) { elemt = tn.lhs; };
if (tk == nkind.N_TARRAY) { elemt = tn.lhs; baseisarray = true; };
if (tk == nkind.N_TPTR) { elemt = tn.lhs; };
// idxelemtn: `*[N]T` drills to the pointee
// array's element (#61).
let elemt: *node = idxelemtn(tn);
let baseisarray: bool = tn.kind == nkind.N_TARRAY;
let sname: str;
sname.ptr = nil; sname.len = 0;
let viaptr: bool = false;

107
selfhost/cmd/wcc/cgenutil.ww
View File

@@ -1026,11 +1026,9 @@ fn nodeisstr(c: *cgen, n: *node) bool = {
if (lc != nil) { bt = lc.tnode; }
else { bt = letvartnode(c, base.str); };
if (bt != nil) {
let elem: *node = nil;
let bk: nkind = bt.kind;
if (bk == nkind.N_TARRAY) { elem = bt.lhs; };
if (bk == nkind.N_TSLICE) { elem = bt.lhs; };
if (bk == nkind.N_TPTR) { elem = bt.lhs; };
// idxelemtn: `*[N]T` drills to the pointee
// array's element (#61).
let elem: *node = idxelemtn(bt);
if (elem != nil) {
return isstrtype(c, elem);
};
@@ -1072,11 +1070,8 @@ fn nodeisstr(c: *cgen, n: *node) bool = {
if (streq(fi.fname, fld)) {
let ft: *node = fi.tnode;
if (ft != nil) {
let elem: *node = nil;
let fk: nkind = ft.kind;
if (fk == nkind.N_TPTR) { elem = ft.lhs; };
if (fk == nkind.N_TSLICE) { elem = ft.lhs; };
if (fk == nkind.N_TARRAY) { elem = ft.lhs; };
// idxelemtn: `*[N]T` drill (#61).
let elem: *node = idxelemtn(ft);
if (elem != nil) {
return isstrtype(c, elem);
};
@@ -1124,8 +1119,6 @@ fn typeis8byteprimitive(c: *cgen, t: *node) bool = {
// the stamped tinfo so alias/enum recursion lives in lib/ww/typ.ww.
fn elemissignedc(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
// #65 Phase-N step-2 cleanup: peel TY_NAMED before the .sub read.
// #64 now flows per-decl NAMED wrappers, so a NAMED-of-(`*T`/`[]T`/
// `[N]T`) reaching here would read NAMED.sub (nil) instead of the
@@ -1133,7 +1126,10 @@ fn elemissignedc(c: *cgen, t: *node) bool = {
// before the eff->sub read (:3518-3520). Byte-id-neutral: every
// aliased indexable in-tree has a u8 element (typeissigned=false
// either way). Transitive peel matches the #63 idiom.
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti additionally drills `*[N]T` to the pointee array (#61)
// so a signed-narrow element behind a pointer-to-array still
// sign-extends on load.
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeissigned(ti.sub);
};
@@ -1148,9 +1144,8 @@ fn elemissignedc(c: *cgen, t: *node) bool = {
// (the unstamped-base trap that broke the exprfloatkind collapse, #121).
fn elemisfloatc(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti = TY_NAMED peel + the `*[N]T` drill (#61).
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeisfloat(ti.sub);
};
@@ -1159,9 +1154,8 @@ fn elemisfloatc(c: *cgen, t: *node) bool = {
// so cgindex picks MOVSS over MOVSD at the #119 element load.
fn elemisf32c(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti = TY_NAMED peel + the `*[N]T` drill (#61).
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeisf32(ti.sub);
};
@@ -1295,6 +1289,46 @@ export fn localloadop(c: *cgen, tnode: *node) str = {
return loadopsz(sigd, sz);
};
// idxeffti — element-effective tinfo for indexing. `*[N]T` auto-derefs
// at an index base, so its esz/element classification must come from
// the pointee ARRAY (stride T), not from the pointer (whose .sub is
// the whole [N]T — the #61 stride bug, N*size(T) off target per index
// step). One peel choke-point: every tinfo-keyed index-element answer
// (elemsizeofc / elemissignedc / elemisfloatc / elemisf32c) routes
// through here. Mirrors cstage idx_eff (cmd/w6c/cgen.c:1163).
fn idxeffti(t0: *tinfo) *tinfo = {
let t: *tinfo = t0;
for (t != nil && t.kind == tykind.TY_NAMED) { t = t.under; };
if (t != nil && t.kind == tykind.TY_PTR) {
let p: *tinfo = t.sub;
for (p != nil && p.kind == tykind.TY_NAMED) { p = p.under; };
if (p != nil && p.kind == tykind.TY_ARRAY) { return p; };
};
return t;
};
// idxelemtn — element type-NODE for an indexable base tnode, the
// node-keyed companion of idxeffti for the cgen arms that classify
// the element structurally (istaggedtype / isstrtype / isslicetype /
// isfloattype / tnodestoreop). Same `*[N]T` drill: the pointee array's
// OWN element, never the array (#61 — an undrilled elemtn made the
// store-width chooser believe the element IS `[N]T` and emit an
// N*8-byte aggregate copy from an 8B source: caller-frame smash).
// nil for non-indexable kinds (str N_TNAME: callers want nil so
// tnodestoreop falls to the u8 byte store).
fn idxelemtn(tn: *node) *node = {
if (tn == nil) { return nil; };
let k: nkind = tn.kind;
if (k != nkind.N_TARRAY && k != nkind.N_TSLICE
&& k != nkind.N_TPTR) { return nil; };
let elem: *node = tn.lhs;
if (k == nkind.N_TPTR && elem != nil
&& elem.kind == nkind.N_TARRAY) {
return elem.lhs;
};
return elem;
};
// elemsizeof — given the type node of an indexable (`*T`, `[]T`,
// `[N]T`, `str`), return the byte size of one element (1 for u8/i8/
// bool/str-byte, 8 otherwise — same shape as C cgen's esz fallback).
@@ -1364,9 +1398,15 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = {
// sub-array stride $12. Mirror cstage esz = idx_eff(bt)->sub->size
// (cmd/w6c/cgen.c:4923): the element-array tinfo's natural size
// (sub.size*elen, type.c:121) IS the outer stride.
// N_TPTR is excluded (#61): a pointee-array is NOT a nested
// element — `p[i]` on `*[N]T` auto-derefs and strides the array's
// OWN element (idx_eff peels TY_PTR→TY_ARRAY before the .sub
// read). Routing it through this whole-sub-array rule scaled
// every index by N*size(T) — the siphash round() corruption. The
// `*[N][M]T` outer stride still resolves below via idxeffti
// (pointee array's .sub = [M]T, its natural size).
let nk: nkind = t.kind;
let nest: *node = nil;
if (nk == nkind.N_TPTR) { nest = t.lhs; };
if (nk == nkind.N_TSLICE) { nest = t.lhs; };
if (nk == nkind.N_TARRAY) { nest = t.lhs; };
if (nest != nil && nest.kind == nkind.N_TARRAY) {
@@ -1387,20 +1427,16 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = {
// and the local-array-init STORE (frame-smash). Peel TY_NAMED on the
// indexable and on its element, matching the #270-2 nested-array block
// above. Structural slotsize fallback stays for the t.type_==nil case.
let ti: *tinfo = t.type_: *tinfo;
// idxeffti folds that peel together with the `*[N]T` TY_PTR→
// TY_ARRAY drill (#61) so .sub is the array's element, never the
// whole pointee array.
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti != nil) {
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
if (ti != nil) {
let esub: *tinfo = ti.sub;
for (esub != nil && esub.kind == tykind.TY_NAMED) { esub = esub.under; };
if (esub != nil) { return esub.size: i32; };
};
let esub: *tinfo = ti.sub;
for (esub != nil && esub.kind == tykind.TY_NAMED) { esub = esub.under; };
if (esub != nil) { return esub.size: i32; };
};
let k: nkind = t.kind;
let elem: *node = nil;
if (k == nkind.N_TPTR) { elem = t.lhs; };
if (k == nkind.N_TSLICE) { elem = t.lhs; };
if (k == nkind.N_TARRAY) { elem = t.lhs; };
let elem: *node = idxelemtn(t);
if (elem == nil) { return direct; };
if (elem.kind == nkind.N_TNAME) {
let ps: i32 = primsize(elem.str);
@@ -2293,11 +2329,8 @@ fn matchscrutt(c: *cgen, scrut: *node) *node = {
if (bl != nil) { btn = bl.tnode; }
else { btn = letvartnode(c, ibase.str); };
if (btn == nil) { return nil; };
let bk: nkind = btn.kind;
let etn: *node = nil;
if (bk == nkind.N_TARRAY) { etn = btn.lhs; };
if (bk == nkind.N_TSLICE) { etn = btn.lhs; };
if (bk == nkind.N_TPTR) { etn = btn.lhs; };
// idxelemtn: `*[N]T` drills to the pointee array's element (#61).
let etn: *node = idxelemtn(btn);
if (etn == nil) { return nil; };
return resolvetagged(c, etn);
};

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

@@ -3116,6 +3116,11 @@ fn exprtype(c: *checker, e: *node, hint: *node) *node = {
return tn;
};
};
// Retained divergence: *[N]T does NOT decay here —
// `p[lo:hi]` types as [][N]T (C-pointer-slicing), unlike
// the index route (idxeffti) and unlike Hare. Loud on the
// usual []T annotation; for-range likewise. Team task #18
// (#61-residual A).
if (bu.kind == nkind.N_TPTR && bu.lhs != nil) {
let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
sl.lhs = bu.lhs;

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

@@ -13443,6 +13443,11 @@ fn exprtype(c: *checker, e: *node, hint: *node) *node = {
return tn;
};
};
// Retained divergence: *[N]T does NOT decay here —
// `p[lo:hi]` types as [][N]T (C-pointer-slicing), unlike
// the index route (idxeffti) and unlike Hare. Loud on the
// usual []T annotation; for-range likewise. Team task #18
// (#61-residual A).
if (bu.kind == nkind.N_TPTR && bu.lhs != nil) {
let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
sl.lhs = bu.lhs;
@@ -16942,11 +16947,9 @@ fn nodeisstr(c: *cgen, n: *node) bool = {
if (lc != nil) { bt = lc.tnode; }
else { bt = letvartnode(c, base.str); };
if (bt != nil) {
let elem: *node = nil;
let bk: nkind = bt.kind;
if (bk == nkind.N_TARRAY) { elem = bt.lhs; };
if (bk == nkind.N_TSLICE) { elem = bt.lhs; };
if (bk == nkind.N_TPTR) { elem = bt.lhs; };
// idxelemtn: `*[N]T` drills to the pointee
// array's element (#61).
let elem: *node = idxelemtn(bt);
if (elem != nil) {
return isstrtype(c, elem);
};
@@ -16988,11 +16991,8 @@ fn nodeisstr(c: *cgen, n: *node) bool = {
if (streq(fi.fname, fld)) {
let ft: *node = fi.tnode;
if (ft != nil) {
let elem: *node = nil;
let fk: nkind = ft.kind;
if (fk == nkind.N_TPTR) { elem = ft.lhs; };
if (fk == nkind.N_TSLICE) { elem = ft.lhs; };
if (fk == nkind.N_TARRAY) { elem = ft.lhs; };
// idxelemtn: `*[N]T` drill (#61).
let elem: *node = idxelemtn(ft);
if (elem != nil) {
return isstrtype(c, elem);
};
@@ -17040,8 +17040,6 @@ fn typeis8byteprimitive(c: *cgen, t: *node) bool = {
// the stamped tinfo so alias/enum recursion lives in lib/ww/typ.ww.
fn elemissignedc(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
// #65 Phase-N step-2 cleanup: peel TY_NAMED before the .sub read.
// #64 now flows per-decl NAMED wrappers, so a NAMED-of-(`*T`/`[]T`/
// `[N]T`) reaching here would read NAMED.sub (nil) instead of the
@@ -17049,7 +17047,10 @@ fn elemissignedc(c: *cgen, t: *node) bool = {
// before the eff->sub read (:3518-3520). Byte-id-neutral: every
// aliased indexable in-tree has a u8 element (typeissigned=false
// either way). Transitive peel matches the #63 idiom.
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti additionally drills `*[N]T` to the pointee array (#61)
// so a signed-narrow element behind a pointer-to-array still
// sign-extends on load.
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeissigned(ti.sub);
};
@@ -17064,9 +17065,8 @@ fn elemissignedc(c: *cgen, t: *node) bool = {
// (the unstamped-base trap that broke the exprfloatkind collapse, #121).
fn elemisfloatc(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti = TY_NAMED peel + the `*[N]T` drill (#61).
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeisfloat(ti.sub);
};
@@ -17075,9 +17075,8 @@ fn elemisfloatc(c: *cgen, t: *node) bool = {
// so cgindex picks MOVSS over MOVSD at the #119 element load.
fn elemisf32c(c: *cgen, t: *node) bool = {
if (t == nil) { return false; };
let ti: *tinfo = t.type_: *tinfo;
if (ti == nil) { return false; };
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
// idxeffti = TY_NAMED peel + the `*[N]T` drill (#61).
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti == nil) { return false; };
return typeisf32(ti.sub);
};
@@ -17211,6 +17210,46 @@ export fn localloadop(c: *cgen, tnode: *node) str = {
return loadopsz(sigd, sz);
};
// idxeffti — element-effective tinfo for indexing. `*[N]T` auto-derefs
// at an index base, so its esz/element classification must come from
// the pointee ARRAY (stride T), not from the pointer (whose .sub is
// the whole [N]T — the #61 stride bug, N*size(T) off target per index
// step). One peel choke-point: every tinfo-keyed index-element answer
// (elemsizeofc / elemissignedc / elemisfloatc / elemisf32c) routes
// through here. Mirrors cstage idx_eff (cmd/w6c/cgen.c:1163).
fn idxeffti(t0: *tinfo) *tinfo = {
let t: *tinfo = t0;
for (t != nil && t.kind == tykind.TY_NAMED) { t = t.under; };
if (t != nil && t.kind == tykind.TY_PTR) {
let p: *tinfo = t.sub;
for (p != nil && p.kind == tykind.TY_NAMED) { p = p.under; };
if (p != nil && p.kind == tykind.TY_ARRAY) { return p; };
};
return t;
};
// idxelemtn — element type-NODE for an indexable base tnode, the
// node-keyed companion of idxeffti for the cgen arms that classify
// the element structurally (istaggedtype / isstrtype / isslicetype /
// isfloattype / tnodestoreop). Same `*[N]T` drill: the pointee array's
// OWN element, never the array (#61 — an undrilled elemtn made the
// store-width chooser believe the element IS `[N]T` and emit an
// N*8-byte aggregate copy from an 8B source: caller-frame smash).
// nil for non-indexable kinds (str N_TNAME: callers want nil so
// tnodestoreop falls to the u8 byte store).
fn idxelemtn(tn: *node) *node = {
if (tn == nil) { return nil; };
let k: nkind = tn.kind;
if (k != nkind.N_TARRAY && k != nkind.N_TSLICE
&& k != nkind.N_TPTR) { return nil; };
let elem: *node = tn.lhs;
if (k == nkind.N_TPTR && elem != nil
&& elem.kind == nkind.N_TARRAY) {
return elem.lhs;
};
return elem;
};
// elemsizeof — given the type node of an indexable (`*T`, `[]T`,
// `[N]T`, `str`), return the byte size of one element (1 for u8/i8/
// bool/str-byte, 8 otherwise — same shape as C cgen's esz fallback).
@@ -17280,9 +17319,15 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = {
// sub-array stride $12. Mirror cstage esz = idx_eff(bt)->sub->size
// (cmd/w6c/cgen.c:4923): the element-array tinfo's natural size
// (sub.size*elen, type.c:121) IS the outer stride.
// N_TPTR is excluded (#61): a pointee-array is NOT a nested
// element — `p[i]` on `*[N]T` auto-derefs and strides the array's
// OWN element (idx_eff peels TY_PTR→TY_ARRAY before the .sub
// read). Routing it through this whole-sub-array rule scaled
// every index by N*size(T) — the siphash round() corruption. The
// `*[N][M]T` outer stride still resolves below via idxeffti
// (pointee array's .sub = [M]T, its natural size).
let nk: nkind = t.kind;
let nest: *node = nil;
if (nk == nkind.N_TPTR) { nest = t.lhs; };
if (nk == nkind.N_TSLICE) { nest = t.lhs; };
if (nk == nkind.N_TARRAY) { nest = t.lhs; };
if (nest != nil && nest.kind == nkind.N_TARRAY) {
@@ -17303,20 +17348,16 @@ fn elemsizeofc(c: *cgen, t: *node) i32 = {
// and the local-array-init STORE (frame-smash). Peel TY_NAMED on the
// indexable and on its element, matching the #270-2 nested-array block
// above. Structural slotsize fallback stays for the t.type_==nil case.
let ti: *tinfo = t.type_: *tinfo;
// idxeffti folds that peel together with the `*[N]T` TY_PTR→
// TY_ARRAY drill (#61) so .sub is the array's element, never the
// whole pointee array.
let ti: *tinfo = idxeffti(t.type_: *tinfo);
if (ti != nil) {
for (ti != nil && ti.kind == tykind.TY_NAMED) { ti = ti.under; };
if (ti != nil) {
let esub: *tinfo = ti.sub;
for (esub != nil && esub.kind == tykind.TY_NAMED) { esub = esub.under; };
if (esub != nil) { return esub.size: i32; };
};
let esub: *tinfo = ti.sub;
for (esub != nil && esub.kind == tykind.TY_NAMED) { esub = esub.under; };
if (esub != nil) { return esub.size: i32; };
};
let k: nkind = t.kind;
let elem: *node = nil;
if (k == nkind.N_TPTR) { elem = t.lhs; };
if (k == nkind.N_TSLICE) { elem = t.lhs; };
if (k == nkind.N_TARRAY) { elem = t.lhs; };
let elem: *node = idxelemtn(t);
if (elem == nil) { return direct; };
if (elem.kind == nkind.N_TNAME) {
let ps: i32 = primsize(elem.str);
@@ -18209,11 +18250,8 @@ fn matchscrutt(c: *cgen, scrut: *node) *node = {
if (bl != nil) { btn = bl.tnode; }
else { btn = letvartnode(c, ibase.str); };
if (btn == nil) { return nil; };
let bk: nkind = btn.kind;
let etn: *node = nil;
if (bk == nkind.N_TARRAY) { etn = btn.lhs; };
if (bk == nkind.N_TSLICE) { etn = btn.lhs; };
if (bk == nkind.N_TPTR) { etn = btn.lhs; };
// idxelemtn: `*[N]T` drills to the pointee array's element (#61).
let etn: *node = idxelemtn(btn);
if (etn == nil) { return nil; };
return resolvetagged(c, etn);
};
@@ -21805,6 +21843,9 @@ fn cgindex(c: *cgen, n: *node) void = {
// path when the base is a bare ident (mem.ww shape).
let base: *node = n.lhs;
let idx: *node = n.rhs;
// Direct non-ident index bases that match none of the typed arms
// below (e.g. a cast-expression base) keep this 8B default —
// cs!=ww for narrow elements. Team task #19 (#61-residual B).
let esz: i32 = 8;
let signed_elem: bool = false;
// #119: float element loads route to MOVSS/MOVSD into X0, not the
@@ -21928,22 +21969,14 @@ fn cgindex(c: *cgen, n: *node) void = {
if (base.kind == nkind.N_IDENT) {
let bl: *local = baselocal;
let etn: *node = nil;
// idxelemtn drills `*[N]T` to the pointee array's own
// element (#61) — an undrilled etn classified the whole
// array, missing tagged/str/slice elements behind a
// pointer-to-array base.
if (bl != nil) {
let btn: *node = bl.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { etn = btn.lhs; };
if (bk == nkind.N_TSLICE) { etn = btn.lhs; };
if (bk == nkind.N_TPTR) { etn = btn.lhs; };
};
etn = idxelemtn(bl.tnode);
} else {
let tn: *node = letvartnode(c, base.str);
if (tn != nil) {
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) { etn = tn.lhs; };
if (bk == nkind.N_TSLICE) { etn = tn.lhs; };
if (bk == nkind.N_TPTR) { etn = tn.lhs; };
};
etn = idxelemtn(letvartnode(c, base.str));
};
if (istaggedtype(c, etn)) {
if (!isnullabletype(etn)) {
@@ -27162,13 +27195,12 @@ fn cgassign(c: *cgen, n: *node) void = {
baselocal = localfindnode(c, bn);
if (baselocal != nil) {
esz = elemsizeofc(c, baselocal.tnode);
let btn: *node = baselocal.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { elemtn = btn.lhs; };
if (bk == nkind.N_TSLICE) { elemtn = btn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = btn.lhs; };
};
// idxelemtn drills `*[N]T` to the pointee
// array's element (#61): an undrilled elemtn
// made the width chooser believe the element
// IS the whole array (N*8B aggregate copy
// from an 8B source — frame smash).
elemtn = idxelemtn(baselocal.tnode);
} else {
// #11: store/compound twin of the #10 cgindex
// read fix. A global str/slice element store hit
@@ -27190,14 +27222,13 @@ fn cgassign(c: *cgen, n: *node) void = {
if (tn != nil) {
globalname = bn;
esz = elemsizeofc(c, tn);
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) {
// idxelemtn: `*[N]T` drill, see the
// local branch above (#61).
elemtn = idxelemtn(tn);
if (tn.kind == nkind.N_TARRAY) {
isglobalarr = true;
elemtn = tn.lhs;
} else {
isglobalptr = true;
if (bk == nkind.N_TSLICE) { elemtn = tn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = tn.lhs; };
};
};
};
@@ -27609,13 +27640,12 @@ fn cgassign(c: *cgen, n: *node) void = {
baselocal = localfindnode(c, bn);
if (baselocal != nil) {
esz = elemsizeofc(c, baselocal.tnode);
let btn: *node = baselocal.tnode;
if (btn != nil) {
let bk: nkind = btn.kind;
if (bk == nkind.N_TARRAY) { elemtn = btn.lhs; };
if (bk == nkind.N_TSLICE) { elemtn = btn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = btn.lhs; };
};
// idxelemtn drills `*[N]T` to the pointee
// array's element (#61): an undrilled elemtn
// made the width chooser believe the element
// IS the whole array (N*8B aggregate copy
// from an 8B source — frame smash).
elemtn = idxelemtn(baselocal.tnode);
} else {
// #11: store/compound twin of the #10 cgindex
// read fix. A global str/slice element store hit
@@ -27637,14 +27667,13 @@ fn cgassign(c: *cgen, n: *node) void = {
if (tn != nil) {
globalname = bn;
esz = elemsizeofc(c, tn);
let bk: nkind = tn.kind;
if (bk == nkind.N_TARRAY) {
// idxelemtn: `*[N]T` drill, see the
// local branch above (#61).
elemtn = idxelemtn(tn);
if (tn.kind == nkind.N_TARRAY) {
isglobalarr = true;
elemtn = tn.lhs;
} else {
isglobalptr = true;
if (bk == nkind.N_TSLICE) { elemtn = tn.lhs; };
if (bk == nkind.N_TPTR) { elemtn = tn.lhs; };
};
};
};
@@ -27795,12 +27824,10 @@ fn cgassign(c: *cgen, n: *node) void = {
let lc: *local = localfindnode(c, idxbase.str);
if (lc != nil) { if (lc.tnode != nil) {
let tn: *node = lc.tnode;
let elemt: *node = nil;
let baseisarray: bool = false;
let tk: nkind = tn.kind;
if (tk == nkind.N_TSLICE) { elemt = tn.lhs; };
if (tk == nkind.N_TARRAY) { elemt = tn.lhs; baseisarray = true; };
if (tk == nkind.N_TPTR) { elemt = tn.lhs; };
// idxelemtn: `*[N]T` drills to the pointee
// array's element (#61).
let elemt: *node = idxelemtn(tn);
let baseisarray: bool = tn.kind == nkind.N_TARRAY;
let sname: str;
sname.ptr = nil; sname.len = 0;
let viaptr: bool = false;

383
test/wcc/949_ptrarr_index_run.c Normal file
View File

@@ -0,0 +1,383 @@
/*
* 949_ptrarr_index_run — runtime + byte-id net for #61: indexing
* through a pointer-to-array (`p[i]`, p: *[N]T) must stride by
* size(T), the pointee array's ELEMENT, never by the whole-array
* byte size.
*
* The family (one root class):
* A. wwstage value-route scaling — elemsizeofc's #270-2 nested-array
* block (selfhost/cmd/wcc/cgenutil.ww) fed a `*[N]T` pointee into
* the "outer stride = whole sub-array" rule that is only correct
* for [N][M]T / [][M]T. Every read/write/compound through `p[i]`
* scaled by N*size(T) (OOB for any i>=1), and the same wrong
* element belief reached the store-width chooser: a var-idx write
* emitted an N*8-byte aggregate copy sourced at the 8B rhs slot —
* OOB read of the frame neighborhood + OOB write at base+N*8*i,
* caller-frame smash. This is exactly lib/hash/siphash round()'s
* `v[0]=v0 .. v[3]=v3` corruption. cstage was runtime-correct
* (idx_eff, cgen.c:1163, peels TY_PTR→TY_ARRAY); wwstage aligned
* UP via the idxeffti/idxelemtn choke-point.
* B. `&p[i]` addr-of route — BOTH stages identically wrong
* (byte-id-BLIND): the TK_AMP &base[i] arm read bu->sub->size
* without the ptr peel, so &p[3]-&a[0] returned 3*N*size(T).
* Both stages converged on the idx_eff'd element size; only the
* RUNTIME rows here can pin this class — the 990-997 byte-id
* gates can never see a both-stages-identical miscompile.
*
* Each row carries (a) a cstage `ww build` + run asserting the exit
* code and (b) a w6c vs w6c_ww `.s` cmp (rule-10 byte-id). Together
* they pin BOTH stages: byte-id + cstage-runtime-correct implies
* wwstage-runtime-correct. The matrix covers the elem widths the
* scaling class is sensitive to ({1,2,4,8}B), const + var indices,
* param / local / cast bases, read / write / compound routes,
* neighbor-corruption guards, the &p[i] pointer-difference (B), and
* the live consumer's mix-in-place shape (siphash round).
*/
#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;
}
struct row { const char *label; const char *src; int want_exit; };
static const struct row rows[] = {
/* A: read, const idx, param base, 8B elem (ken p2). Pre-fix
* wwstage strode 32 → read past the array. */
{ "rd_u64_param_const",
"package main;\n"
"fn rd(p: *[4]u64) u64 = {\n"
" return p[1];\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u64 = [100u64, 101u64, 102u64, 103u64];\n"
" return rd(&a): i32;\n"
"};\n", 101 },
/* A: read, var idx, 1B elem. */
{ "rd_u8_param_var",
"package main;\n"
"fn rd(p: *[4]u8, i: i32) u8 = {\n"
" return p[i];\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u8 = [10u8, 20u8, 30u8, 40u8];\n"
" return rd(&a, 2): i32;\n"
"};\n", 30 },
/* A: read, 2B elem. */
{ "rd_u16_param",
"package main;\n"
"fn rd(p: *[4]u16) u16 = {\n"
" return p[3];\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u16 = [11u16, 22u16, 33u16, 44u16];\n"
" return rd(&a): i32;\n"
"};\n", 44 },
/* A: read, 4B elem. */
{ "rd_u32_param",
"package main;\n"
"fn rd(p: *[4]u32) u32 = {\n"
" return p[2];\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u32 = [11u32, 22u32, 33u32, 44u32];\n"
" return rd(&a): i32;\n"
"};\n", 33 },
/* A: signed-narrow elem behind the ptr — pins the MOVSXD
* sign-extend the idxeffti'd elemissignedc picks (an undrilled
* read of the ptr tinfo classified the ARRAY: unsigned). */
{ "rd_i32_signed",
"package main;\n"
"fn rd(p: *[4]i32) i32 = {\n"
" return p[1];\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]i32 = [7, -5, 9, 1];\n"
" return rd(&a) + 10;\n"
"};\n", 5 },
/* A: write, const idx (ken p3) — scale-only half. */
{ "wr_u64_param_const",
"package main;\n"
"fn wr(p: *[4]u64) void = {\n"
" p[1] = 7u64;\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u64 = [1u64, 2u64, 3u64, 4u64];\n"
" wr(&a);\n"
" return (a[0] + a[1] + a[2]): i32;\n"
"};\n", 11 },
/* A: write, VAR idx + param rhs (ken p10) — the corruption
* proof: pre-fix wwstage emitted a 32B aggregate copy sourced
* at &x (reading i, p, saved BP) to base+32*i → frame smash /
* SIGSEGV. Neighbor guards assert no byte outside a[1] moved. */
{ "wr_u64_varidx_paramrhs",
"package main;\n"
"fn wr(p: *[4]u64, i: i32, x: u64) void = {\n"
" p[i] = x;\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u64 = [10u64, 11u64, 12u64, 13u64];\n"
" let i: i32 = 1;\n"
" wr(&a, i, 77u64);\n"
" if (a[0] != 10u64) { return 1; };\n"
" if (a[1] != 77u64) { return 2; };\n"
" if (a[2] != 12u64) { return 3; };\n"
" if (a[3] != 13u64) { return 4; };\n"
" return 0;\n"
"};\n", 0 },
/* A: write, 1B elem, neighbor guards at the tightest width. */
{ "wr_u8_neighbors",
"package main;\n"
"fn wr(p: *[4]u8) void = {\n"
" p[1] = 9u8;\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u8 = [1u8, 2u8, 3u8, 4u8];\n"
" wr(&a);\n"
" return (a[0] + a[1] + a[2]): i32;\n"
"};\n", 13 },
/* A: compound, const idx, 8B elem (ken p9b). */
{ "compound_u64",
"package main;\n"
"fn add5(p: *[4]u64) void = {\n"
" p[1] += 5u64;\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u64 = [100u64, 101u64, 102u64, 103u64];\n"
" add5(&a);\n"
" return a[1]: i32;\n"
"};\n", 106 },
/* A: compound, var idx, 4B elem. */
{ "compound_u32_varidx",
"package main;\n"
"fn addat(p: *[4]u32, i: i32) void = {\n"
" p[i] += 7u32;\n"
"};\n"
"export fn main() i32 = {\n"
" let a: [4]u32 = [10u32, 20u32, 30u32, 40u32];\n"
" addat(&a, 2);\n"
" return a[2]: i32;\n"
"};\n", 37 },
/* A: local-ptr base, no call boundary (ken p4). */
{ "rd_localptr",
"package main;\n"
"export fn main() i32 = {\n"
" let a: [4]u64 = [100u64, 101u64, 102u64, 103u64];\n"
" let p: *[4]u64 = &a;\n"
" return p[2]: i32;\n"
"};\n", 102 },
/* A: cast base (ken p6). */
{ "rd_castbase",
"package main;\n"
"export fn main() i32 = {\n"
" let big: [4]u64 = [5u64, 6u64, 7u64, 8u64];\n"
" let p: *[4]u64 = (&big): *[4]u64;\n"
" return p[1]: i32;\n"
"};\n", 6 },
/* A: nested *[2][3]u32 (ken p16) — the elemsizeofc N_TPTR
* carve-out must coexist with the #270-2 outer-stride rule for
* the pointee's OWN nesting: inner stride 4, outer 12. Read,
* write, neighbor guards; param + local ptr bases. */
{ "nested_2d",
"package main;\n"
"fn rd(p: *[2][3]u32, i: i32, j: i32) u32 = { return p[i][j]; };\n"
"export fn main() i32 = {\n"
" let a: [2][3]u32;\n"
" a[0][0] = 0: u32; a[0][1] = 1: u32; a[0][2] = 2: u32;\n"
" a[1][0] = 10: u32; a[1][1] = 11: u32; a[1][2] = 12: u32;\n"
" if (rd(&a, 1, 2) != 12: u32) { return 1; };\n"
" if (rd(&a, 0, 1) != 1: u32) { return 2; };\n"
" let p: *[2][3]u32 = &a;\n"
" p[1][0] = 99: u32;\n"
" if (a[1][0] != 99: u32) { return 3; };\n"
" if (a[1][1] != 11: u32) { return 4; };\n"
" if (a[0][2] != 2: u32) { return 5; };\n"
" return 0;\n"
"};\n", 0 },
/* A: *[3]str — 3-word (ptr,len,cap) header elements; pins the
* read-side str-header gate on the idx_eff'd element. Pre-fix
* BOTH stages were runtime-wrong here, differently: cstage's
* u->sub gate missed the ptr base and dropped len/cap (ken
* p17). */
{ "rd_str_elem",
"package main;\n"
"fn lenof(p: *[3]str, i: i32) i32 = { return p[i].len; };\n"
"export fn main() i32 = {\n"
" let a: [3]str;\n"
" a[0] = \"x\"; a[1] = \"yy\"; a[2] = \"zzz\";\n"
" if (lenof(&a, 2) != 3) { return 1; };\n"
" if (lenof(&a, 0) != 1) { return 2; };\n"
" let p: *[3]str = &a;\n"
" if (p[1].len != 2) { return 3; };\n"
" return 0;\n"
"};\n", 0 },
/* B: &p[i] pointer difference (ken p8b) — both stages emitted
* the whole-array stride (96) byte-IDENTICALLY pre-fix; only
* this runtime row can see the class. 3 * size(u64) = 24. */
{ "amp_diff_u64",
"package main;\n"
"export fn main() i32 = {\n"
" let a: [4]u64 = [1u64, 2u64, 3u64, 4u64];\n"
" let p: *[4]u64 = &a;\n"
" let d: u64 = (&p[3]): u64 - (&a[0]): u64;\n"
" return d: i32;\n"
"};\n", 24 },
/* B: &p[i] difference at a narrow width. 3 * size(u16) = 6. */
{ "amp_diff_u16",
"package main;\n"
"export fn main() i32 = {\n"
" let a: [4]u16 = [1u16, 2u16, 3u16, 4u16];\n"
" let p: *[4]u16 = &a;\n"
" let d: u64 = (&p[3]): u64 - (&a[0]): u64;\n"
" return d: i32;\n"
"};\n", 6 },
/* A: the live consumer's shape — siphash round() mutates all
* four lanes through the param ptr, each read feeding a later
* write. Pre-fix wwstage smashed the caller frame here. */
{ "mix_inplace_round",
"package main;\n"
"fn mix(v: *[4]u64) void = {\n"
" v[0] += v[1];\n"
" v[2] += v[3];\n"
" v[1] += v[0];\n"
" v[3] += v[2];\n"
"};\n"
"export fn main() i32 = {\n"
" let v: [4]u64 = [1u64, 2u64, 3u64, 4u64];\n"
" mix(&v);\n"
" if (v[0] != 3u64) { return 1; };\n"
" if (v[1] != 5u64) { return 2; };\n"
" if (v[2] != 7u64) { return 3; };\n"
" if (v[3] != 11u64) { return 4; };\n"
" return 0;\n"
"};\n", 0 },
{ NULL, NULL, 0 }
};
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);
int cb = fgetc(fb);
if (ca != cb) { rc = -1; break; }
if (ca == EOF) break;
}
fclose(fa); fclose(fb);
return rc;
}
int
main(void)
{
const char *bin = getenv("BIN");
if (!bin) bin = "out/bin";
char absbin[1024];
if (bin[0] != '/') {
char cwd[1024];
if (getcwd(cwd, sizeof cwd) == NULL) return 1;
snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin);
bin = absbin;
}
char w6c[1100], w6c_ww[1100];
snprintf(w6c, sizeof w6c, "%s/w6c", bin);
snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin);
if (access(w6c_ww, X_OK) != 0) {
fprintf(stderr, "ptrarr_index: w6c_ww missing — cannot run "
"the cs==ww byte-id gate\n");
return 1;
}
int n = 0, fail = 0;
for (int i = 0; rows[i].src; i++, n++) {
char src[64];
snprintf(src, sizeof src, "/tmp/wwpai_%d_%d.ww", getpid(), i);
FILE *f = fopen(src, "wb");
if (f == NULL) { fail++; continue; }
fputs(rows[i].src, f);
fclose(f);
/* (a) cstage build + run. */
char tmpdir[64];
snprintf(tmpdir, sizeof tmpdir, "/tmp/wwpai_%d_d_%d",
getpid(), i);
mkdir(tmpdir, 0755);
char cmd[2048];
snprintf(cmd, sizeof cmd, "cd %s && %s/ww build %s",
tmpdir, bin, src);
if (runwait(cmd) != 0) {
fprintf(stderr, "row[%s]: cstage build failed\n",
rows[i].label);
fail++;
unlink(src); rmdir(tmpdir);
continue;
}
char outbin[128];
const char *base = strrchr(src, '/');
base = base ? base + 1 : src;
snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base);
char *dot = strrchr(outbin, '.');
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
int got = runwait(outbin);
if (got != rows[i].want_exit) {
fprintf(stderr, "row[%s]: cstage exit %d, want %d\n",
rows[i].label, got, rows[i].want_exit);
fail++;
}
unlink(outbin); rmdir(tmpdir);
/* (b) cs==ww byte-id gate. */
char cs_s[64], ws_s[64];
snprintf(cs_s, sizeof cs_s, "/tmp/wwpai_%d_%d_cs.s",
getpid(), i);
snprintf(ws_s, sizeof ws_s, "/tmp/wwpai_%d_%d_ww.s",
getpid(), i);
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", rows[i].label);
fail++; unlink(src); continue;
}
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",
rows[i].label);
fail++; unlink(src); unlink(cs_s); continue;
}
if (slurp_eq(cs_s, ws_s) != 0) {
fprintf(stderr,
"row[%s]: cstage/wwstage .s DIFFER (rule-10 "
"byte-id violation)\n", rows[i].label);
fail++;
}
unlink(src); unlink(cs_s); unlink(ws_s);
}
if (fail) {
fprintf(stderr, "%d/%d ptrarr-index tests failed\n", fail, n);
return 1;
}
printf("ptrarr_index: %d/%d ok (cstage run + cs==ww byte-id)\n",
n, n);
return 0;
}

5
test/wcc/989_lib_byteid.c
View File

@@ -73,6 +73,8 @@ static const struct ent ents[] = {
{ .fixture = "lib/hash/crc16/crc16_test.ww", .mode = M_ID },
{ .fixture = "lib/hash/crc32/crc32_test.ww", .mode = M_ID },
{ .fixture = "lib/hash/crc64/crc64_test.ww", .mode = M_ID },
/* graduated from #59.7 DIVERGE by the #61 *[N]T index-stride fix */
{ .fixture = "lib/hash/siphash/siphash_test.ww", .mode = M_ID },
{ .fixture = "lib/math/checked/checked_test.ww", .mode = M_ID },
{ .fixture = "lib/math/random/random_test.ww", .mode = M_ID },
{ .fixture = "lib/memio/memiotest.ww", .mode = M_ID },
@@ -118,8 +120,7 @@ static const struct ent ents[] = {
.mode = M_DIVERGE, .cite = "#59.5" },
{ .fixture = "lib/fmt/fmttest.ww",
.mode = M_DIVERGE, .cite = "#59.6" },
{ .fixture = "lib/hash/siphash/siphash_test.ww",
.mode = M_DIVERGE, .cite = "#59.7" },
/* #59.7 siphash graduated to M_ID above (#61 fix) */
{ .fixture = "lib/log/logtest.ww",
.mode = M_DIVERGE, .cite = "#59.8" },
{ .fixture = "lib/os/stattest.ww",