refactor: loader paths from data everywhere — no ld-linux-x86-64 hardcodes

fixup_gcc_specs detects the baked loader name from the specs content and
replaces it with resolve_loader()'s answer (any glibc arch); the specs dir is
discovered instead of assuming x86_64-linux-gnu. mcpp pack derives the
BundleProject PT_INTERP distro path from the loader soname ldd resolved for
the binary being packed (LSB /lib64 vs /lib), instead of a hardcoded x86_64
string. The only remaining literal loader names live in linkmodel.cppm's
per-arch triple map.

Author: Sunrisepeak

src/pack/pack.cppm

@@ -638,15 +638,23 @@ run(const Plan& plan, const mcpp::config::GlobalConfig& cfg)
                 return std::unexpected(Error{r.error()});
 
             // PT_INTERP handling differs by mode:
-            //   BundleProject → repoint to /lib64/ld-linux-x86-64.so.2
-            //                   (LSB-mandated symlink on glibc distros)
+            //   BundleProject → repoint to the target distro's loader
+            //                   (LSB layout: /lib64/<loader> on x86_64,
+            //                   /lib/<loader> elsewhere), derived from the
+            //                   loader soname ldd resolved for THIS binary —
+            //                   arch-correct without hardcoding a name.
             //   BundleAll     → leave PT_INTERP alone; the wrapper script
             //                   ignores it and launches via the bundled
             //                   loader directly.
             if (plan.opts.mode == Mode::BundleProject || plan.opts.mode == Mode::None) {
-                if (auto r = set_interpreter(bundledBinary,
-                        "/lib64/ld-linux-x86-64.so.2", patchelf); !r)
-                    return std::unexpected(Error{r.error()});
+                if (auto soname = find_loader_soname(*deps); !soname.empty()) {
+                    auto distroLoader =
+                        (soname == "ld-linux-x86-64.so.2" ? "/lib64/" : "/lib/")
+                        + soname;
+                    if (auto r = set_interpreter(bundledBinary, distroLoader,
+                                                 patchelf); !r)
+                        return std::unexpected(Error{r.error()});
+                }
             }
         }
 

src/toolchain/post_install.cppm

@@ -84,41 +84,52 @@ export void patchelf_walk(const std::filesystem::path& dir,
 // xlings' home, not mcpp's sandbox glibc — binaries would fail to exec.
 //
 // Mcpp does a post-install spec rewrite:
-//   - Dynamically detects the baked-in lib dir from the specs file
-//   - Replaces the dynamic-linker path with <glibc_lib64>/ld-linux-x86-64.so.2
-//   - Replaces the rpath with <glibc_lib64>:<gcc_lib64>
+//   - Dynamically detects the baked-in loader path from the specs file
+//   - Replaces it with the sandbox glibc payload's loader
+//   - Replaces the rpath with <glibc_lib>:<gcc_lib64>
 // Idempotent — skips if already pointing at the correct glibc.
-// Extract the baked-in lib directory from a gcc specs file by finding
-// the dynamic-linker path that ends with `/ld-linux-x86-64.so.2`.
-// xim bakes the installing user's XLINGS_HOME into specs at install
-// time, so the path varies per machine — we cannot hardcode it.
-std::string detect_baked_lib_dir(const std::string& specsContent) {
-    constexpr std::string_view kLoader = "/ld-linux-x86-64.so.2";
-    auto pos = specsContent.find(kLoader);
+// Extract the baked-in glibc loader path (".../ld-linux-<arch>.so.N") from a
+// gcc specs file. xim bakes the installing user's XLINGS_HOME into specs at
+// install time, so the DIR varies per machine, and the loader NAME varies
+// per arch — detect both instead of hardcoding either.
+std::string detect_baked_loader(const std::string& specsContent) {
+    constexpr std::string_view kLoaderMark = "/ld-linux-";
+    auto pos = specsContent.find(kLoaderMark);
     if (pos == std::string::npos) return "";
-    // Walk backwards to find start of the absolute path
+    // Walk backwards to find start of the absolute path…
     auto start = pos;
     while (start > 0 && specsContent[start - 1] != ' '
                      && specsContent[start - 1] != ':'
                      && specsContent[start - 1] != ';'
                      && specsContent[start - 1] != '\n') {
         --start;
     }
-    auto dir = specsContent.substr(start, pos - start);
-    // Sanity: must be absolute
-    if (dir.empty() || dir[0] != '/') return "";
-    // Skip if it already points to the target glibc (no fixup needed)
-    return dir;
+    // …and forwards to its end.
+    auto end = pos + kLoaderMark.size();
+    while (end < specsContent.size()
+           && !std::isspace(static_cast<unsigned char>(specsContent[end]))
+           && specsContent[end] != ':' && specsContent[end] != ';') {
+        ++end;
+    }
+    auto loader = specsContent.substr(start, end - start);
+    if (loader.empty() || loader[0] != '/') return "";
+    return loader;
 }
 
 void fixup_gcc_specs(const std::filesystem::path& gccPkgRoot,
                      const std::filesystem::path& glibcLibDir,
                      const std::filesystem::path& gccLibDir)
 {
-    auto specsParent = gccPkgRoot / "lib" / "gcc" / "x86_64-linux-gnu";
-    if (!std::filesystem::exists(specsParent)) return;
+    std::filesystem::path specsParent;
+    std::error_code ec;
+    for (auto it = std::filesystem::directory_iterator(gccPkgRoot / "lib" / "gcc", ec);
+         !ec && it != std::filesystem::directory_iterator{}; it.increment(ec)) {
+        if (it->is_directory(ec)) { specsParent = it->path(); break; }
+    }
+    if (specsParent.empty()) return;
 
-    auto loaderReplacement = (glibcLibDir / "ld-linux-x86-64.so.2").string();
+    auto loaderReplacement = resolve_loader(glibcLibDir, /*targetTriple=*/{}).string();
+    if (loaderReplacement.empty()) return;
     auto rpathReplacement  = std::format("{}:{}",
                                          glibcLibDir.string(),
                                          gccLibDir.string());
@@ -141,13 +152,12 @@ void fixup_gcc_specs(const std::filesystem::path& gccPkgRoot,
         std::stringstream ss;  ss << is.rdbuf();
         std::string content = ss.str();
 
-        auto bakedDir = detect_baked_lib_dir(content);
-        if (bakedDir.empty()) continue;
+        auto bakedLoader = detect_baked_loader(content);
+        if (bakedLoader.empty()) continue;
+        auto bakedDir = std::filesystem::path(bakedLoader).parent_path().string();
         // Already pointing at the right place — no fixup needed.
         if (bakedDir == glibcLibDir.string()) continue;
 
-        auto bakedLoader = bakedDir + "/ld-linux-x86-64.so.2";
-
         // Order matters: replace the full loader file path first so the
         // shorter dir pattern doesn't eat its prefix.
         replace_all(content, bakedLoader, loaderReplacement);