ww/test/wcc/733_enum_modshadow.c

/*
 * 733_enum_modshadow — sentinel for the trio leaf-name pattern's
 * 4th leaf: wwstage's enumlookup. Pins (a) bare-leaf `Color.MEMBER`
 * to a same-module-first walk so the constant folds against the
 * caller's own Color rather than another module's same-leaf-name
 * Color sitting at the head of c.enums, and (b) `pkg.Color.MEMBER`
 * to the new enumlookupmod variant so the explicit qualifier wins
 * the leaf-collision on the same shape as fnparamslookupmod (#28)
 * and fnretlookupmod (#31).
 *
 * Pre-fix wwstage's `enumlookup` (selfhost/cmd/wcc/cgen.ww) walked
 * c.enums head-first by ename, returning the FIRST match. The
 * cgdot enum branch handed it `lhs.str` (bare leaf) for both the
 * `Color.MEMBER` shape (lhs N_IDENT) and the `pkg.Color.MEMBER`
 * shape (lhs N_DOT) — explicit pkg silently dropped. Either
 * collision direction folded `Color.RED` to the wrong constant.
 * Silent miscompile, not byte-id: cstage folds at the checker via
 * scope_lookup_prefer (cur_mod, "Color") for the bare case and via
 * the inner N_DOT's typed SK_USE.SK_TYPE lookup for the qualified
 * case, so cs vs ws asm diverged on every collision shape — but no
 * stdlib in-tree currently declares two same-leaf enums, so 995
 * stayed green.
 *
 * Asserts the post-fix constants land inside the matching TEXT
 * sym on BOTH stages and that cs vs ws stay byte-identical on
 * each row. Sentinel-flips if any of the three pieces revert:
 * the enumlookup same-module-first walk, the enumlookupmod
 * variant, or the cgdot N_DOT routing.
 */
#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;
}

struct row {
	const char *label;
	const char *src;
	const char *textsym;	/* TEXT sym containing the load */
	const char *want_imm;	/* the immediate that MUST appear */
	const char *bad_imm;	/* the immediate that MUST NOT appear */
};

/* Source orderings pick which module's Color sits at the head of
 * c.enums after collectenums' head-prepend walk. The LAST `type
 * Color = enum ...` in source order ends at the head — that's the
 * leaf-collision the same-module-first walk must beat. */
static const struct row rows[] = {
	{ "bare_leaf_same_module",
	  "// MODULE: gamma\n"
	  "use alpha;\n"
	  "use beta;\n"
	  "export fn main() i32 = { return 0; };\n"
	  "// MODULE: beta\n"
	  "type Color = enum i32 { RED = 7, };\n"
	  "export fn readred() Color = { return Color.RED; };\n"
	  "// MODULE: alpha\n"
	  "type Color = enum i32 { RED = 100, };\n",
	  "TEXT beta.readred", "$7,", "$100," },
	{ "dot_qualified_explicit_module",
	  "// MODULE: gamma\n"
	  "use alpha;\n"
	  "use beta;\n"
	  "export fn main() i32 = { return 0; };\n"
	  "// MODULE: alpha\n"
	  "type Color = enum i32 { RED = 100, };\n"
	  "export fn readalphared() Color = { return alpha.Color.RED; };\n"
	  "// MODULE: beta\n"
	  "type Color = enum i32 { RED = 7, };\n",
	  "TEXT alpha.readalphared", "$100,", "$7," },
	/* Caller's module is gamma — neither alpha nor beta — so the
	 * enumlookup same-module-first walk finds NO Color match in
	 * gamma. Without the cgdot etmod tracking + enumlookupmod
	 * variant, enumlookup falls back to head-walk and picks beta's
	 * Color (last declared → prepended → head). With the new path,
	 * enumlookupmod("Color", "alpha") prefers alpha. Pins the
	 * second piece of the trio-leaf fix independent of row 1. */
	{ "dot_qualified_cross_module",
	  "// MODULE: gamma\n"
	  "use alpha;\n"
	  "use beta;\n"
	  "export fn readalpharedgamma() i32 = { return alpha.Color.RED: i32; };\n"
	  "export fn main() i32 = { return 0; };\n"
	  "// MODULE: alpha\n"
	  "type Color = enum i32 { RED = 100, };\n"
	  "// MODULE: beta\n"
	  "type Color = enum i32 { RED = 7, };\n",
	  "TEXT gamma.readalpharedgamma", "$100,", "$7," },
};

