fix(bench): the generated fixture needs the payload flags too, and a shim is not an engine

CI 上 fixture 的 cmake/xmake 全红,`cannot find crt1.o / crti.o / -lm`。

**我的公平性修复只做了一半。** `--compiler payload:gcc` 把 mcpp registry 里的
编译器交给了每个引擎,但**生成的** fixture 描述里没有任何 payload 接线 ——
`bench_hermetic_payload()` 只存在于 checked-in 的 bench/projects/ 里。一个裸的
registry gcc 不知道自己的汇编器、链接器和 libc 在哪,而 cmake 把这个报成
「编译器无法编译一个简单程序」,只字不提 sysroot。

`bench.toolchain::payload_flags()` 现在算出这些 flag,`emit_cmake` 在
**`project()` 之前**写入(cmake 的编译器探测就发生在 project() 里),
`emit_xmake` 通过 add_cxflags/add_ldflags 写入。gcc 拿 -B + --sysroot,
clang 拿显式的 libc++ include 链 —— 与 hermetic_payload.cmake 同一套判断,
注释里写明了「同一个决策在两处」以及为什么不能靠 include 一个绝对路径。

**另一条:xlings 的 shim 会替一个没装的程序回答。** 问它 `--version`,它打印
`[error] xlings: 'bazel' is not installed` 然后**退出 0**。照单全收就是
「present,版本 = 那句错误」,于是该引擎的每个格子都跑了、都失败了,并被记成
**对引擎的发现**,而不是「这台机器上没装」—— macOS 每个 job 18 个格子。
`probe_program` 现在把这种 banner 当作 absent。

本机验证:fixture 的 cmake/xmake modules cold 从「configure 失败」变成
4.29s / 3.07s。

Author: speak-agent

bench/src/engines/engine.cppm

@@ -131,6 +131,19 @@ inline Availability probe_program(std::string_view program,
                                    version_argv.size() > 1 ? version_argv[1] : "--version",
                                    r.exit_code)};
     auto banner = first_line(*captured);
+    // ⚠️ A SHIM THAT ANSWERS FOR A PROGRAM IT DOES NOT HAVE. xlings installs
+    // `bazel`, `mcpp` and friends as shims on PATH; ask one for its version
+    // when the package is not installed and it prints
+    //
+    //     [error] xlings: 'bazel' is not installed
+    //
+    // and exits ZERO. Taken at face value that is "present, version =
+    // <error message>", so every cell for that engine ran, failed, and was
+    // recorded as a FINDING against the engine rather than as "not installed
+    // here" — 18 cells per macOS job.
+    if (banner.find("is not installed") != std::string::npos)
+        return {false, std::format("{} resolves to a shim that reports it is not "
+                                   "installed: {}", program, banner)};
     return {true, banner.empty() ? std::string(program) : banner};
 }
 

bench/src/fixture/buildfiles.cppm

@@ -62,6 +62,15 @@ inline std::string join(const std::vector<std::string>& v, std::string_view sep,
     return out;
 }
 
+
+// Leading space is convenient when concatenating flag strings and wrong inside
+// a quoted xmake argument.
+inline std::string trim_copy(std::string_view s) {
+    while (!s.empty() && s.front() == ' ') s.remove_prefix(1);
+    while (!s.empty() && s.back()  == ' ') s.remove_suffix(1);
+    return std::string(s);
+}
+
 }  // namespace detail
 
 // --- mcpp -----------------------------------------------------------------
