fix: statically link musl build helpers

Author: wellwei

.github/workflows/ci-aarch64-fresh-install.yml

@@ -16,11 +16,21 @@ on:
   workflow_dispatch:
   schedule:
     - cron: '0 6 * * 1'   # weekly Mon 06:00 UTC
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'src/build/build_program.cppm'
+      - 'src/platform/process.cppm'
+      - 'tests/e2e/167_build_mcpp_musl_host_static.sh'
+      - '.github/workflows/ci-aarch64-fresh-install.yml'
   push:
     branches: [ main ]
     paths:
       - '.github/workflows/ci-aarch64-fresh-install.yml'
 
+permissions:
+  contents: read
+
 concurrency:
   group: ci-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
@@ -34,6 +44,10 @@ jobs:
       # Verbose every mcpp invocation — cold bootstrap path (src/cli.cppm).
       MCPP_VERBOSE: "1"
     steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
       - name: System info
         run: |
           uname -a
@@ -70,14 +84,38 @@ jobs:
           git clone --depth 1 https://github.com/openxlings/xim-pkgindex "$idx"
           grep -n "skipping relocation\|os.isfile(path.join(bindir" "$idx/pkgs/m/musl-gcc.lua" | head -2 || true
 
+      - name: Build current mcpp source for native regression tests
+        run: |
+          mcpp build --target aarch64-linux-musl
+          self=$(find target/aarch64-linux-musl -type f -name mcpp | head -1)
+          test -x "$self"
+          self=$(realpath "$self")
+          "$self" --version
+          echo "MCPP_SELF=$self" >> "$GITHUB_ENV"
+
       - name: Native build + run an `import std` program
         run: |
           work=$(mktemp -d); cd "$work"
-          mcpp new hello
+          "$MCPP_SELF" new hello
           cd hello
+          cat > build.mcpp <<'EOF'
+          #include <cstdio>
+          int main() {
+              FILE* marker = std::fopen("helper-ran", "w");
+              if (!marker) return 2;
+              std::fputs("ok\n", marker);
+              std::fclose(marker);
+              return 0;
+          }
+          EOF
           # default src uses import std (C++23)
-          mcpp build
-          out=$(mcpp run 2>/dev/null || true)
+          "$MCPP_SELF" build
+          test -f helper-ran
+          helper=target/.build-mcpp/build.mcpp.bin
+          file "$helper"
+          file "$helper" | grep -q 'statically linked'
+          ! readelf -lW "$helper" | grep -q 'Requesting program interpreter'
+          out=$("$MCPP_SELF" run 2>/dev/null)
           echo "program output: $out"
           bin=$(find target -type f -name hello | head -1)
           file "$bin"

src/build/build_program.cppm

@@ -585,8 +585,14 @@ std::expected<void, std::string> run_build_program(
     auto childEnv = contract_env(root, outDir, env);
     std::string ctxHash = contract_hash(childEnv);
 
+    const bool staticHostHelper = mcpp::platform::supports_full_static
+                               && mcpp::toolchain::is_musl_target(tc);
+    std::string compilerIdentity = hostCompiler.string();
+    compilerIdentity += staticHostHelper
+                      ? "\nbuild-program-link=musl-static-v1"
+                      : "\nbuild-program-link=default-v1";
     std::string programHash  = mcpp::toolchain::hash_file(src);
-    std::string compilerHash = mcpp::toolchain::hash_string(hostCompiler.string());
+    std::string compilerHash = mcpp::toolchain::hash_string(compilerIdentity);
 
     // Fast path: declared inputs + contract unchanged → reapply cached
     // directives, no run.
@@ -641,6 +647,11 @@ std::expected<void, std::string> run_build_program(
         compileArgv.push_back("-x"); compileArgv.push_back("none");
         compileArgv.push_back((bdir / "mcpp.o").string());
     }
+    // A dynamic musl helper requires /lib/ld-musl-<arch>.so.1 on the host,
+    // which glibc distributions do not provide. Keep the host build program in
+    // the musl toolchain's documented static world. This is link-only: `base`
+    // also feeds the bundled module's compile/precompile commands above.
+    if (staticHostHelper) compileArgv.push_back("-static");
     compileArgv.push_back("-o"); compileArgv.push_back(bin.string());
     mcpp::ui::info("build.mcpp", "compiling");
     // GCC resolves `import mcpp;` via gcm.cache/ relative to the compile cwd, so

src/platform/process.cppm

@@ -230,6 +230,11 @@ std::vector<std::string> merged_environ(
     }
     return out;
 }
