Hojun-Cho
65a6cac6a0
test/run fans test/wcc/*.c across $(nproc) workers via xargs -0 -n2 -P $JOBS; each worker writes <prefix>.status and an optional <prefix>.fail sentinel into a mktemp results dir. The driver collects in glob order so output stays deterministic across runs. Wraps every ww/w6c/w6a/w6l/wwdump invocation in 990-995 with `timeout 180`, bounding orphan compilers under 8-way contention. The direct runwait(exe) calls for fresh-built test binaries get the same treatment via a "timeout 180 %s" snprintf hop. Motivation: pid 2101 was a w6c_ww that ran 42h on /tmp/wcas_asm_1326_15.ww until we killed it during this session; timeout makes that impossible. 993's /tmp/ww_d_hello.ww is now pid-keyed (snprintf %d getpid); without it concurrent runs (or future shards of 993 itself) would race on the staging file. Wall: 9m59s → 4m31s on 8 cores. Same 132/132 status.
298 lines
8.4 KiB
C
298 lines
8.4 KiB
C
/*
|
|
* 994_w6c_ww — phase-10 marker for the ww-side w6c port.
|
|
*
|
|
* w6c_ww is a thin packaging of selfhost/cmd/wcc/cgen.ww: it slurps a
|
|
* .ww file, runs lex+parse+cgen, and writes Plan 9 amd64 asm to the
|
|
* file given by -o. The same cgen is reached through `wwdump_ww -c`,
|
|
* so w6c_ww must produce byte-identical output to wwdump_ww -c on
|
|
* every program — this test pins that.
|
|
*
|
|
* (We do not diff against C-side `w6c` here because the C compiler has
|
|
* features the ww cgen has not yet ported — float compare, fn-address
|
|
* @symbol, indirect call. Test 990 probe 5 covers the C-vs-ww diff on
|
|
* the subset that the ww cgen handles today.)
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.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 const char *
|
|
absbin(void)
|
|
{
|
|
const char *b = getenv("BIN");
|
|
if (!b) b = "out/bin";
|
|
if (b[0] == '/') return b;
|
|
static char buf[2048];
|
|
char cwd[1024];
|
|
if (getcwd(cwd, sizeof cwd) == NULL) return NULL;
|
|
snprintf(buf, sizeof buf, "%s/%s", cwd, b);
|
|
return buf;
|
|
}
|
|
|
|
static int
|
|
slurp(const char *path, char **outbuf, size_t *outlen)
|
|
{
|
|
FILE *f = fopen(path, "rb");
|
|
if (!f) return -1;
|
|
fseek(f, 0, SEEK_END);
|
|
long n = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
if (n < 0) { fclose(f); return -1; }
|
|
char *b = malloc((size_t)n + 1);
|
|
if (!b) { fclose(f); return -1; }
|
|
if (fread(b, 1, (size_t)n, f) != (size_t)n) { free(b); fclose(f); return -1; }
|
|
b[n] = '\0';
|
|
fclose(f);
|
|
*outbuf = b;
|
|
*outlen = (size_t)n;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
diff_one(const char *bin, const char *label, const char *src)
|
|
{
|
|
char ws[64], cs[64], cmd[2048];
|
|
snprintf(ws, sizeof ws, "/tmp/wwc6_%d_w.s", getpid());
|
|
snprintf(cs, sizeof cs, "/tmp/wwc6_%d_c.s", getpid());
|
|
|
|
snprintf(cmd, sizeof cmd, "timeout 180 %s/wwdump_ww -c %s > %s 2>/dev/null",
|
|
bin, src, ws);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "w6c_ww FAIL: wwdump_ww -c errored on %s\n", label);
|
|
unlink(ws);
|
|
return -1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "timeout 180 %s/w6c_ww -o %s %s 2>/dev/null", bin, cs, src);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "w6c_ww FAIL: w6c_ww errored on %s\n", label);
|
|
unlink(ws); unlink(cs);
|
|
return -1;
|
|
}
|
|
char *bw = NULL, *bc = NULL;
|
|
size_t nw = 0, nc = 0;
|
|
int rc = 0;
|
|
if (slurp(ws, &bw, &nw) < 0 || slurp(cs, &bc, &nc) < 0) {
|
|
fprintf(stderr, "w6c_ww FAIL: cannot read .s for %s\n", label);
|
|
rc = -1;
|
|
} else if (nw != nc || memcmp(bw, bc, nw) != 0) {
|
|
fprintf(stderr, "w6c_ww FAIL: %s — wwdump_ww %zu vs w6c_ww %zu bytes\n",
|
|
label, nw, nc);
|
|
rc = -1;
|
|
}
|
|
free(bw); free(bc);
|
|
unlink(ws); unlink(cs);
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
write_file(const char *path, const char *content)
|
|
{
|
|
FILE *f = fopen(path, "wb");
|
|
if (!f) return -1;
|
|
fputs(content, f);
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
const char *bin = absbin();
|
|
if (!bin) return 1;
|
|
char cwd[1024];
|
|
if (getcwd(cwd, sizeof cwd) == NULL) return 1;
|
|
|
|
/* In-source corpus: programs the ww-side cgen handles today.
|
|
* Mirrors probe 5 in 990_selfhost without the parts that drift
|
|
* against C w6c. */
|
|
struct { const char *label; const char *src; } progs[] = {
|
|
{ "ret42",
|
|
"fn main() i32 = { return 42; };" },
|
|
{ "add",
|
|
"fn add(a: i32, b: i32) i32 = { return a + b; };\n"
|
|
"fn main() i32 = { return add(7, 35); };" },
|
|
{ "sum_for",
|
|
"fn sum(n: i32) i32 = {\n"
|
|
" let s: i32 = 0;\n"
|
|
" let i: i32 = 0;\n"
|
|
" for (i < n) { s += i; i += 1; };\n"
|
|
" return s;\n"
|
|
"};\n"
|
|
"fn main() i32 = { return sum(10); };" },
|
|
{ "if_else",
|
|
"fn check(x: i32) i32 = {\n"
|
|
" if (x > 0) { return 1; };\n"
|
|
" if (x < 0) { return 100; };\n"
|
|
" return 0;\n"
|
|
"};\n"
|
|
"fn main() i32 = { return check(7); };" },
|
|
{ "recursion",
|
|
"fn fact(n: i32) i32 = {\n"
|
|
" if (n <= 1) { return 1; };\n"
|
|
" return n * fact(n - 1);\n"
|
|
"};\n"
|
|
"fn main() i32 = { return fact(5); };" },
|
|
{ "enum",
|
|
"type mode = enum u8 { R = 1, W = 2, RW = R | W };\n"
|
|
"fn main() i32 = {\n"
|
|
" let m: mode = mode.RW;\n"
|
|
" return m as i32;\n"
|
|
"};" },
|
|
{ "switch",
|
|
"fn classify(x: i32) i32 = {\n"
|
|
" switch (x) {\n"
|
|
" case 1, 2, 3: return 10;\n"
|
|
" case 7: return 70;\n"
|
|
" case: return 0;\n"
|
|
" };\n"
|
|
" return -1;\n"
|
|
"};\n"
|
|
"fn main() i32 = { return classify(2); };" },
|
|
{ "append",
|
|
"import os;\n"
|
|
"fn main() i32 = {\n"
|
|
" let s: []u8;\n"
|
|
" s.ptr = nil; s.len = 0; s.cap = 0;\n"
|
|
" append(s, 65u8, 66u8, 67u8);\n"
|
|
" return s.len: i32;\n"
|
|
"};" },
|
|
{ "append_spread",
|
|
"import os;\n"
|
|
"fn main() i32 = {\n"
|
|
" let src: []i64;\n"
|
|
" src.ptr = nil; src.len = 0; src.cap = 0;\n"
|
|
" append(src, 10i64, 20i64);\n"
|
|
" let dst: []i64;\n"
|
|
" dst.ptr = nil; dst.len = 0; dst.cap = 0;\n"
|
|
" append(dst, src...);\n"
|
|
" return dst.len: i32;\n"
|
|
"};" },
|
|
{ "forrange",
|
|
"import os;\n"
|
|
"fn main() i32 = {\n"
|
|
" let s: []u8;\n"
|
|
" s.ptr = nil; s.len = 0; s.cap = 0;\n"
|
|
" append(s, 10u8, 20u8, 30u8);\n"
|
|
" let total: i32 = 0;\n"
|
|
" for (let b .. s) { total += b: i32; };\n"
|
|
" return total;\n"
|
|
"};" },
|
|
{ "forrange_tuple",
|
|
"fn main() i32 = {\n"
|
|
" let buf: [4]i64;\n"
|
|
" buf[0] = 1i64; buf[1] = 10i64; buf[2] = 2i64; buf[3] = 20i64;\n"
|
|
" let s: [](i64, i64);\n"
|
|
" s.ptr = buf.ptr: *(i64, i64);\n"
|
|
" s.len = 2; s.cap = 2;\n"
|
|
" let total: i64 = 0i64;\n"
|
|
" for (let (k, v) .. s) { total += k + v; };\n"
|
|
" return total: i32;\n"
|
|
"};" },
|
|
/* #45: alloc-slice `!` form, []T element ≠ u8. */
|
|
{ "alloc_slice_rune_unw",
|
|
"package main;\n"
|
|
"import rt;\n"
|
|
"fn main() i32 = {\n"
|
|
" let s: []rune = alloc([], 8)!;\n"
|
|
" return s.cap;\n"
|
|
"};" },
|
|
/* #45: alloc-slice `?` form propagates nomem via the
|
|
* enclosing fn's tagged return. */
|
|
{ "alloc_slice_str_prop",
|
|
"package main;\n"
|
|
"import rt;\n"
|
|
"fn doit() (i32 | nomem) = {\n"
|
|
" let s: []str = alloc([], 4)?;\n"
|
|
" return s.cap: i32;\n"
|
|
"};\n"
|
|
"fn main() i32 = { return doit()!; };" },
|
|
{ NULL, NULL },
|
|
};
|
|
|
|
/* Source-tree corpus: the same .combined.ww files the bootstrap
|
|
* fixed point chews on. Confirms w6c_ww handles realistic inputs,
|
|
* not just hand-tailored ones. */
|
|
const char *combined_rel[] = {
|
|
"selfhost/cmd/wwdump/main.combined.ww",
|
|
"selfhost/cmd/w6a/main.combined.ww",
|
|
"selfhost/cmd/w6l/main.combined.ww",
|
|
"selfhost/cmd/ww/main.combined.ww",
|
|
NULL,
|
|
};
|
|
|
|
int fail = 0, n = 0;
|
|
|
|
for (int i = 0; progs[i].label; i++) {
|
|
char src[64];
|
|
snprintf(src, sizeof src, "/tmp/wwc6_%d_%d.ww", getpid(), i);
|
|
if (write_file(src, progs[i].src) != 0) { fail++; n++; continue; }
|
|
if (diff_one(bin, progs[i].label, src) != 0) fail++;
|
|
unlink(src);
|
|
n++;
|
|
}
|
|
for (int i = 0; combined_rel[i]; i++) {
|
|
char p[2048];
|
|
snprintf(p, sizeof p, "%s/%s", cwd, combined_rel[i]);
|
|
if (diff_one(bin, combined_rel[i], p) != 0) fail++;
|
|
n++;
|
|
}
|
|
|
|
/* #50: the check pass is wired into both wwdump_ww -c and
|
|
* w6c_ww in front of cgen. Pre-#50, a hard type error parsed
|
|
* cleanly and reached cgen, which would emit asm with a zero
|
|
* exit (silent miscompile). Pin the rejection by giving each
|
|
* driver a trivially-broken file and demanding non-zero exit. */
|
|
struct { const char *label; const char *src; } bad[] = {
|
|
{ "let_str_to_i32",
|
|
"package main;\n"
|
|
"fn main() i32 = {\n"
|
|
" let x: i32 = \"hello\";\n"
|
|
" return x;\n"
|
|
"};\n" },
|
|
{ NULL, NULL },
|
|
};
|
|
for (int i = 0; bad[i].label; i++) {
|
|
char src[64], wcmd[2048], dcmd[2048], s[64];
|
|
snprintf(src, sizeof src, "/tmp/wwc6_bad_%d_%d.ww", getpid(), i);
|
|
snprintf(s, sizeof s, "/tmp/wwc6_bad_%d_%d.s", getpid(), i);
|
|
if (write_file(src, bad[i].src) != 0) { fail++; n++; continue; }
|
|
snprintf(wcmd, sizeof wcmd,
|
|
"timeout 180 %s/w6c_ww -o %s %s >/dev/null 2>&1", bin, s, src);
|
|
snprintf(dcmd, sizeof dcmd,
|
|
"timeout 180 %s/wwdump_ww -c %s >%s 2>/dev/null", bin, src, s);
|
|
if (runwait(wcmd) == 0) {
|
|
fprintf(stderr,
|
|
"w6c_ww FAIL: %s slipped past check (silent miscompile)\n",
|
|
bad[i].label);
|
|
fail++;
|
|
}
|
|
if (runwait(dcmd) == 0) {
|
|
fprintf(stderr,
|
|
"wwdump_ww -c FAIL: %s slipped past check (silent miscompile)\n",
|
|
bad[i].label);
|
|
fail++;
|
|
}
|
|
unlink(src); unlink(s);
|
|
n++;
|
|
}
|
|
|
|
if (fail) {
|
|
fprintf(stderr, "w6c_ww: %d/%d diff(s) failed\n", fail, n);
|
|
return 1;
|
|
}
|
|
printf("w6c_ww: byte-identical to wwdump_ww -c on %d corpus inputs "
|
|
"(in-source + selfhost combined.ww)\n", n);
|
|
return 0;
|
|
}
|