Hojun-Cho
bf1037d8c4
A one-step `let xs: []T = [e0,e1,..]` had two faults. #31 (silent, cs!=ww): the #258 array→slice borrow wrapped the un-addressable N_ARRLIT directly as the N_SLICE base and cgen never spilled it to a stack slot, so .ptr dangled (`let xs:[]i32=[10,20,30]; xs[1]` returned the un-stored header 1; []u8/[]str segfaulted). #25 (over-strict): a slice target fell through to the exact- element type_eq borrow gate, rejecting bare-int-width ([]u8=[1,2,3]) and str elements the array-init path coerces. Fix (re-stamp + per-borrow scratch; both stages byte-identical asm): - Checker re-stamps the slice arrlit as [count]T, reusing the array-init per-element coercion + range-check (#25): in-range accepts, out-of-range loud-rejects. cstage arrlit_init_fits gains a TY_SLICE arm; wwstage checkletassign mirrors it and stashes the synthesized [count]T tnode on arrlit.lhs (free for N_ARRLIT) so cgen can size the backing NODE-wise (elemsizeofc) and count from the tnode's .rhs intlit — the arrlit's own value tinfo carries the literal's untyped element (unsized), so node-first sizing is required (a cstage/wwstage representation divergence; cstage's Type IS sized and reads base->type). - cgen materialises the N_ARRLIT borrow base into a FRESH per-borrow @slicescr stack slot (distinct slot per borrow: a borrow's backing must outlive the lowering, so it can't share a cached @aggargscr/@tagscr-style slot — two live borrows would alias one backing; localalloc/local_alloc is always-fresh), filled by REUSING the array-init element fill extracted from the N_LET path (cstage cg_arrlit_fill_bp, wwstage cgarrlitfillbp — same store sequence the byte-id-green `let a:[N]T=[..]` uses, the frame-order + store-op guarantee), then LEAQ'd as the base. Supported ONLY at a `let` init. In call-arg / return / assign position there is no addressable backing, so both stages LOUD-REJECT ("bind it to a `let` first") — aligning cstage DOWN to wwstage (which already refused the untyped arrlit element) per rule-10; this closes #31's silent call-arg segfault as a compile error. Full non-let support is deferred (#33). Escape (rule-8 WHY): a `let xs:[]T=[..]; return xs;` returns a slice into a freed frame slot = dangling, IDENTICAL to the pre-existing named-array borrow and Hare-consistent (no escape analysis / GC / heap promotion). Test 953_arrlit_slice_run: 8 accept rows (cstage runtime readback + cs==ww byte-id, frame-size canary incl.) covering the #31 i32 pin, bare-int→u8 coercion, str readback, the multi-live soundness pin (xs[0]+ys[0]=5, not 8 — proves fresh-per-borrow), and a mutate-through-borrow proof; 4 reject rows (out-of-range element + the three non-let contexts, loud in both stages). Tuple-element slices stay blocked by the pre-existing #30 array-init FATAL.
281 lines
8.7 KiB
C
281 lines
8.7 KiB
C
/*
|
|
* 953_arrlit_slice_run — runtime + byte-id + reject net for #25/#31: a
|
|
* one-step array-LITERAL initialiser for a SLICE local (`let xs:[]T=[..]`).
|
|
*
|
|
* #31 (silent miscompile, cs!=ww): the #258 array→slice borrow wrapped the
|
|
* un-addressable N_ARRLIT directly as the N_SLICE base; cgen never spilled
|
|
* the literal to a stack slot, so .ptr pointed at garbage (`let xs:[]i32=
|
|
* [10,20,30]; xs[1]` returned 1; []u8/[]str segfaulted). #25 (over-strict
|
|
* reject): a slice target fell through to the exact-element type_eq borrow
|
|
* gate, so bare-int-width ([]u8=[1,2,3]) and str elements rejected.
|
|
*
|
|
* Fix (re-stamp + per-borrow scratch, both stages symmetric, NO new codegen
|
|
* shape): the checker re-stamps the slice arrlit as [count]T (per-element
|
|
* coercion + range-check, #25); cgen materialises the borrow base into a
|
|
* FRESH per-borrow @slicescr stack slot (distinct slot per borrow — a
|
|
* borrow's backing outlives the lowering, so it can't share a cached slot;
|
|
* two live borrows would otherwise alias one backing), filled via the shared
|
|
* array-init element store (#31). Supported ONLY at a `let` init — in
|
|
* call-arg / return / assign position there is no addressable backing, so
|
|
* both stages LOUD-REJECT ("bind it to a `let` first"), aligning cstage DOWN
|
|
* to wwstage per rule-10; full non-let support is deferred (#33).
|
|
*
|
|
* Accept rows (cstage `ww build` + run for exit code, then w6c vs w6c_ww .s
|
|
* cmp for the rule-10 byte-id gate):
|
|
* - i32_sum let xs:[]i32=[10,20,30]; xs[0]+xs[1]+xs[2] → 60
|
|
* - i32_idx xs[1] (the #31 pin: was 1, want 20) → 20
|
|
* - u8_coerce let zs:[]u8=[1,2,3]; bare-int→u8 width (#25) → 6
|
|
* - u8_typed let xs:[]u8=[10u8,20u8,30u8]; xs[2] → 30
|
|
* - i64_stride let xs:[]i64=[7i64,42i64]; xs[1] (8B stride) → 42
|
|
* - str_read let ys:[]str=["ab","c"]; ys[0].len*10+ys[1].len → 21
|
|
* - len_read let xs:[]i32=[10,20,30]; xs.len → 3
|
|
* - multi_live let xs=[1,2,3]; let ys=[4,5]; xs[0]+ys[0] → 5
|
|
* (SOUNDNESS PIN: fresh-per-borrow; a shared slot → 4+4=8)
|
|
* - borrow_mut xs[1]=99 through the borrow, read back → 99
|
|
*
|
|
* Reject rows (cs==ww symmetric loud-reject, both w6c and w6c_ww non-zero):
|
|
* - reject_oob let q:[]u8=[256,1] → out-of-range element (#25)
|
|
* - reject_call sum([1,2,3]) → non-let borrow (#31/#33)
|
|
* - reject_ret return [1,2,3] → non-let borrow
|
|
* - reject_assign s = [1,2,3] → non-let borrow
|
|
*/
|
|
#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"), *fb = fopen(b, "rb");
|
|
if (fa == NULL || fb == NULL) {
|
|
if (fa) fclose(fa);
|
|
if (fb) fclose(fb);
|
|
return -1;
|
|
}
|
|
int ca, cb, eq = 0;
|
|
do {
|
|
ca = fgetc(fa);
|
|
cb = fgetc(fb);
|
|
if (ca != cb) { eq = -1; break; }
|
|
} while (ca != EOF);
|
|
fclose(fa);
|
|
fclose(fb);
|
|
return eq;
|
|
}
|
|
|
|
struct row { const char *label; const char *src; int want_exit; int reject; };
|
|
|
|
static const struct row rows[] = {
|
|
{ "i32_sum",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []i32 = [10, 20, 30];\n"
|
|
" return xs[0] + xs[1] + xs[2];\n"
|
|
"};\n", 60, 0 },
|
|
{ "i32_idx",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []i32 = [10, 20, 30];\n"
|
|
" return xs[1];\n"
|
|
"};\n", 20, 0 },
|
|
{ "u8_coerce",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let zs: []u8 = [1, 2, 3];\n"
|
|
" return zs[0]: i32 + zs[1]: i32 + zs[2]: i32;\n"
|
|
"};\n", 6, 0 },
|
|
{ "u8_typed",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []u8 = [10u8, 20u8, 30u8];\n"
|
|
" return xs[2]: i32;\n"
|
|
"};\n", 30, 0 },
|
|
{ "i64_stride",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []i64 = [7i64, 42i64];\n"
|
|
" return xs[1]: i32;\n"
|
|
"};\n", 42, 0 },
|
|
{ "str_read",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let ys: []str = [\"ab\", \"c\"];\n"
|
|
" return ys[0].len: i32 * 10 + ys[1].len: i32;\n"
|
|
"};\n", 21, 0 },
|
|
{ "len_read",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []i32 = [10, 20, 30];\n"
|
|
" return xs.len: i32;\n"
|
|
"};\n", 3, 0 },
|
|
{ "multi_live",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []i32 = [1, 2, 3];\n"
|
|
" let ys: []i32 = [4, 5];\n"
|
|
" return xs[0] + ys[0];\n"
|
|
"};\n", 5, 0 },
|
|
{ "borrow_mut",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let xs: []i32 = [1, 2, 3];\n"
|
|
" xs[1] = 99;\n"
|
|
" return xs[1];\n"
|
|
"};\n", 99, 0 },
|
|
/* Reject rows: out-of-range element + the three non-let contexts. */
|
|
{ "reject_oob",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let q: []u8 = [256, 1];\n"
|
|
" return q[0]: i32;\n"
|
|
"};\n", 0, 1 },
|
|
{ "reject_call",
|
|
"package main;\n"
|
|
"fn sum(s: []i32) i32 = { return s[0]; };\n"
|
|
"export fn main() i32 = {\n"
|
|
" return sum([1, 2, 3]);\n"
|
|
"};\n", 0, 1 },
|
|
{ "reject_ret",
|
|
"package main;\n"
|
|
"fn mk() []i32 = { return [1, 2, 3]; };\n"
|
|
"export fn main() i32 = {\n"
|
|
" return mk()[0];\n"
|
|
"};\n", 0, 1 },
|
|
{ "reject_assign",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let s: []i32 = [0, 0];\n"
|
|
" s = [1, 2, 3];\n"
|
|
" return s[0];\n"
|
|
"};\n", 0, 1 },
|
|
{ NULL, NULL, 0, 0 },
|
|
};
|
|
|
|
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, "arrlit_slice: w6c_ww missing — cannot run the "
|
|
"cs==ww byte-id gate (the whole point of this test)\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/wwas_%d_%d.ww", getpid(), i);
|
|
FILE *f = fopen(src, "wb");
|
|
if (f == NULL) { fail++; continue; }
|
|
fputs(rows[i].src, f);
|
|
fclose(f);
|
|
|
|
char cs_s[64], ws_s[64];
|
|
snprintf(cs_s, sizeof cs_s, "/tmp/wwas_%d_%d_cs.s", getpid(), i);
|
|
snprintf(ws_s, sizeof ws_s, "/tmp/wwas_%d_%d_ww.s", getpid(), i);
|
|
char cmd[2048];
|
|
|
|
if (rows[i].reject) {
|
|
/* Both stages must refuse (non-zero). */
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null",
|
|
w6c, cs_s, src);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "row[%s]: w6c ACCEPTED a row that "
|
|
"must reject\n", rows[i].label);
|
|
fail++;
|
|
}
|
|
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 ACCEPTED a row "
|
|
"that must reject\n", rows[i].label);
|
|
fail++;
|
|
}
|
|
unlink(src); unlink(cs_s); unlink(ws_s);
|
|
continue;
|
|
}
|
|
|
|
/* Positive row: cstage build + run for exit code. */
|
|
char tmpdir[64];
|
|
snprintf(tmpdir, sizeof tmpdir, "/tmp/wwas_%d_d_%d",
|
|
getpid(), i);
|
|
mkdir(tmpdir, 0755);
|
|
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);
|
|
|
|
/* rule-10 byte-id: w6c vs w6c_ww .s. */
|
|
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 arrlit-slice tests failed\n", fail, n);
|
|
return 1;
|
|
}
|
|
printf("arrlit_slice: %d/%d ok (cstage run + cs==ww byte-id + "
|
|
"reject)\n", n, n);
|
|
return 0;
|
|
}
|