+
+std::string spawn_failure(std::string_view program, int error) {
+    return std::format("posix_spawnp('{}') failed (error {}): {}\n",
+                       program, error, std::generic_category().message(error));
+}
 #else
 // Build a shell command line from an argv vector (Windows + residual non-POSIX
 // fallback only; Linux/macOS exec directly, #248). The first token (program)
@@ -444,7 +449,12 @@ RunResult capture_exec(
     int sp = ::posix_spawnp(&pid, cargv[0], &fa, nullptr, cargv.data(), envp.data());
     ::posix_spawn_file_actions_destroy(&fa);
     ::close(fds[1]);
-    if (sp != 0) { ::close(fds[0]); result.exit_code = 127; return result; }
+    if (sp != 0) {
+        ::close(fds[0]);
+        result.exit_code = 127;
+        result.output = spawn_failure(argv.front(), sp);
+        return result;
+    }
 
     std::array<char, 4096> buf{};
     ssize_t n;
@@ -547,7 +557,12 @@ RunResult capture_exec_deadline(
     int sp = ::posix_spawnp(&pid, cargv[0], &fa, nullptr, cargv.data(), envp.data());
     ::posix_spawn_file_actions_destroy(&fa);
     ::close(fds[1]);
-    if (sp != 0) { ::close(fds[0]); result.exit_code = 127; return result; }
+    if (sp != 0) {
+        ::close(fds[0]);
+        result.exit_code = 127;
+        result.output = spawn_failure(argv.front(), sp);
+        return result;
+    }
 
     ::fcntl(fds[0], F_SETFL, ::fcntl(fds[0], F_GETFL) | O_NONBLOCK);
 

tests/e2e/167_build_mcpp_musl_host_static.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# requires: musl elf
+# A build.mcpp is a host executable. When the host toolchain targets musl it
+# must be fully static, otherwise a glibc host cannot exec the generated helper
+# because /lib/ld-musl-<arch>.so.1 is absent.
+set -euo pipefail
+
+if [[ "$(uname -s)" != "Linux" ]]; then
+    echo "SKIP: Linux ELF regression"
+    exit 0
+fi
+
+: "${MCPP:?MCPP must point to the self-built mcpp binary}"
+
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+cd "$TMP"
+"$MCPP" new app > new.log 2>&1 || {
+    cat new.log
+    echo "FAIL: mcpp new failed"
+    exit 1
+}
+cd app
+
+cat >> mcpp.toml <<'EOF'
+[toolchain]
+default = "gcc@15.1.0-musl"
+EOF
+
+cat > build.mcpp <<'EOF'
+#include <cstdio>
+int main() {
+    FILE* marker = std::fopen("helper-ran", "w");
+    if (!marker) return 2;
+    std::fputs("ok\n", marker);
+    std::fclose(marker);
+    std::puts("mcpp:rerun-if-changed=build.mcpp");
+    return 0;
+}
+EOF
+
+"$MCPP" build > build.log 2>&1 || {
+    cat build.log
+    echo "FAIL: musl build.mcpp helper did not run on the glibc host"
+    exit 1
+}
+
+helper=target/.build-mcpp/build.mcpp.bin
+test -f helper-ran || { cat build.log; echo "FAIL: build.mcpp did not run"; exit 1; }
+test -x "$helper" || { cat build.log; echo "FAIL: helper binary missing"; exit 1; }
+
+file "$helper"
+file "$helper" | grep -q 'statically linked' || {
+    echo "FAIL: musl host helper is not statically linked"
+    exit 1
+}
+if readelf -lW "$helper" | grep -q 'Requesting program interpreter'; then
+    readelf -lW "$helper"
+    echo "FAIL: musl host helper contains PT_INTERP"
+    exit 1
+fi
+
+echo "OK"

tests/unit/test_process_run_exec.cpp

@@ -44,6 +44,14 @@ TEST(RunExec, ReturnsErrorWhenProgramMissing) {
     EXPECT_NE(process::run_exec({"/no/such/program/mcpp-xyz"}), 0);
 }
 
+TEST(CaptureExec, MissingProgramReportsSpawnFailure) {
+    constexpr std::string_view missing = "/no/such/program/mcpp-capture-xyz";
+    auto r = process::capture_exec({std::string(missing)});
+    EXPECT_EQ(r.exit_code, 127);
+    EXPECT_NE(r.output.find(missing), std::string::npos) << r.output;
+    EXPECT_NE(r.output.find("error 2"), std::string::npos) << r.output;
+}
+
 TEST(CaptureExec, CapturesStdoutWithoutShell) {
     auto r = process::capture_exec({"/bin/echo", "hello world"});
     EXPECT_EQ(r.exit_code, 0);