test: port the archive-driven linker observers to ww

archive_test.ww absorbs 610_arch and 632_w6l_manyflags: archive
member selectivity through a load-bearing undefined @symbol extern
(link exit 0, run exit 7), and the -L capacity table {1,64,65,100,
128} against both w6l and w6l_ww with an ET_EXEC check per leg. ar is
/usr/bin/ar via runcommand; the junk -L flags are real argv entries
instead of a 16KB shell string.

test/object/archive_test.ww

@@ -0,0 +1,169 @@
+package archive_test;
+
+// Archive-driven w6l observers (host ar). Ports of the retired native
+// carriers test/wcc/610_arch.c and 632_w6l_manyflags.c; every
+// assertion preserved.
+//
+// selectivity (610) — libfoo.a holds a needed member and a member
+// referencing an undefined extern; the link succeeds (exit 0) because
+// w6l pulls ONLY the needed member — pulling lib_bad would fail with
+// an undefined reference to this_symbol_does_not_exist — and the
+// binary runs with exit 7. The bad member's @symbol extern is the
+// discriminator; keep it verbatim.
+//
+// manyflags (632, drain F-C) — -L/-l arrays must be sized by argc,
+// not a fixed 64-slot cap. -lfoo resolves only through the FINAL real
+// -L placed after N-1 junk dirs, so a successful link (exit 0 +
+// ELF64 ET_EXEC output) proves the Nth -L was honoured. N table
+// {1, 64, 65, 100, 128}; N=65 is the exact pre-fix overflow slot.
+// Both w6l and w6l_ww are driven (the w6l_ww leg was ungated in the
+// carrier too).
+//
+// Dropped C machinery, not assertions: wwtestpkg.h package-clause
+// injection, the 16KB shell-command buffer (argv is a real vector
+// here), and per-file unlink accounting (testenv.clean).
+
+import os;
+import os.exec;
+import strconv;
+import strings;
+import testenv;
+import time;
+
+fn fail(label: str, why: str) void = {
+	let m: str = strings.concat("archive FAIL: ", label, " -- ", why,
+		"\n");
+	os.write(2, m.ptr, m.len: u64);
+	assert(false);
+};
+
+fn tmo() time.duration = {
+	return (240i64 * (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;
+};
+
+// itos returns a view into a static buffer; dup materializes it.
+fn dec(n: i32) str = {
+	return strings.dup(strconv.itos(n: int, strconv.base.DEC));
+};
+
+// w6c + w6a on one package-main source; leaves <stem>.o next to it.
+fn compile(td: str, stem: str, body: str) void = {
+	let src: str = strings.concat(td, "/", stem, ".ww");
+	let asmf: str = strings.concat(td, "/", stem, ".s");
+	let obj: str = strings.concat(td, "/", stem, ".o");
+	testenv.writefile(src, body);
+	let cav: []str = [testenv.driver("w6c"), "-o", asmf, src];
+	if (runcode(td, strings.concat("c_", stem), cav) != 0) {
+		fail(stem, "w6c failed");
+	};
+	let aav: []str = [testenv.driver("w6a"), "-o", obj, asmf];
+	if (runcode(td, strings.concat("a_", stem), aav) != 0) {
+		fail(stem, "w6a failed");
+	};
+};
+
+// ---- selectivity (610) -------------------------------------------------
+
+@test fn selectivity() void = {
+	let td: str = testenv.fresh();
+	compile(td, "lib_good", strings.concat("package main;\n",
+		"export fn f1() i32 = { return 7; };\n"));
+	// defines f2 but also references an undefined extern — the
+	// discriminator: pulling this member makes the link fail
+	compile(td, "lib_bad", strings.concat("package main;\n",
+		"@symbol(\"this_symbol_does_not_exist\") fn bogus() i32;\n",
+		"export fn f2() i32 = { return bogus(); };\n"));
+	// the plain prototype declares f1 in the same (main) module, so
+	// the call resolves to main.f1 — matching lib_good's definition
+	compile(td, "m", strings.concat("package main;\n",
+		"fn f1() i32;\n",
+		"fn main() i32 = { return f1(); };\n"));
+
+	let lib: str = strings.concat(td, "/libfoo.a");
+	let arav: []str = ["/usr/bin/ar", "rcs", lib,
+		strings.concat(td, "/lib_good.o"),
+		strings.concat(td, "/lib_bad.o")];
+	if (runcode(td, "ar", arav) != 0) { fail("selectivity", "ar failed"); };
+
+	let exe: str = strings.concat(td, "/m");
+	let start: str = strings.concat(testenv.repo(),
+		"/out/obj/rt/start.o");
+	let lav: []str = [testenv.driver("w6l"), "-o", exe,
+		strings.concat(td, "/m.o"), start, lib];
+	let co: testenv.commandout;
+	testenv.runcommand(td, td, "link", lav, tmo(), &co);
+	if (co.termination != exec.termination.EXIT || co.code != 0) {
+		fail("selectivity", strings.concat(
+			"link failed (bad member pulled?): ", co.stderr));
+	};
+
+	let rav: []str = [exe];
+	if (runcode(td, "run_m", rav) != 7) {
+		fail("selectivity", "exit != 7");
+	};
+	testenv.clean(td);
+};
+
+// ---- manyflags (632) ---------------------------------------------------
+
+fn linkwith(td: str, lnk: str, n: i32) void = {
+	let tag: str = strings.concat(lnk, "_", dec(n));
+	let exe: str = strings.concat(td, "/x_", tag);
+	let av: []str = alloc([], 8u64)!;
+	append(av, testenv.driver(lnk));
+	append(av, "-o");
+	append(av, exe);
+	append(av, strings.concat(td, "/m.o"));
+	let i: i32 = 1;
+	for (i < n) {
+		append(av, strings.concat("-L/nonexist/wwfc_d", dec(i)));
+		i += 1;
+	};
+	append(av, strings.concat("-L", td));
+	append(av, "-lfoo");
+	if (runcode(td, strings.concat("lnk_", tag), av) != 0) {
+		fail("manyflags", strings.concat(lnk, " nflags=", dec(n),
+			" link failed (Nth -L not honoured)"));
+	};
+	let o: str = testenv.readfile(exe);
+	if (o.len < 64 || o[0] != 0x7fu8 || o[1] != 0x45u8
+		|| o[2] != 0x4cu8 || o[3] != 0x46u8) {
+		fail("manyflags", strings.concat(lnk, " nflags=", dec(n),
+			" output not an ELF"));
+	};
+	// ET_EXEC == 2 (Ehdr e_type at 16, LE u16)
+	if (testenv.leu16(o, 16) != 2u64) {
+		fail("manyflags", strings.concat(lnk, " nflags=", dec(n),
+			" output not ET_EXEC"));
+	};
+};
+
+@test fn manyflags() void = {
+	let td: str = testenv.fresh();
+	// a standalone main.o (no undefs) + an unrelated archived foo.o
+	compile(td, "m", strings.concat("package main;\n",
+		"fn main() i32 = { return 42; };\n"));
+	compile(td, "f", strings.concat("package main;\n",
+		"export fn foo() i32 = { return 7; };\n"));
+	let arav: []str = ["/usr/bin/ar", "rcs",
+		strings.concat(td, "/libfoo.a"),
+		strings.concat(td, "/f.o")];
+	if (runcode(td, "ar", arav) != 0) { fail("manyflags", "ar failed"); };
+
+	let counts: []i32 = [1, 64, 65, 100, 128];
+	let i: i32 = 0;
+	for (i < 5) {
+		linkwith(td, "w6l_ww", counts[i]);
+		linkwith(td, "w6l", counts[i]);
+		i += 1;
+	};
+	testenv.clean(td);
+};