Hojun-Cho
a95a7a316b
Every surviving carrier now owns its artifacts: checked mkdir/mkdtemp/ fopen acquisition, one all-exit cleanup funnel per carrier, ENOENT- tolerant checked unlinks, exact-path deletion (rm -rf only for an owned pid-keyed dir or a .sepwork beneath one), and cleanup failure fails a passing carrier without overwriting its diagnostic. In the same pass the carriers adapt to the driver contract this branch lands: --sep and WW_PKGCACHE are gone, -S and the /tmp/ww_run_<pid> scratch contract are asserted, and rows whose runtime or reject coverage moved to test/wcc/data fixtures or test/lang @test owners are trimmed to the byte/artifact/diagnostic observations only they can make. Repair and adaptation ride together because most files interleave both in the same hunks; splitting would manufacture intermediate carrier states that never existed and cannot run against either driver.
266 lines
7.7 KiB
C
266 lines
7.7 KiB
C
/*
|
||
* 744_letcopy_struct — sentinel for STATUS-6 #32. Class B-symmetric
|
||
* cgen miscompile: `let p2: T = p1;` where T is a struct >8B and rhs
|
||
* is a local ident silently zero-inits p2 (cstage emitted nothing for
|
||
* the copy; wwstage emitted a single MOVQ AX + stale BX from the
|
||
* sz==16 str-init tail). Reads after the let saw whatever the stack
|
||
* held — silent partial-copy / silent zero on a fresh frame.
|
||
*
|
||
* Both stages now byte-copy the source slot to the dest slot
|
||
* per-qword with a sized tail (MOVL/MOVB) for natural sizes not
|
||
* 8-aligned. Mirrors cg_widen_tagged_store's struct-ident payload
|
||
* copy. See cmd/w6c/cgen.c N_LET and selfhost/cmd/wcc/cgenstmt.ww
|
||
* cglet.
|
||
*
|
||
* Rows exercise the 4 struct shapes the task brief called out:
|
||
* (a) 3-field i32 (sz=12, MOVQ + MOVL tail).
|
||
* (b) i32 + str field (sz=24, 3 × MOVQ).
|
||
* (c) i32 + []u8 slice field (sz=32, 4 × MOVQ).
|
||
* (d) i32 + tagged (i32|str) field (sz=32, 4 × MOVQ).
|
||
*
|
||
* Each row pins:
|
||
* - asm-presence in both stages: produce body emits `min_loads`
|
||
* `MOVQ -K(BP), AX` source-slot loads (the bug pin — pre-fix
|
||
* cstage emitted 0; wwstage emitted 1 with garbage BX tail).
|
||
* - asm byte-id between stages (cmp -s on the produce-bearing .s).
|
||
* - runtime: produce() returns 0 (every field round-tripped).
|
||
*/
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <unistd.h>
|
||
#include <sys/wait.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 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
|
||
count_substr(const char *start, const char *end, const char *needle)
|
||
{
|
||
int n = 0;
|
||
size_t nlen = strlen(needle);
|
||
const char *p = start;
|
||
while (p + nlen <= end) {
|
||
if (memcmp(p, needle, nlen) == 0) { n++; p += nlen; }
|
||
else { p++; }
|
||
}
|
||
return n;
|
||
}
|
||
|
||
struct row {
|
||
const char *label;
|
||
/* Direct-w6c source: bare fn produce, no package/imports. */
|
||
const char *asm_src;
|
||
/* Runtime copies are owned by test/wcc/data/r744_letcopy_*. */
|
||
/* Source-slot loads expected in produce: at least N for the copy.
|
||
* Pre-fix cstage emitted 0; pre-fix wwstage emitted 1 with stale BX.
|
||
* `MOVQ -K(BP), AX` is also emitted by p2.a / p2.s.len reads in the
|
||
* checks, so set min_loads to a value the copy alone surpasses. */
|
||
int min_loads;
|
||
};
|
||
|
||
static const struct row rows[] = {
|
||
/* (a) 3-field i32 struct, sz=12. Copy = 1 × MOVQ + 1 × MOVL.
|
||
* p1 inits via structlit to sidestep the pre-existing no-rhs
|
||
* zero-init divergence for non-8-multiple struct sizes
|
||
* (cstage uses natural sz=12 → MOVQ+MOVL, wwstage uses slot
|
||
* sz=16 → MOVQ+MOVQ). Tracked as the #15/#26c rule-10
|
||
* size-strategy convergence follow-up. */
|
||
{ "tri_i32",
|
||
"type tri = struct { a: i32, b: i32, c: i32 };\n"
|
||
"export fn produce() i32 = {\n"
|
||
" let p1: tri = tri{a=11, b=22, c=33};\n"
|
||
" let p2: tri = p1;\n"
|
||
" if (p2.a != 11) { return 11; };\n"
|
||
" if (p2.b != 22) { return 12; };\n"
|
||
" if (p2.c != 33) { return 13; };\n"
|
||
" return 0;\n"
|
||
"};\n",
|
||
1 },
|
||
/* (b) i32 + str field, sz=24. Copy = 3 × MOVQ. */
|
||
{ "field_str",
|
||
"type ws = struct { a: i32, s: str };\n"
|
||
"export fn produce() i32 = {\n"
|
||
" let p1: ws;\n"
|
||
" p1.a = 7; p1.s = \"hi\";\n"
|
||
" let p2: ws = p1;\n"
|
||
" if (p2.a != 7) { return 11; };\n"
|
||
" if (p2.s.len != 2) { return 12; };\n"
|
||
" return 0;\n"
|
||
"};\n",
|
||
3 },
|
||
/* (c) i32 + []u8 slice field, sz=32. Copy = 4 × MOVQ. */
|
||
{ "field_slice",
|
||
"type wsl = struct { a: i32, b: []u8 };\n"
|
||
"export fn produce() i32 = {\n"
|
||
" let raw: [3]u8 = [1: u8, 2: u8, 3: u8];\n"
|
||
" let p1: wsl;\n"
|
||
" p1.a = 9; p1.b = raw[0:3];\n"
|
||
" let p2: wsl = p1;\n"
|
||
" if (p2.a != 9) { return 11; };\n"
|
||
" if (p2.b.len != 3) { return 12; };\n"
|
||
" return 0;\n"
|
||
"};\n",
|
||
4 },
|
||
/* (d) i32 + tagged (i32|str) field, sz=32. Copy = 4 × MOVQ.
|
||
* Runtime checks only p2.a; the asm load-count (>=4) and the
|
||
* byte-id gate together prove the full 32B slot copied — match
|
||
* on p2.t avoided because wwstage's match scrutinee spill grows
|
||
* the frame and reorders ABI loads vs cstage (pre-existing
|
||
* #15/#26c rule-10 size-strategy / match-spill divergence). */
|
||
{ "field_tagged",
|
||
"type tag = (i32 | str);\n"
|
||
"type wtg = struct { a: i32, t: tag };\n"
|
||
"export fn produce() i32 = {\n"
|
||
" let p1: wtg = wtg{a=5, t=42: tag};\n"
|
||
" let p2: wtg = p1;\n"
|
||
" if (p2.a != 5) { return 11; };\n"
|
||
" return 0;\n"
|
||
"};\n",
|
||
4 },
|
||
};
|
||
|
||
/* Locate `TEXT produce` body in the asm file and count source-slot
|
||
* loads (`MOVQ\t-K(BP), AX`) inside it. Pre-fix cstage produce had 0;
|
||
* pre-fix wwstage produce had 1 (no tail). */
|
||
static int
|
||
check_copy_loads(const char *spath, const struct row *r)
|
||
{
|
||
static char buf[1 << 16];
|
||
if (slurp(spath, buf, sizeof buf) < 0) return -1;
|
||
|
||
const char *body = strstr(buf, "TEXT main.produce");
|
||
if (!body) {
|
||
fprintf(stderr, "row[%s]: no TEXT produce label in %s\n",
|
||
r->label, spath);
|
||
return -1;
|
||
}
|
||
/* End at the next TEXT (or EOF). */
|
||
const char *end = strstr(body + 1, "\nTEXT ");
|
||
if (!end) end = buf + strlen(buf);
|
||
|
||
int loads = count_substr(body, end, "MOVQ\t-");
|
||
if (loads < r->min_loads) {
|
||
fprintf(stderr,
|
||
"row[%s]: only %d `MOVQ -K(BP), AX` source loads in "
|
||
"produce; expected >= %d (copy missing)\n",
|
||
r->label, loads, r->min_loads);
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
emit_s(const char *w6c, const struct row *r, int i, int stage,
|
||
char *out_s, size_t cap)
|
||
{
|
||
char src[64], cmd[1024];
|
||
snprintf(src, sizeof src, "/tmp/lcs_asm_%d_%d_%d.ww",
|
||
getpid(), i, stage);
|
||
snprintf(out_s, cap, "/tmp/lcs_asm_%d_%d_%d.s",
|
||
getpid(), i, stage);
|
||
|
||
FILE *f = fopen(src, "wb");
|
||
if (!f) return -1;
|
||
wwtest_fputs(r->asm_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;
|
||
}
|
||
|
||
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++) {
|
||
const struct row *r = &rows[i];
|
||
char cs_path[160], ws_path[160];
|
||
|
||
/* cstage asm-presence. */
|
||
if (emit_s(w6c, r, i, 0, cs_path, sizeof cs_path) != 0) {
|
||
fprintf(stderr,
|
||
"letcopy_struct[cstage][%s]: w6c failed\n",
|
||
r->label);
|
||
fail++; total++; continue;
|
||
}
|
||
total++;
|
||
if (check_copy_loads(cs_path, r) != 0) fail++;
|
||
|
||
/* wwstage asm-presence + byte-id. */
|
||
if (have_ww) {
|
||
if (emit_s(w6c_ww, r, i, 1, ws_path, sizeof ws_path)
|
||
!= 0) {
|
||
fprintf(stderr,
|
||
"letcopy_struct[wwstage][%s]: "
|
||
"w6c_ww failed\n", r->label);
|
||
fail++; total++;
|
||
unlink(cs_path);
|
||
continue;
|
||
}
|
||
total++;
|
||
if (check_copy_loads(ws_path, r) != 0) fail++;
|
||
|
||
total++;
|
||
char cmd[512];
|
||
snprintf(cmd, sizeof cmd, "cmp -s %s %s",
|
||
cs_path, ws_path);
|
||
if (runwait(cmd) != 0) {
|
||
fprintf(stderr,
|
||
"letcopy_struct[%s]: cstage vs wwstage "
|
||
"asm differs\n", r->label);
|
||
fail++;
|
||
}
|
||
unlink(ws_path);
|
||
}
|
||
unlink(cs_path);
|
||
|
||
}
|
||
|
||
if (fail) {
|
||
fprintf(stderr,
|
||
"letcopy_struct: %d/%d fixtures failed\n", fail, total);
|
||
return 1;
|
||
}
|
||
printf("letcopy_struct: %d/%d ok\n", total, total);
|
||
return 0;
|
||
}
|