static int
slurp(const char *path, char *buf, size_t cap)
{
	FILE *f = fopen(path, "rb");
	if (!f) return -1;
	size_t n = fread(buf, 1, cap - 1, f);
	fclose(f);
	buf[n] = '\0';
	return (int)n;
}

static int
emit_s(const char *w6c, const struct row *r, int i, char *out_s, size_t cap)
{
	char src[64], cmd[1024];
	snprintf(src, sizeof src, "/tmp/ems_%d_%d.ww", getpid(), i);
	snprintf(out_s, cap, "/tmp/ems_%d_%d_%s.s",
	    getpid(), i, w6c[strlen(w6c) - 1] == 'w' ? "ww" : "c");

	FILE *f = fopen(src, "wb");
	if (!f) return -1;
	fputs(r->src, f);
	fclose(f);

	snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", w6c, out_s, src);
	int rc = runwait(cmd);
	unlink(src);
	return rc;
}

/* Inside the named TEXT sym, before its first RET, the want_imm
 * MUST appear and the bad_imm MUST NOT. bad_imm flags pre-fix
 * head-walk picking the wrong-module Color. */
static int
check_imm(const char *spath, const struct row *r, const char *stage)
{
	char buf[1 << 14];
	if (slurp(spath, buf, sizeof buf) < 0) {
		fprintf(stderr, "row[%s][%s]: cannot read %s\n",
		    r->label, stage, spath);
		return -1;
	}
	const char *fn = strstr(buf, r->textsym);
	if (!fn) {
		fprintf(stderr, "row[%s][%s]: no %s in %s\n",
		    r->label, stage, r->textsym, spath);
		return -1;
	}
	const char *ret = strstr(fn, "\tRET");
	if (!ret) {
		fprintf(stderr, "row[%s][%s]: no RET inside %s\n",
		    r->label, stage, r->textsym);
		return -1;
	}
	const char *good = strstr(fn, r->want_imm);
	if (!good || good >= ret) {
		fprintf(stderr,
		    "row[%s][%s]: want_imm %s missing inside %s\n",
		    r->label, stage, r->want_imm, r->textsym);
		return -1;
	}
	const char *bad = strstr(fn, r->bad_imm);
	if (bad && bad < ret) {
		fprintf(stderr,
		    "row[%s][%s]: bad_imm %s present inside %s — wrong-module Color\n",
		    r->label, stage, r->bad_imm, r->textsym);
		return -1;
	}
	return 0;
}

int
main(void)
{
	const char *bin = getenv("BIN");
	if (!bin) bin = "out/bin";
	char absbin[512];
	if (bin[0] != '/') {
		char cwd[256];
		if (getcwd(cwd, sizeof cwd) == NULL) return 1;
		snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin);
		bin = absbin;
	}

	char w6c[640], w6c_ww[640];
	snprintf(w6c, sizeof w6c, "%s/w6c", bin);
	snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin);

	int have_ww = (access(w6c_ww, X_OK) == 0);
	int n = (int)(sizeof rows / sizeof rows[0]);
	int total = 0, fail = 0;

	for (int i = 0; i < n; i++) {
		char cs_path[128], ws_path[128];

		if (emit_s(w6c, &rows[i], i, cs_path, sizeof cs_path) != 0) {
			fprintf(stderr,
			    "enum_modshadow[cstage][%s]: w6c failed\n",
			    rows[i].label);
			fail++; total++; continue;
		}
		total++;
		if (check_imm(cs_path, &rows[i], "cstage") != 0) fail++;

		if (!have_ww) { unlink(cs_path); continue; }

		if (emit_s(w6c_ww, &rows[i], i, ws_path, sizeof ws_path) != 0) {
			fprintf(stderr,
			    "enum_modshadow[wwstage][%s]: w6c_ww failed\n",
			    rows[i].label);
			fail++; total++;
			unlink(cs_path); continue;
		}
		total++;
		if (check_imm(ws_path, &rows[i], "wwstage") != 0) fail++;

		total++;
		char cmd[512];
		snprintf(cmd, sizeof cmd, "cmp -s %s %s", cs_path, ws_path);
		if (runwait(cmd) != 0) {
			fprintf(stderr,
			    "enum_modshadow[%s]: cstage vs wwstage asm differs\n",
			    rows[i].label);
			fail++;
		}

		unlink(cs_path); unlink(ws_path);
	}

	if (fail) {
		fprintf(stderr,
		    "enum_modshadow: %d/%d fixtures failed\n", fail, total);
		return 1;
	}
	printf("enum_modshadow: %d/%d ok\n", total, total);
	return 0;
}