feat: ensure sysroot complete by symlinking from payload xpkgs

When GCC's probed sysroot (subos/default) is missing linux kernel
headers or glibc headers, symlink them from the payload xpkgs:
  - linux/, asm/, asm-generic/ ← scode-x-linux-headers xpkg
  - features.h, bits/, etc.    ← xim-x-glibc xpkg

This makes mcpp self-sufficient: it uses subos/default as a sysroot
directory for GCC's include-fixed mechanism, but actively populates
it from payload rather than depending on xlings init completeness.

Principle: subos is just a directory layout that mcpp manages.
Content comes from xpkgs payloads. Clang doesn't use subos at all
(--no-default-config + explicit -isystem from payload).

Author: Sunrisepeak

src/toolchain/detect.cppm

@@ -81,6 +81,12 @@ detect(const std::filesystem::path& explicit_compiler) {
     // When available, flags are assembled from these paths instead of --sysroot.
     tc.payloadPaths = probe_payload_paths(tc.binaryPath);
 
+    // For GCC: ensure the probed sysroot has complete headers by symlinking
+    // missing content (linux kernel headers, glibc) from payload xpkgs.
+    // This makes mcpp self-sufficient — not dependent on xlings subos init.
+    if (tc.payloadPaths && !tc.sysroot.empty())
+        ensure_sysroot_complete(tc.sysroot, *tc.payloadPaths);
+
     return tc;
 }
 

src/toolchain/probe.cppm

@@ -49,10 +49,16 @@ probe_sysroot(const std::filesystem::path& compilerBin,
 
 // Probe fine-grained sysroot paths from sibling xpkgs payloads.
 // Returns populated PayloadPaths if glibc xpkg found; linux-headers
-// may be empty if not available (host /usr/include used as fallback).
+// may be empty if not available.
 std::optional<PayloadPaths>
 probe_payload_paths(const std::filesystem::path& compilerBin);
 
+// Ensure sysroot directory has complete headers by symlinking from
+// payload xpkgs. Called when GCC's probed sysroot exists but may
+// be missing linux kernel headers or glibc headers.
+void ensure_sysroot_complete(const std::filesystem::path& sysroot,
+                             const PayloadPaths& pp);
+
 } // namespace mcpp::toolchain
 
 namespace mcpp::toolchain {
@@ -345,4 +351,40 @@ probe_payload_paths(const std::filesystem::path& compilerBin) {
     return pp;
 }
 
+void ensure_sysroot_complete(const std::filesystem::path& sysroot,
+                             const PayloadPaths& pp) {
+    if (sysroot.empty()) return;
+
+    auto sysrootInclude = sysroot / "usr" / "include";
+    if (!std::filesystem::exists(sysrootInclude)) return;
+
+    std::error_code ec;
+
+    // Ensure linux kernel headers are present in sysroot.
+    // If missing, symlink from linux-headers payload.
+    if (!pp.linuxInclude.empty()) {
+        for (auto dir : {"linux", "asm", "asm-generic"}) {
+            auto target = sysrootInclude / dir;
+            auto source = pp.linuxInclude / dir;
+            if (!std::filesystem::exists(target, ec) && std::filesystem::exists(source, ec)) {
+                std::filesystem::create_directory_symlink(source, target, ec);
+            }
+        }
+    }
+
+    // Ensure glibc headers are present if sysroot is bare.
+    if (!std::filesystem::exists(sysrootInclude / "features.h", ec)) {
+        // Symlink individual glibc dirs/files into sysroot.
+        for (auto& entry : std::filesystem::directory_iterator(pp.glibcInclude, ec)) {
+            auto target = sysrootInclude / entry.path().filename();
+            if (!std::filesystem::exists(target, ec)) {
+                if (entry.is_directory(ec))
+                    std::filesystem::create_directory_symlink(entry.path(), target, ec);
+                else
+                    std::filesystem::create_symlink(entry.path(), target, ec);
+            }
+        }
+    }
+}
+
 } // namespace mcpp::toolchain