@@ -102,12 +111,24 @@ inline void emit_mcpp(const std::filesystem::path& root, Variant variant, const
 
 // --- cmake ----------------------------------------------------------------
 
-inline void emit_cmake(const std::filesystem::path& root, Variant variant, const Shape& s) {
+inline void emit_cmake(const std::filesystem::path& root, Variant variant, const Shape& s,
+                       std::string_view compiler = {}) {
     const auto set = source_set(variant, s);
+    // The payload flags go in BEFORE project(), because cmake's "can the
+    // compiler build a trivial program" probe runs during project() — and a
+    // bare registry gcc fails that probe at the LINK with `cannot find crt1.o`,
+    // reported as a configure error that never mentions a sysroot.
+    const auto pf = toolchain::payload_flags(compiler);
     std::string cm =
         "# Generated by bench.fixture.buildfiles — do not edit.\n"
-        "cmake_minimum_required(VERSION 3.28)\n"
-        "project(fx CXX)\n"
+        "cmake_minimum_required(VERSION 3.28)\n";
+    if (!pf.compile.empty() || !pf.link.empty()) {
+        cm += std::format("set(CMAKE_CXX_FLAGS \"${{CMAKE_CXX_FLAGS}}{}\")\n"
+                          "set(CMAKE_C_FLAGS   \"${{CMAKE_C_FLAGS}}{}\")\n"
+                          "set(CMAKE_EXE_LINKER_FLAGS \"${{CMAKE_EXE_LINKER_FLAGS}}{}\")\n",
+                          pf.compile, pf.compile, pf.link);
+    }
+    cm += "project(fx CXX)\n"
         "set(CMAKE_CXX_STANDARD 23)\n"
         "set(CMAKE_CXX_STANDARD_REQUIRED ON)\n"
         "set(CMAKE_CXX_EXTENSIONS OFF)\n"
@@ -128,7 +149,9 @@ inline void emit_cmake(const std::filesystem::path& root, Variant variant, const
 
 // --- xmake ----------------------------------------------------------------
 
-inline void emit_xmake(const std::filesystem::path& root, Variant variant, const Shape&) {
+inline void emit_xmake(const std::filesystem::path& root, Variant variant, const Shape&,
+                       std::string_view compiler = {}) {
+    const auto pf = toolchain::payload_flags(compiler);
     std::string lua =
         "-- Generated by bench.fixture.buildfiles — do not edit.\n"
         "set_project(\"fx\")\n"
@@ -150,6 +173,14 @@ inline void emit_xmake(const std::filesystem::path& root, Variant variant, const
         // cost none of the others do.
         lua += "    set_policy(\"build.c++.modules.std\", false)\n";
     }
+    // Same payload flags as the cmake arm: xmake is handed the driver through
+    // CXX, and a registry gcc without -B/--sysroot cannot link.
+    if (!pf.compile.empty())
+        lua += std::format("    add_cxflags(\"{}\", {{force = true}})\n",
+                           detail::trim_copy(pf.compile));
+    if (!pf.link.empty())
+        lua += std::format("    add_ldflags(\"{}\", {{force = true}})\n",
+                           detail::trim_copy(pf.link));
     detail::write(root / "xmake.lua", lua);
 }
 
@@ -206,8 +237,8 @@ inline void emit_bazel(const std::filesystem::path& root, Variant variant, const
 inline void emit_all(const std::filesystem::path& root, Variant variant, const Shape& s,
                      std::string_view compiler = {}) {
     emit_mcpp(root, variant, s, compiler);
-    emit_cmake(root, variant, s);
-    emit_xmake(root, variant, s);
+    emit_cmake(root, variant, s, compiler);
+    emit_xmake(root, variant, s, compiler);
     emit_bazel(root, variant, s);
 }
 

bench/src/toolchain.cppm

@@ -115,4 +115,72 @@ inline Resolved payload_cxx(std::string_view compiler) {
                             driver.string(), clang ? "llvm" : "gcc", ver)};
 }
 
+// The flags a FOREIGN engine needs so that a payload compiler can actually
+// build and link — the generated fixture's counterpart of
+// bench/projects/common/cmake/hermetic_payload.cmake.
+//
+// ⚠️ WHY THIS EXISTS AT ALL, given that file exists. The checked-in project
+// descriptions `include()` it; the fixture is GENERATED into a scratch
+// directory by a binary that may live anywhere, so it has no path to include.
+// The two are the same decision in two places and must be kept in step — the
+// alternative considered (emit an `include()` of an absolute path) makes every
+// generated fixture depend on this checkout still being where it was.
+//
+// It is needed because `--compiler payload:gcc` hands cmake and xmake a
+// compiler out of mcpp's registry, and a bare registry gcc has no idea where
+// its assembler, linker or libc are:
+//
+//     /usr/bin/ld: cannot find crt1.o: No such file or directory
+//     /usr/bin/ld: cannot find -lm: No such file or directory
+//
+// which cmake reports as "the C++ compiler is not able to compile a simple
+// test program", i.e. as a configure failure with no mention of a sysroot.
+struct PayloadFlags {
+    std::string compile;
+    std::string link;
+};
+
+inline PayloadFlags payload_flags(std::string_view compiler) {
+    PayloadFlags f;
+    // Only a compiler FROM the registry gets these; a host compiler already
+    // knows where its own runtime is, and adding a registry sysroot to it
+    // produces a mixed build that fails somewhere unrelated.
+    if (compiler.find("xpkgs") == std::string_view::npos) return f;
+
+    const auto xpkgs = registry_xpkgs();
+    if (xpkgs.empty()) return f;
+    std::error_code ec;
+
+    if (!is_clang_request(compiler)) {
+        // gcc: -B for `as`/`ld`, --sysroot for headers and startup files, and
+        // BOTH must reach compile and link — the driver spawns `as` at compile
+        // time and `ld` at link time, so one side alone silently falls back.
+        for (const auto& e : std::filesystem::directory_iterator(
+                 xpkgs / "xim-x-binutils", ec)) {
+            f.compile += " -B" + (e.path() / "bin").string();
+            f.link    += " -B" + (e.path() / "bin").string();
+            break;
+        }
+        auto sysroot = registry_xpkgs().parent_path().parent_path()
+                     / "subos" / "default";
+        if (std::filesystem::is_directory(sysroot, ec)) {
+            f.compile += " --sysroot=" + sysroot.string();
+            f.link    += " --sysroot=" + sysroot.string();
+        }
+        return f;
+    }
+
+    // clang: an explicit libc++ chain rather than --sysroot, which is what mcpp
+    // itself drives clang with. Handing clang gcc's sysroot is the mirror of the
+    // bug above — one arm on the payload libc, the other on the host's.
+    const std::string ver{on_windows() ? kLlvmWindows : kLlvm};
+    const auto root = xpkgs / "xim-x-llvm" / ver;
+    if (std::filesystem::is_directory(root / "include" / "c++" / "v1", ec)) {
+        f.compile += " --no-default-config -nostdinc++"
+                     " -isystem" + (root / "include" / "c++" / "v1").string();
+        f.link    += " -nostdlib++ -L" + (root / "lib").string() + " -lc++ -lc++abi";
+    }
+    return f;
+}
+
 }  // namespace bench::toolchain