fix: scope bound glibc to compiler commands

Author: ZheFeng7110

src/build/ninja_backend.cppm

@@ -589,10 +589,17 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     // The macOS initializer-ordering shim (#336) is a C translation unit, so
     // it needs the C driver bindings even in a project with no .c sources.
     const bool need_ios_init_shim = flags.needsStreamInitShim;
-    append(std::format("cxx       = {}\n", escape_ninja_path(flags.cxxBinary)));
+    auto compiler_command = [&](const std::filesystem::path& binary) {
+        const auto& dirs = plan.toolchain.compilerInvocationRuntimeDirs.empty()
+            ? plan.toolchain.compilerRuntimeDirs
+            : plan.toolchain.compilerInvocationRuntimeDirs;
+        return mcpp::platform::linux_::build_clean_ld_library_path_prefix(dirs)
+             + escape_ninja_path(binary);
+    };
+    append(std::format("cxx       = {}\n", compiler_command(flags.cxxBinary)));
     append(std::format("cxxflags  = {}\n", flags.cxx));
     if (need_c_rule || need_asm_rule || need_ios_init_shim) {  // asm_object drives the C compiler too
-        append(std::format("cc        = {}\n", escape_ninja_path(flags.ccBinary)));
+        append(std::format("cc        = {}\n", compiler_command(flags.ccBinary)));
     }
     if (need_c_rule || need_ios_init_shim) {
         append(std::format("cflags    = {}\n", flags.cc));

src/toolchain/detect.cppm

@@ -58,7 +58,9 @@ detect(const std::filesystem::path& explicit_compiler,
         return tc;
     }
 
-    tc.compilerRuntimeDirs = discover_compiler_runtime_dirs(tc.binaryPath, runtimeBinding);
+    tc.compilerRuntimeDirs = discover_compiler_runtime_dirs(tc.binaryPath);
+    tc.compilerInvocationRuntimeDirs =
+        discover_compiler_invocation_runtime_dirs(tc.binaryPath, runtimeBinding);
     auto envPrefix = compiler_env_prefix(tc);
 
     auto ver_r = run_capture(std::format("{}{} --version 2>&1",

src/toolchain/model.cppm

@@ -100,7 +100,13 @@ struct Toolchain {
     // zero-libc tier and on hosted targets.
     std::string                         targetSysrootPkg;
     std::filesystem::path               targetSysrootLib;
-    std::vector<std::filesystem::path>   compilerRuntimeDirs; // LD_LIBRARY_PATH for private tools
+    // Runtime directories inherited by Ninja and its whole process tree. Keep
+    // private libc out of this list: Ninja launches each edge through /bin/sh.
+    std::vector<std::filesystem::path>   compilerRuntimeDirs;
+    // Directories required when starting a compiler driver. On Linux this may
+    // include the bound glibc payload, but it is applied inside each compiler
+    // command after Ninja's shell has already started.
+    std::vector<std::filesystem::path>   compilerInvocationRuntimeDirs;
     std::vector<std::filesystem::path>   linkRuntimeDirs;     // -L/-rpath dirs for produced binaries
     // Environment the toolchain's tools need when invoked (set on the ninja
     // process, inherited by compiler/linker children). Empty for GCC/Clang

src/toolchain/probe.cppm

@@ -31,8 +31,11 @@ std::string trim_line(std::string s);
 std::string normalize_driver_output(std::string_view s);
 
 std::vector<std::filesystem::path>
-discover_compiler_runtime_dirs(const std::filesystem::path& compilerBin,
-                               std::string_view runtimeBinding = {});
+discover_compiler_runtime_dirs(const std::filesystem::path& compilerBin);
+
+std::vector<std::filesystem::path>
+discover_compiler_invocation_runtime_dirs(const std::filesystem::path& compilerBin,
+                                          std::string_view runtimeBinding);
 
 std::vector<std::filesystem::path>
 discover_link_runtime_dirs(const std::filesystem::path& compilerBin,
@@ -190,8 +193,7 @@ std::string normalize_driver_output(std::string_view s) {
 }
 
 std::vector<std::filesystem::path>
-discover_compiler_runtime_dirs(const std::filesystem::path& compilerBin,
-                               std::string_view runtimeBinding) {
+discover_compiler_runtime_dirs(const std::filesystem::path& compilerBin) {
     std::vector<std::filesystem::path> dirs;
     auto root = compilerBin.parent_path().parent_path();
 
@@ -212,6 +214,14 @@ discover_compiler_runtime_dirs(const std::filesystem::path& compilerBin,
         append_existing_unique(dirs, *rt / "lib");
     }
 
+    return dirs;
+}
+
+std::vector<std::filesystem::path>
+discover_compiler_invocation_runtime_dirs(const std::filesystem::path& compilerBin,
+                                          std::string_view runtimeBinding) {
+    auto dirs = discover_compiler_runtime_dirs(compilerBin);
+
     // A managed compiler's DT_RUNPATH reaches its bound private libc for its
     // own direct dependencies only. A host /etc/ld.so.preload library can
     // require libdl.so.2 itself, where that non-transitive RUNPATH cannot help.
@@ -251,7 +261,8 @@ discover_link_runtime_dirs(const std::filesystem::path& compilerBin,
 }
 
 std::string compiler_env_prefix(const Toolchain& tc) {
-    return env_prefix_for_dirs(tc.compilerRuntimeDirs);
+    return env_prefix_for_dirs(tc.compilerInvocationRuntimeDirs.empty()
+        ? tc.compilerRuntimeDirs : tc.compilerInvocationRuntimeDirs);
 }
 
 std::expected<std::filesystem::path, DetectError>

tests/unit/test_toolchain_detect.cpp

@@ -127,9 +127,13 @@ esac
 
     auto tc = detect(compiler, "glibc@2.44");
     ASSERT_TRUE(tc.has_value()) << tc.error().message;
-    EXPECT_NE(std::find(tc->compilerRuntimeDirs.begin(), tc->compilerRuntimeDirs.end(), wanted),
-              tc->compilerRuntimeDirs.end());
-    EXPECT_EQ(std::find(tc->compilerRuntimeDirs.begin(), tc->compilerRuntimeDirs.end(), other),
+    EXPECT_NE(std::find(tc->compilerInvocationRuntimeDirs.begin(),
+                        tc->compilerInvocationRuntimeDirs.end(), wanted),
+              tc->compilerInvocationRuntimeDirs.end());
+    EXPECT_EQ(std::find(tc->compilerInvocationRuntimeDirs.begin(),
+                        tc->compilerInvocationRuntimeDirs.end(), other),
+              tc->compilerInvocationRuntimeDirs.end());
+    EXPECT_EQ(std::find(tc->compilerRuntimeDirs.begin(), tc->compilerRuntimeDirs.end(), wanted),
               tc->compilerRuntimeDirs.end());
 }
 #endif // defined(__linux__)