ww/test/wcc/994_w6c_ww.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, "%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, "%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",
		  "use 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",
		  "use 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"
		  "};" },
		{ 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++;
	}

	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;
}