Hojun-Cho
83f5956df2
Every section banner dies (103 -> 0) across test/lang, the observer suites, the C carriers, and the five comment-heavy corpus fixtures; banner provenance (#N cites, carrier numbers, repair-cluster labels) folded into headers or adjacent WHY comments. Narration deleted; row provenance, ref cites, divergence pins, and layout contracts kept (fwd-ref decl-order guards and bootstrap-gate corpus rationale restored where the sweep over-cut). Comment-only proven: all 3742 wwbuild workdir .s byte-identical before/after; test-commit and test-byteid (161 lang + 1399 data, 0 pinned-divergent) green.
487 lines
18 KiB
Plaintext
487 lines
18 KiB
Plaintext
package m3sep_test;
|
|
|
|
// M3 `.wwi` separate-compilation CONSUMER gate (task #22 arc). Port of
|
|
// the retired native carrier test/wcc/989_m3sep_run.c; every assertion
|
|
// preserved. Drives the raw w6c/w6a/w6l toolchains (+_ww twins), never
|
|
// the ww driver: the composed //ww:module units splice PRODUCED .wwi
|
|
// bytes between compile steps — an inter-stage artifact flow no
|
|
// driver invocation or fixture can express.
|
|
//
|
|
// keystone (rob §4.1, the load-bearing claim) — compiling package P
|
|
// under `-c` with deps as `.wwi` emits byte-identical codegen to deps
|
|
// as full BODIES, holding the -c filter constant and varying only the
|
|
// dep-source form; proven per package (mid, root, smid) on BOTH
|
|
// stages (a wwstage-only guard regression cannot hide behind the
|
|
// .wwi-sourced sep unit), plus cs==ww on the sep unit (rule 10),
|
|
// sep-path determinism (same input twice -> identical), and the
|
|
// value-global guard: an imported `export let` must never re-emit its
|
|
// DATA[W] definition (link collision). The smid row exercises the
|
|
// strlit-intern guard: neutralize it and sleaf.banner interns ahead
|
|
// of smid.label in the bodies-unit, desyncing `_S_` -> keystone RED.
|
|
//
|
|
// chain — end-to-end: leaf/mid/root compiled -c, assembled, linked
|
|
// with libwwrt.a and RUN through both full toolchains -> exit 59 (the
|
|
// real cross-boundary computation over all four fact-classes: fn
|
|
// signature, struct layout, def const, export-let global); the two
|
|
// final executables byte-identical (rule 10 end-to-end).
|
|
//
|
|
// str49 (#49) — two str-bearing packages sep-LINK without an `_S_`
|
|
// label collision (per-unit prefix): exit 160 reads a distinguishing
|
|
// byte THROUGH each str's .ptr; cstage .s carries `sleaf._S_` /
|
|
// `smid._S_` and no bare `DATA _S_0(SB)`.
|
|
//
|
|
// leaf53 (#53) — two packages exporting the SAME-named non-fn leaves
|
|
// (`let v`, `def K`) sep-LINK because every exported decl
|
|
// path-qualifies (cea.v/ceb.v, cea.K/ceb.K, no bare v/K DATA): exit
|
|
// 140 proves each getter reads its OWN module's data.
|
|
//
|
|
// Dropped C machinery, not assertions: the ~70-entry remove_child
|
|
// cleanup ledger (testenv.clean asserts the recursive removal).
|
|
|
|
import os;
|
|
import os.exec;
|
|
import strings;
|
|
import testenv;
|
|
import time;
|
|
|
|
fn fail(label: str, why: str) void = {
|
|
let m: str = strings.concat("m3sep FAIL: ", label, " -- ", why, "\n");
|
|
os.write(2, m.ptr, m.len: u64);
|
|
assert(false);
|
|
};
|
|
|
|
fn tmo() time.duration = {
|
|
return (180i64 * (time.second: i64)): time.duration;
|
|
};
|
|
|
|
// -1 encodes an abnormal (non-EXIT) termination, never a valid code.
|
|
fn runcode(dir: str, name: str, argv: []str) i32 = {
|
|
let co: testenv.commandout;
|
|
testenv.runcommand(dir, dir, name, argv, tmo(), &co);
|
|
if (co.termination != exec.termination.EXIT) { return -1; };
|
|
return co.code;
|
|
};
|
|
|
|
// one //ww:module section: directive line, body bytes, closing newline
|
|
// (the exact append_section shape the carrier composed).
|
|
fn sec(directive: str, body: str) str = {
|
|
return strings.concat(directive, "\n", body, "\n");
|
|
};
|
|
|
|
// The fixture: leaf -> mid -> root carries all FOUR cross-boundary
|
|
// fact-classes (fn signature, struct layout, def const, export-let
|
|
// global). root exit = combine(mkpoint(3,4)) + add(1,2) = 56 + 3 = 59.
|
|
fn leafsrc() str = {
|
|
return strings.concat(
|
|
"package leaf;\n",
|
|
"export type Point = struct { x: i32, y: i32 };\n",
|
|
"export def SCALE: i32 = 7;\n",
|
|
"export let origin_tag: i32 = 42;\n",
|
|
"export fn add(a: i32, b: i32) i32 = { return a + b; };\n",
|
|
"export fn mkpoint(x: i32, y: i32) Point = { return Point { x = x, y = y }; };\n",
|
|
"fn leafpriv(z: i32) i32 = { return z * SCALE; };\n");
|
|
};
|
|
|
|
fn midsrc() str = {
|
|
return strings.concat(
|
|
"package mid;\n",
|
|
"import leaf;\n",
|
|
"export fn combine(p: leaf.Point) i32 = {\n",
|
|
" return leaf.add(p.x, p.y) + leaf.SCALE + leaf.origin_tag;\n",
|
|
"};\n");
|
|
};
|
|
|
|
fn rootsrc() str = {
|
|
return strings.concat(
|
|
"package main;\n",
|
|
"import leaf;\n",
|
|
"import mid;\n",
|
|
"fn main() i32 = {\n",
|
|
" let p = leaf.mkpoint(3, 4);\n",
|
|
" let r = mid.combine(p);\n",
|
|
" r = r + leaf.add(1, 2);\n",
|
|
" return r;\n",
|
|
"};\n");
|
|
};
|
|
|
|
// str sub-fixture: sleaf's export-let interns a strlit in sleaf's own
|
|
// compile but is stripped from sleaf.wwi — the strlit-intern guard's
|
|
// non-vacuity source (see keystone smid row).
|
|
fn sleafsrc() str = {
|
|
return strings.concat(
|
|
"package sleaf;\n",
|
|
"export let banner: str = \"sleaf-banner\";\n",
|
|
"export fn tag(a: i32) i32 = { return a + 1; };\n",
|
|
"export fn getbanner() str = { return banner; };\n");
|
|
};
|
|
|
|
fn smidsrc() str = {
|
|
return strings.concat(
|
|
"package smid;\n",
|
|
"import sleaf;\n",
|
|
"export let label: str = \"smid-label\";\n",
|
|
"export fn use(a: i32) i32 = { return sleaf.tag(a); };\n",
|
|
"export fn getlabel() str = { return label; };\n");
|
|
};
|
|
|
|
// getbanner()[0] = 's'(115), getlabel()[4] = '-'(45) -> 160; a collided
|
|
// `_S_0` resolving to the wrong package's bytes corrupts the exit.
|
|
fn srootsrc() str = {
|
|
return strings.concat(
|
|
"package main;\n",
|
|
"import sleaf;\n",
|
|
"import smid;\n",
|
|
"fn main() i32 = {\n",
|
|
" let a: str = sleaf.getbanner();\n",
|
|
" let b: str = smid.getlabel();\n",
|
|
" return (a[0]: i32) + (b[4]: i32);\n",
|
|
"};\n");
|
|
};
|
|
|
|
// cea.val()=43, ceb.val()=97 -> 140; a collided bare v/K resolving to
|
|
// the wrong package's data corrupts the exit.
|
|
fn ceasrc() str = {
|
|
return strings.concat(
|
|
"package cea;\n",
|
|
"export let v: i64 = 40;\n",
|
|
"export def K: i64 = 3;\n",
|
|
"export fn val() i64 = { return v + K; };\n");
|
|
};
|
|
|
|
fn cebsrc() str = {
|
|
return strings.concat(
|
|
"package ceb;\n",
|
|
"export let v: i64 = 90;\n",
|
|
"export def K: i64 = 7;\n",
|
|
"export fn val() i64 = { return v + K; };\n");
|
|
};
|
|
|
|
fn cxrootsrc() str = {
|
|
return strings.concat(
|
|
"package main;\n",
|
|
"import cea;\n",
|
|
"import ceb;\n",
|
|
"fn main() i32 = { return (cea.val(): i32) + (ceb.val(): i32); };\n");
|
|
};
|
|
|
|
fn produce(td: str, name: str, unit: str, wwi: str) void = {
|
|
let av: []str = [testenv.driver("w6c"), "-I", wwi, "-o", "/dev/null",
|
|
unit];
|
|
if (runcode(td, strings.concat("prod_", name), av) != 0) {
|
|
fail(name, ".wwi produce failed");
|
|
};
|
|
};
|
|
|
|
fn compilestep(td: str, label: str, step: str, comp: str, outs: str,
|
|
unit: str) void = {
|
|
let av: []str = [testenv.driver(comp), "-c", "-o", outs, unit];
|
|
if (runcode(td, strings.concat(label, "_", step), av) != 0) {
|
|
fail(label, strings.concat(comp, " -c failed (", step, ")"));
|
|
};
|
|
};
|
|
|
|
// the per-package keystone: 5 compiles over the bodies/sep unit pair,
|
|
// then bodies==sep (both stages), cs==ww, determinism, and the
|
|
// imported-value-global DATA guard.
|
|
fn keystone(td: str, label: str, bodies: str, sepu: str) void = {
|
|
let bf: str = strings.concat(td, "/", label, ".bodies.ww");
|
|
testenv.writefile(bf, bodies);
|
|
let sf: str = strings.concat(td, "/", label, ".sep.ww");
|
|
testenv.writefile(sf, sepu);
|
|
let csb: str = strings.concat(td, "/", label, ".bodies.cs.s");
|
|
let css: str = strings.concat(td, "/", label, ".sep.cs.s");
|
|
let wws: str = strings.concat(td, "/", label, ".sep.ww.s");
|
|
let css2: str = strings.concat(td, "/", label, ".sep.cs2.s");
|
|
let wwb: str = strings.concat(td, "/", label, ".bodies.ww.s");
|
|
compilestep(td, label, "bcs", "w6c", csb, bf);
|
|
compilestep(td, label, "scs", "w6c", css, sf);
|
|
compilestep(td, label, "sww", "w6c_ww", wws, sf);
|
|
compilestep(td, label, "scs2", "w6c", css2, sf);
|
|
compilestep(td, label, "bww", "w6c_ww", wwb, bf);
|
|
if (!testenv.same(testenv.readfile(csb), testenv.readfile(css))) {
|
|
fail(label, strings.concat("bodies.s != sep.s (the .wwi does not ",
|
|
"convey the dep facts P's codegen needs)"));
|
|
};
|
|
if (!testenv.same(testenv.readfile(wwb), testenv.readfile(wws))) {
|
|
fail(label, "ww bodies.s != ww sep.s (wwstage keystone)");
|
|
};
|
|
if (!testenv.same(testenv.readfile(css), testenv.readfile(wws))) {
|
|
fail(label, "cs sep.s != ww sep.s (rule 10)");
|
|
};
|
|
if (!testenv.same(testenv.readfile(css), testenv.readfile(css2))) {
|
|
fail(label, "sep codegen non-deterministic");
|
|
};
|
|
// definition guard only: a READ (LEAQ origin_tag) is legitimate in a
|
|
// dependent; the DATA[W] definition belongs to leaf's compile alone.
|
|
let s: str = testenv.readfile(css);
|
|
if (testenv.has(s, "DATAW origin_tag(SB)")
|
|
|| testenv.has(s, "DATA origin_tag(SB)")) {
|
|
fail(label, "imported value-global re-emitted (link collision)");
|
|
};
|
|
};
|
|
|
|
fn buildpkg(td: str, name: str, comp: str, asmtool: str, unit: str,
|
|
sf: str, of: str) void = {
|
|
let cav: []str = [testenv.driver(comp), "-c", "-o", sf, unit];
|
|
if (runcode(td, strings.concat("c_", name), cav) != 0) {
|
|
fail(name, strings.concat(comp, " -c failed"));
|
|
};
|
|
let aav: []str = [testenv.driver(asmtool), "-o", of, sf];
|
|
if (runcode(td, strings.concat("a_", name), aav) != 0) {
|
|
fail(name, strings.concat(asmtool, " failed"));
|
|
};
|
|
};
|
|
|
|
fn producecore(td: str) void = {
|
|
let leafww: str = strings.concat(td, "/leaf.ww");
|
|
testenv.writefile(leafww, leafsrc());
|
|
produce(td, "leaf", leafww, strings.concat(td, "/leaf.wwi"));
|
|
let prod: str = strings.concat(td, "/mid.prod.ww");
|
|
testenv.writefile(prod, strings.concat(
|
|
sec("//ww:module leaf",
|
|
testenv.readfile(strings.concat(td, "/leaf.wwi"))),
|
|
sec("//ww:module-reset", midsrc())));
|
|
produce(td, "mid", prod, strings.concat(td, "/mid.wwi"));
|
|
};
|
|
|
|
fn producestr(td: str, withsmid: bool) void = {
|
|
let sleafww: str = strings.concat(td, "/sleaf.ww");
|
|
testenv.writefile(sleafww, sleafsrc());
|
|
produce(td, "sleaf", sleafww, strings.concat(td, "/sleaf.wwi"));
|
|
if (!withsmid) { return; };
|
|
let prod: str = strings.concat(td, "/smid.prod.ww");
|
|
testenv.writefile(prod, strings.concat(
|
|
sec("//ww:module sleaf",
|
|
testenv.readfile(strings.concat(td, "/sleaf.wwi"))),
|
|
sec("//ww:module-reset", smidsrc())));
|
|
produce(td, "smid", prod, strings.concat(td, "/smid.wwi"));
|
|
};
|
|
|
|
@test fn m3keystone() void = {
|
|
let td: str = testenv.fresh();
|
|
producecore(td);
|
|
producestr(td, false);
|
|
let rl: str = testenv.readfile(strings.concat(td, "/leaf.wwi"));
|
|
let rm: str = testenv.readfile(strings.concat(td, "/mid.wwi"));
|
|
let rsl: str = testenv.readfile(strings.concat(td, "/sleaf.wwi"));
|
|
keystone(td, "mid",
|
|
strings.concat(sec("//ww:module leaf", leafsrc()),
|
|
sec("//ww:module-reset", midsrc())),
|
|
strings.concat(sec("//ww:module leaf", rl),
|
|
sec("//ww:module-reset", midsrc())));
|
|
keystone(td, "root",
|
|
strings.concat(sec("//ww:module leaf", leafsrc()),
|
|
sec("//ww:module mid", midsrc()),
|
|
sec("//ww:module-reset", rootsrc())),
|
|
strings.concat(sec("//ww:module leaf", rl),
|
|
sec("//ww:module mid", rm),
|
|
sec("//ww:module-reset", rootsrc())));
|
|
keystone(td, "smid",
|
|
strings.concat(sec("//ww:module sleaf", sleafsrc()),
|
|
sec("//ww:module-reset", smidsrc())),
|
|
strings.concat(sec("//ww:module sleaf", rsl),
|
|
sec("//ww:module-reset", smidsrc())));
|
|
testenv.clean(td);
|
|
};
|
|
|
|
@test fn m3chain() void = {
|
|
let td: str = testenv.fresh();
|
|
producecore(td);
|
|
let rl: str = testenv.readfile(strings.concat(td, "/leaf.wwi"));
|
|
let rm: str = testenv.readfile(strings.concat(td, "/mid.wwi"));
|
|
let midsep: str = strings.concat(td, "/mid.sep.ww");
|
|
testenv.writefile(midsep, strings.concat(
|
|
sec("//ww:module leaf", rl),
|
|
sec("//ww:module-reset", midsrc())));
|
|
let rootsep: str = strings.concat(td, "/root.sep.ww");
|
|
testenv.writefile(rootsep, strings.concat(
|
|
sec("//ww:module leaf", rl),
|
|
sec("//ww:module mid", rm),
|
|
sec("//ww:module-reset", rootsrc())));
|
|
|
|
let comps: []str = ["w6c", "w6c_ww"];
|
|
let asms: []str = ["w6a", "w6a_ww"];
|
|
let lnks: []str = ["w6l", "w6l_ww"];
|
|
let tags: []str = ["cs", "ww"];
|
|
let rt: str = strings.concat(testenv.repo(), "/out/lib/libwwrt.a");
|
|
let exes: []str = ["", ""];
|
|
let t: i32 = 0;
|
|
for (t < 2) {
|
|
let lo: str = strings.concat(td, "/leaf.", tags[t], ".o");
|
|
let mo: str = strings.concat(td, "/mid.", tags[t], ".o");
|
|
let ro: str = strings.concat(td, "/root.", tags[t], ".o");
|
|
buildpkg(td, strings.concat("leaf_", tags[t]), comps[t], asms[t],
|
|
strings.concat(td, "/leaf.ww"),
|
|
strings.concat(td, "/leaf.", tags[t], ".s"), lo);
|
|
buildpkg(td, strings.concat("mid_", tags[t]), comps[t], asms[t],
|
|
midsep, strings.concat(td, "/mid.", tags[t], ".s"), mo);
|
|
buildpkg(td, strings.concat("root_", tags[t]), comps[t], asms[t],
|
|
rootsep, strings.concat(td, "/root.", tags[t], ".s"), ro);
|
|
let exe: str = strings.concat(td, "/prog.", tags[t]);
|
|
let lav: []str = [testenv.driver(lnks[t]), "-o", exe, ro, mo, lo,
|
|
rt];
|
|
if (runcode(td, strings.concat("l_", tags[t]), lav) != 0) {
|
|
fail("chain", strings.concat(lnks[t], " link failed"));
|
|
};
|
|
let rav: []str = [exe];
|
|
if (runcode(td, strings.concat("run_", tags[t]), rav) != 59) {
|
|
fail("chain", strings.concat(tags[t], " sep program exit != 59 ",
|
|
"(cross-boundary behavior wrong)"));
|
|
};
|
|
exes[t] = exe;
|
|
t += 1;
|
|
};
|
|
// symbol order is identical (same object set, same order); the .s
|
|
// are byte-id, so the linked images must match too.
|
|
if (!testenv.same(testenv.readfile(exes[0]),
|
|
testenv.readfile(exes[1]))) {
|
|
fail("chain", "cs exe != ww exe (rule 10, final image)");
|
|
};
|
|
testenv.clean(td);
|
|
};
|
|
|
|
@test fn m3str49() void = {
|
|
let td: str = testenv.fresh();
|
|
producestr(td, true);
|
|
let rsl: str = testenv.readfile(strings.concat(td, "/sleaf.wwi"));
|
|
let rsm: str = testenv.readfile(strings.concat(td, "/smid.wwi"));
|
|
let smidsep: str = strings.concat(td, "/smid.sep.ww");
|
|
testenv.writefile(smidsep, strings.concat(
|
|
sec("//ww:module sleaf", rsl),
|
|
sec("//ww:module-reset", smidsrc())));
|
|
let srootsep: str = strings.concat(td, "/sroot.sep.ww");
|
|
testenv.writefile(srootsep, strings.concat(
|
|
sec("//ww:module sleaf", rsl),
|
|
sec("//ww:module smid", rsm),
|
|
sec("//ww:module-reset", srootsrc())));
|
|
|
|
let comps: []str = ["w6c", "w6c_ww"];
|
|
let asms: []str = ["w6a", "w6a_ww"];
|
|
let lnks: []str = ["w6l", "w6l_ww"];
|
|
let tags: []str = ["cs", "ww"];
|
|
let rt: str = strings.concat(testenv.repo(), "/out/lib/libwwrt.a");
|
|
let exes: []str = ["", ""];
|
|
let t: i32 = 0;
|
|
for (t < 2) {
|
|
let ls: str = strings.concat(td, "/sleaf.", tags[t], ".s");
|
|
let ms: str = strings.concat(td, "/smid.", tags[t], ".s");
|
|
let lo: str = strings.concat(td, "/sleaf.", tags[t], ".o");
|
|
let mo: str = strings.concat(td, "/smid.", tags[t], ".o");
|
|
let ro: str = strings.concat(td, "/sroot.", tags[t], ".o");
|
|
buildpkg(td, strings.concat("sleaf_", tags[t]), comps[t], asms[t],
|
|
strings.concat(td, "/sleaf.ww"), ls, lo);
|
|
buildpkg(td, strings.concat("smid_", tags[t]), comps[t], asms[t],
|
|
smidsep, ms, mo);
|
|
buildpkg(td, strings.concat("sroot_", tags[t]), comps[t], asms[t],
|
|
srootsep, strings.concat(td, "/sroot.", tags[t], ".s"), ro);
|
|
// #49 structural proof (cstage .s once): module-prefixed strlit
|
|
// labels, never a shared bare _S_0
|
|
if (t == 0) {
|
|
let sl: str = testenv.readfile(ls);
|
|
let sm: str = testenv.readfile(ms);
|
|
if (!testenv.has(sl, "sleaf._S_")
|
|
|| !testenv.has(sm, "smid._S_")) {
|
|
fail("str49", "strlit label not module-prefixed");
|
|
};
|
|
if (testenv.has(sl, "DATA _S_0(SB)")
|
|
|| testenv.has(sm, "DATA _S_0(SB)")) {
|
|
fail("str49",
|
|
"bare _S_0 survives (cross-unit link collision)");
|
|
};
|
|
};
|
|
let exe: str = strings.concat(td, "/sprog.", tags[t]);
|
|
let lav: []str = [testenv.driver(lnks[t]), "-o", exe, ro, mo, lo,
|
|
rt];
|
|
if (runcode(td, strings.concat("l_", tags[t]), lav) != 0) {
|
|
fail("str49", strings.concat(lnks[t],
|
|
" str-pkg sep link failed (#49)"));
|
|
};
|
|
let rav: []str = [exe];
|
|
if (runcode(td, strings.concat("run_", tags[t]), rav) != 160) {
|
|
fail("str49", strings.concat(tags[t], " str-link exit != 160 ",
|
|
"(#49 _S_ collision corrupts the linked strings)"));
|
|
};
|
|
exes[t] = exe;
|
|
t += 1;
|
|
};
|
|
if (!testenv.same(testenv.readfile(exes[0]),
|
|
testenv.readfile(exes[1]))) {
|
|
fail("str49", "cs str-exe != ww str-exe (rule 10, #49)");
|
|
};
|
|
testenv.clean(td);
|
|
};
|
|
|
|
@test fn m3leaf53() void = {
|
|
let td: str = testenv.fresh();
|
|
let ceaww: str = strings.concat(td, "/cea.ww");
|
|
testenv.writefile(ceaww, ceasrc());
|
|
let cebww: str = strings.concat(td, "/ceb.ww");
|
|
testenv.writefile(cebww, cebsrc());
|
|
produce(td, "cea", ceaww, strings.concat(td, "/cea.wwi"));
|
|
produce(td, "ceb", cebww, strings.concat(td, "/ceb.wwi"));
|
|
let cxsep: str = strings.concat(td, "/cxroot.sep.ww");
|
|
testenv.writefile(cxsep, strings.concat(
|
|
sec("//ww:module cea",
|
|
testenv.readfile(strings.concat(td, "/cea.wwi"))),
|
|
sec("//ww:module ceb",
|
|
testenv.readfile(strings.concat(td, "/ceb.wwi"))),
|
|
sec("//ww:module-reset", cxrootsrc())));
|
|
|
|
let comps: []str = ["w6c", "w6c_ww"];
|
|
let asms: []str = ["w6a", "w6a_ww"];
|
|
let lnks: []str = ["w6l", "w6l_ww"];
|
|
let tags: []str = ["cs", "ww"];
|
|
let rt: str = strings.concat(testenv.repo(), "/out/lib/libwwrt.a");
|
|
let exes: []str = ["", ""];
|
|
let t: i32 = 0;
|
|
for (t < 2) {
|
|
let as_: str = strings.concat(td, "/cea.", tags[t], ".s");
|
|
let bs: str = strings.concat(td, "/ceb.", tags[t], ".s");
|
|
let ao: str = strings.concat(td, "/cea.", tags[t], ".o");
|
|
let bo: str = strings.concat(td, "/ceb.", tags[t], ".o");
|
|
let ro: str = strings.concat(td, "/cxroot.", tags[t], ".o");
|
|
buildpkg(td, strings.concat("cea_", tags[t]), comps[t], asms[t],
|
|
ceaww, as_, ao);
|
|
buildpkg(td, strings.concat("ceb_", tags[t]), comps[t], asms[t],
|
|
cebww, bs, bo);
|
|
buildpkg(td, strings.concat("cxroot_", tags[t]), comps[t], asms[t],
|
|
cxsep, strings.concat(td, "/cxroot.", tags[t], ".s"), ro);
|
|
// #53 structural proof (cstage .s once): module-prefixed exported
|
|
// non-fn leaves, never a shared bare v/K
|
|
if (t == 0) {
|
|
let sa: str = testenv.readfile(as_);
|
|
let sb: str = testenv.readfile(bs);
|
|
if (!testenv.has(sa, "cea.v(SB)") || !testenv.has(sa, "cea.K(SB)")
|
|
|| !testenv.has(sb, "ceb.v(SB)")
|
|
|| !testenv.has(sb, "ceb.K(SB)")) {
|
|
fail("leaf53", "exported non-fn leaf not module-prefixed");
|
|
};
|
|
if (testenv.has(sa, "DATAW v(SB)") || testenv.has(sa, "DATA K(SB)")
|
|
|| testenv.has(sb, "DATAW v(SB)")
|
|
|| testenv.has(sb, "DATA K(SB)")) {
|
|
fail("leaf53",
|
|
"bare exported leaf survives (cross-unit link collision)");
|
|
};
|
|
};
|
|
let exe: str = strings.concat(td, "/cxprog.", tags[t]);
|
|
let lav: []str = [testenv.driver(lnks[t]), "-o", exe, ro, ao, bo,
|
|
rt];
|
|
if (runcode(td, strings.concat("l_", tags[t]), lav) != 0) {
|
|
fail("leaf53", strings.concat(lnks[t],
|
|
" export-leaf sep link failed (#53)"));
|
|
};
|
|
let rav: []str = [exe];
|
|
if (runcode(td, strings.concat("run_", tags[t]), rav) != 140) {
|
|
fail("leaf53", strings.concat(tags[t], " export-leaf exit != 140 ",
|
|
"(#53 same-leaf collision corrupts the linked data)"));
|
|
};
|
|
exes[t] = exe;
|
|
t += 1;
|
|
};
|
|
if (!testenv.same(testenv.readfile(exes[0]),
|
|
testenv.readfile(exes[1]))) {
|
|
fail("leaf53", "cs export-leaf exe != ww exe (rule 10, #53)");
|
|
};
|
|
testenv.clean(td);
|
|
};
|