411 lines
12 KiB
C
411 lines
12 KiB
C
/*
|
|
* w6c_ww and `wwdump_ww -c` reach the same selfhost cgen, so they must
|
|
* produce byte-identical output on every program — this test pins
|
|
* that.
|
|
*
|
|
* (We do not diff against C-side `w6c` here: this carrier's oracle is
|
|
* the wwdump_ww -c TOOL OUTPUT, not the tool binary. The C-vs-ww diff
|
|
* on real programs is owned by the blanket byte-identity gates.)
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <sys/wait.h>
|
|
#include <dirent.h>
|
|
#include "wwtestpkg.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];
|
|
char *bw = NULL, *bc = NULL;
|
|
size_t nw = 0, nc = 0;
|
|
int rc = -1;
|
|
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);
|
|
goto cleanup;
|
|
}
|
|
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);
|
|
goto cleanup;
|
|
}
|
|
if (slurp(ws, &bw, &nw) < 0 || slurp(cs, &bc, &nc) < 0) {
|
|
fprintf(stderr, "w6c_ww FAIL: cannot read .s for %s\n", label);
|
|
} else if (nw == 0) {
|
|
fprintf(stderr, "w6c_ww FAIL: empty .s for %s\n", label);
|
|
} 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);
|
|
} else
|
|
rc = 0;
|
|
|
|
cleanup:
|
|
free(bw); free(bc);
|
|
/* cs may not exist when w6c_ww never ran or died before -o. */
|
|
int cleanfail = 0;
|
|
if (unlink(ws) != 0 && errno != ENOENT) {
|
|
perror(ws);
|
|
cleanfail = 1;
|
|
}
|
|
if (unlink(cs) != 0 && errno != ENOENT) {
|
|
perror(cs);
|
|
cleanfail = 1;
|
|
}
|
|
if (cleanfail && rc == 0)
|
|
rc = -1;
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
write_file(const char *path, const char *content)
|
|
{
|
|
FILE *f = fopen(path, "wb");
|
|
if (!f) return -1;
|
|
wwtest_fputs(content, f);
|
|
/* wwtest_fputs is void; ferror is the only short-write witness. */
|
|
int bad = ferror(f);
|
|
if (fclose(f) != 0) bad = 1;
|
|
if (bad) {
|
|
perror(path);
|
|
if (unlink(path) != 0 && errno != ENOENT)
|
|
perror(path);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
files_eq(const char *a, const char *b)
|
|
{
|
|
char *ba = NULL, *bb = NULL;
|
|
size_t na = 0, nb = 0;
|
|
if (slurp(a, &ba, &na) < 0 || slurp(b, &bb, &nb) < 0) {
|
|
free(ba); free(bb);
|
|
return -1;
|
|
}
|
|
int eq = (na == nb && memcmp(ba, bb, na) == 0);
|
|
free(ba); free(bb);
|
|
return eq ? 0 : 1;
|
|
}
|
|
|
|
/* cs==ww over a sep-build's per-package artifacts: every .s/.o/.wwi the
|
|
* cstage driver produced in `csdir` must be byte-identical to the wwstage
|
|
* driver's same-named file in `wwdir` (rule 10; the .wwi interface files
|
|
* enter the compare set per rob-c6-spec §2). Returns the mismatch count
|
|
* (≥1 also on an unreadable / empty cs sepwork). */
|
|
static int
|
|
cmp_sepwork(const char *csdir, const char *wwdir)
|
|
{
|
|
DIR *d = opendir(csdir);
|
|
if (!d) {
|
|
fprintf(stderr, "Tier-C FAIL: no cs sepwork %s\n", csdir);
|
|
return 1;
|
|
}
|
|
int bad = 0, seen = 0;
|
|
struct dirent *ent;
|
|
while ((ent = readdir(d)) != NULL) {
|
|
const char *nm = ent->d_name;
|
|
size_t nl = strlen(nm);
|
|
int is_s = (nl > 2 && strcmp(nm + nl - 2, ".s") == 0);
|
|
int is_o = (nl > 2 && strcmp(nm + nl - 2, ".o") == 0);
|
|
int is_wwi = (nl > 4 && strcmp(nm + nl - 4, ".wwi") == 0);
|
|
if (!is_s && !is_o && !is_wwi) continue;
|
|
seen++;
|
|
char a[2048], b[2048];
|
|
snprintf(a, sizeof a, "%s/%s", csdir, nm);
|
|
snprintf(b, sizeof b, "%s/%s", wwdir, nm);
|
|
if (files_eq(a, b) != 0) {
|
|
fprintf(stderr, "Tier-C FAIL: cs!=ww for %s (rule 10)\n", nm);
|
|
bad++;
|
|
}
|
|
}
|
|
closedir(d);
|
|
if (seen == 0) {
|
|
fprintf(stderr, "Tier-C FAIL: no .s/.o/.wwi in %s\n", csdir);
|
|
bad++;
|
|
}
|
|
return bad;
|
|
}
|
|
|
|
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,
|
|
* kept free of 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",
|
|
"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",
|
|
"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",
|
|
"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"
|
|
"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"
|
|
"fn doit() (i32 | nomem) = {\n"
|
|
" let s: []str = alloc([], 4)?;\n"
|
|
" return s.cap: i32;\n"
|
|
"};\n"
|
|
"fn main() i32 = { return doit()!; };" },
|
|
{ NULL, 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++;
|
|
if (unlink(src) != 0 && errno != ENOENT) {
|
|
perror(src);
|
|
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++;
|
|
}
|
|
if (unlink(src) != 0 && errno != ENOENT) {
|
|
perror(src);
|
|
fail++;
|
|
}
|
|
if (unlink(s) != 0 && errno != ENOENT) {
|
|
perror(s);
|
|
fail++;
|
|
}
|
|
n++;
|
|
}
|
|
|
|
/* Tier-C capstone (#46 c6, rob-c6-spec §2 / amendment-B; M4 #89).
|
|
* The load-bearing M4 oracle: build w6c by SEPARATE compilation under
|
|
* BOTH driver stages and prove they sep-produce byte-identical per-package
|
|
* .s/.o/.wwi (cs==ww on the real tool's sep artifacts, rule 10). The
|
|
* combined corpus + the sep-out==combined-out leg are gone with the
|
|
* retired combined mode (E3 flip); the per-pkg cs==ww comparison is
|
|
* the surviving live oracle. Its
|
|
* cold pid-keyed scratch is wiped after the explicit bootstrap gate. */
|
|
{
|
|
char inc[4096], cmd[16384];
|
|
snprintf(inc, sizeof inc,
|
|
"-I %s/lib -I %s/lib/ww -I %s/selfhost/cmd", cwd, cwd, cwd);
|
|
char root[2048];
|
|
snprintf(root, sizeof root, "%s/selfhost/cmd/w6c/main.ww", cwd);
|
|
|
|
struct { const char *drv, *tag; char prog[2048]; int ok; }
|
|
stg[] = { { "ww", "cs", {0}, 0 }, { "ww_ww", "ww", {0}, 0 } };
|
|
for (int s = 0; s < 2; s++) {
|
|
snprintf(stg[s].prog, sizeof stg[s].prog,
|
|
"/tmp/wwc6tc_%d_%s", getpid(), stg[s].tag);
|
|
/* Per-(pid,stage) output stems isolate every artifact used by
|
|
* this gate. */
|
|
snprintf(cmd, sizeof cmd,
|
|
"timeout 600 %s/%s build "
|
|
"%s -o %s %s >/dev/null 2>&1",
|
|
bin, stg[s].drv, inc, stg[s].prog, root);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "Tier-C FAIL: %s build w6c\n",
|
|
stg[s].drv);
|
|
fail++;
|
|
} else stg[s].ok = 1;
|
|
n++;
|
|
}
|
|
|
|
/* cs==ww on the real tool's sep .s/.o/.wwi (rule 10). */
|
|
if (stg[0].ok && stg[1].ok) {
|
|
char csdir[2176], wwdir[2176];
|
|
snprintf(csdir, sizeof csdir, "%s.sepwork", stg[0].prog);
|
|
snprintf(wwdir, sizeof wwdir, "%s.sepwork", stg[1].prog);
|
|
fail += cmp_sepwork(csdir, wwdir);
|
|
n++;
|
|
}
|
|
|
|
for (int s = 0; s < 2; s++) {
|
|
snprintf(cmd, sizeof cmd, "rm -rf %s %s.sepwork %s.cache",
|
|
stg[s].prog, stg[s].prog, stg[s].prog);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "Tier-C: cleanup %s failed\n",
|
|
stg[s].prog);
|
|
fail++;
|
|
}
|
|
}
|
|
}
|
|
|
|
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 in-source corpus "
|
|
"inputs + Tier-C: cs==ww sep .s/.o/.wwi on the real w6c build\n",
|
|
n);
|
|
return 0;
|
|
}
|