const std::filesystem::path& rootCanon) {

if (rootCanon.empty()) return true;

std::error_code ec;

auto real = std::filesystem::weakly_canonical(file, ec);

if (ec) return true;

auto r = rootCanon.generic_string();

auto f = real.generic_string();

if (f == r) return false;

return !(f.size() > r.size() && f.starts_with(r) && f[r.size()] == '/');

const std::filesystem::path& loader,

const std::string& rpath,

const std::filesystem::path& patchelfBin,

const std::filesystem::path& fenceRoot)

{

if (!std::filesystem::exists(dir) || !std::filesystem::exists(patchelfBin))

return;

std::error_code ec;

for (auto it = std::filesystem::recursive_directory_iterator(dir, ec);

it != std::filesystem::recursive_directory_iterator{}; it.increment(ec))

{

if (ec) { ec.clear(); continue; }

if (!it->is_regular_file(ec)) continue;

auto path = it->path();

// Skip non-ELF (cheap magic check)

std::ifstream is(path, std::ios::binary);

char m[4]{};

is.read(m, 4);

if (!is || m[0] != 0x7f || m[1] != 'E' || m[2] != 'L' || m[3] != 'F')

continue;

is.close();

// #273 fence: never rewrite files that physically live outside the

// sandbox (payload reached through a symlink → foreign installation).

if (escapes_containment(path, fenceRoot)) {

mcpp::log::verbose("toolchain", std::format(

"patchelf_walk: skip (outside sandbox, #273 fence): {}",

path.string()));

continue;

}

// Probe PT_INTERP — skip static binaries (no interp).

auto probe = std::format("{} --print-interpreter {} 2>/dev/null",

mcpp::platform::shell::quote(patchelfBin.string()),

mcpp::platform::shell::quote(path.string()));

auto probeResult = mcpp::platform::process::capture(probe);

bool hasInterp = (probeResult.exit_code == 0 && !probeResult.output.empty());

// Patch a COPY and atomically rename it into place. The payload can

// contain libraries the CURRENT process has mmapped (a self-hosted

// mcpp links the sandbox glibc/libgcc_s, and since the fixup

// pipeline runs on every install path, the patching process may BE

// such a consumer). In-place patchelf rewrites the backing file of

// those live mappings and corrupts the running process — observed

// on CI as an exit-time SIGSEGV in _dl_fini jumping to an

// unrelocated address. rename() gives the patched content a fresh

// inode while live processes keep the old one.

auto tmp = path;

tmp += ".mcpp-patch.tmp";

{

std::error_code cec;

std::filesystem::copy_file(

path, tmp, std::filesystem::copy_options::overwrite_existing, cec);

if (cec) continue;

std::filesystem::permissions(

tmp, std::filesystem::status(path, cec).permissions(),

std::filesystem::perm_options::replace, cec);

}

bool patched = true;

if (hasInterp) {

patched = (mcpp::platform::process::run_silent(std::format(

"{} --set-interpreter {} {} 2>/dev/null",

mcpp::platform::shell::quote(patchelfBin.string()),

mcpp::platform::shell::quote(loader.string()),

mcpp::platform::shell::quote(tmp.string()))) == 0) && patched;

}

// Always set RUNPATH (works on .so too — they need to find deps).

if (!rpath.empty()) {

patched = (mcpp::platform::process::run_silent(std::format(

"{} --set-rpath {} {} 2>/dev/null",

mcpp::platform::shell::quote(patchelfBin.string()),

mcpp::platform::shell::quote(rpath),

mcpp::platform::shell::quote(tmp.string()))) == 0) && patched;

}

std::error_code rec;

if (patched) std::filesystem::rename(tmp, path, rec);

if (!patched || rec) std::filesystem::remove(tmp, rec);

}

const std::filesystem::path& glibcLibDir,

const std::filesystem::path& fenceRoot) {

// #273 fence — same rule the removed gcc specs fixup used.

if (escapes_containment(payloadRoot, fenceRoot)) {

mcpp::log::verbose("toolchain",

"fixup_clang_cfg: skip (payload outside sandbox, #273 fence)");

return;

}

auto binDir = payloadRoot / "bin";

if (!std::filesystem::exists(binDir)) return;

// Target triple from the payload layout (lib/<triple>), used for the

// loader lookup and the per-target libc++ include/lib dirs.

std::string triple;

std::error_code ec;

for (auto it = std::filesystem::directory_iterator(payloadRoot / "lib", ec);

!ec && it != std::filesystem::directory_iterator{}; it.increment(ec)) {

auto name = it->path().filename().string();

if (it->is_directory(ec) && name.find("-linux-") != std::string::npos) {

triple = name;

break;

}

}

std::string common, cxxOnly, cHdr;

auto cxxInclude = payloadRoot / "include" / "c++" / "v1";

if constexpr (mcpp::platform::is_macos) {

// macOS keeps its historical cfg semantics: the C library and the

// C++ runtime LINK both come from the SDK; only the libc++ HEADERS

// come from the payload. Do NOT add -nostdinc++/-stdlib=libc++

// here — a bare cfg-driven link has no libc++abi handling (that

// lives in the main build's needs_explicit_libcxx path) and dies

// with undefined __cxa_* / __gxx_personality_v0.

if (auto sdk = mcpp::platform::macos::sdk_path())

common += "--sysroot=" + sdk->string() + "\n";

if (std::filesystem::exists(cxxInclude))

cxxOnly += "-isystem " + cxxInclude.string() + "\n";

} else {

if (!glibcLibDir.empty()) {

auto loader = resolve_loader(glibcLibDir, triple);

common += "-B" + glibcLibDir.string() + "\n";

common += "-L" + glibcLibDir.string() + "\n";

if (!loader.empty())

common += "-Wl,--dynamic-linker=" + loader.string() + "\n";

common += "-Wl,--enable-new-dtags,-rpath," + glibcLibDir.string() + "\n";

}

common += "-fuse-ld=lld\n--rtlib=compiler-rt\n--unwindlib=libunwind\n";

// HEADER axis (C and C++ drivers alike): the C library and kernel

// headers come from the same payloads the link axis uses. Without

// these, a direct `clang hello.c` only works when the HOST happens

// to ship /usr/include — silently non-hermetic, broken on

// header-less machines. For C++ they must come AFTER the libc++

// block (its C-header wrappers reach libc via #include_next), so

// they are collected separately and appended in order below —

// byte-consistent with what llvm.lua's install hook generates.

if (!glibcLibDir.empty()) {

auto glibcInclude = glibcLibDir.parent_path() / "include";

if (std::filesystem::exists(glibcInclude / "features.h"))

cHdr += "-isystem " + glibcInclude.string() + "\n";

constexpr std::string_view kLinuxLimits = "include/linux/limits.h";

auto linuxHeaders = mcpp::xlings::paths::find_sibling_package(

payloadRoot / "bin" / "clang++", "linux-headers", kLinuxLimits);

if (!linuxHeaders)

linuxHeaders = mcpp::xlings::paths::find_home_tool(

"linux-headers", kLinuxLimits);

if (linuxHeaders)

cHdr += "-isystem " + (*linuxHeaders / "include").string() + "\n";

}

if (std::filesystem::exists(cxxInclude)) {

cxxOnly += "-nostdinc++\n-stdlib=libc++\n";

cxxOnly += "-isystem " + cxxInclude.string() + "\n";

}

if (!triple.empty()) {

auto tripleInclude = payloadRoot / "include" / triple / "c++" / "v1";

if (std::filesystem::exists(tripleInclude))

cxxOnly += "-isystem " + tripleInclude.string() + "\n";

}

cxxOnly += cHdr;

if (!triple.empty()) {

auto tripleLib = payloadRoot / "lib" / triple;

if (std::filesystem::exists(tripleLib)) {

cxxOnly += "-L" + tripleLib.string() + "\n";

cxxOnly += "-Wl,-rpath," + tripleLib.string() + "\n";

}

}

}

// Regenerate every existing cfg in bin/ (clang.cfg, clang++.cfg, and any

// versioned clang-<major>.cfg xlings created), classified C vs C++ by

// whether the driver name contains "++".

for (auto it = std::filesystem::directory_iterator(binDir, ec);

!ec && it != std::filesystem::directory_iterator{}; it.increment(ec)) {

auto name = it->path().filename().string();

if (!name.ends_with(".cfg")) continue;

const bool isCxx = name.find("++") != std::string::npos;

std::ofstream os(it->path());

os << common << (isCxx ? cxxOnly : cHdr);

}

std::string_view runtimeId) {

return select_glibc_payload_lib(

mcpp::xlings::paths::xim_tool_root(xlEnv, "glibc"), runtimeId);

const std::filesystem::path& payloadRoot,

const std::filesystem::path& glibcLibDir) {

auto xlEnv = mcpp::config::make_xlings_env(cfg);

auto gccLibDir = payloadRoot / "lib64";

auto patchelfBin = mcpp::xlings::paths::xim_tool(xlEnv, "patchelf",

mcpp::xlings::pinned::kPatchelfVersion) / "bin" / "patchelf";

if (!glibcLibDir.empty() && std::filesystem::exists(gccLibDir)

&& std::filesystem::exists(patchelfBin))

{

auto loader = resolve_loader(glibcLibDir, /*targetTriple=*/{});

auto rpath = std::format("{}:{}",

glibcLibDir.string(), gccLibDir.string());

mcpp::log::verbose("toolchain", std::format(

"gcc fixup: patchelf_walk rpath='{}'", rpath));

// Single trust root for every walk below — including the binutils

// SIBLING payloads, which the entry-point ownership guard does not

// cover (it only vets the gcc payload itself).

auto fence = containment_root(cfg.registryDir);

auto binutilsRoot = mcpp::xlings::paths::xim_tool_root(xlEnv, "binutils");

if (std::filesystem::exists(binutilsRoot)) {

for (auto& v : std::filesystem::directory_iterator(binutilsRoot))

patchelf_walk(v.path(), loader, rpath, patchelfBin, fence);

}

patchelf_walk(payloadRoot, loader, rpath, patchelfBin, fence);

} else {

mcpp::ui::warning(

"could not locate sandbox glibc/gcc/patchelf paths; "

"gcc-built binaries may have unresolved PT_INTERP/RUNPATH");

}

const std::filesystem::path& payloadRoot,

const std::filesystem::path& glibcLibDir) {

auto xlEnv = mcpp::config::make_xlings_env(cfg);

auto patchelfBin = mcpp::xlings::paths::xim_tool(xlEnv, "patchelf",

mcpp::xlings::pinned::kPatchelfVersion) / "bin" / "patchelf";

if (!glibcLibDir.empty() && std::filesystem::exists(patchelfBin)) {

auto loader = resolve_loader(glibcLibDir, /*targetTriple=*/{});

auto llvmLib = payloadRoot / "lib";

std::string rpath;

std::error_code ec;

for (auto it = std::filesystem::directory_iterator(llvmLib, ec);

!ec && it != std::filesystem::directory_iterator{}; it.increment(ec)) {

if (it->is_directory(ec)

&& it->path().filename().string().find("-linux-") != std::string::npos)

rpath += it->path().string() + ":";

}

rpath += llvmLib.string() + ":" + glibcLibDir.string();

mcpp::log::verbose("toolchain", std::format(

"llvm fixup: patchelf_walk lib/ rpath='{}'", rpath));

patchelf_walk(llvmLib, loader, rpath, patchelfBin,

containment_root(cfg.registryDir));

}

mcpp::log::verbose("toolchain", "llvm fixup: fixup_clang_cfg");

fixup_clang_cfg(payloadRoot, glibcLibDir, containment_root(cfg.registryDir));

std::ifstream is(bin, std::ios::binary);

if (!is) return {};

unsigned char ident[16]{};

is.read(reinterpret_cast<char*>(ident), sizeof ident);

if (!is || ident[0] != 0x7f || ident[1] != 'E'

|| ident[2] != 'L' || ident[3] != 'F') return {};

const bool is64 = ident[4] == 2;

const bool le = ident[5] == 1;

if (!is64 || !le) return {}; // the only shape payloads ship

auto u16 = [&](std::streamoff off) -> std::uint16_t {

is.seekg(off); unsigned char b[2]{};

is.read(reinterpret_cast<char*>(b), 2);

return static_cast<std::uint16_t>(b[0] | (b[1] << 8));

};

auto u64 = [&](std::streamoff off) -> std::uint64_t {

is.seekg(off); unsigned char b[8]{};

is.read(reinterpret_cast<char*>(b), 8);

std::uint64_t v = 0;

for (int i = 7; i >= 0; --i) v = (v << 8) | b[i];

return v;

};

const auto phoff = u64(0x20);

const auto phentsize = u16(0x36);

const auto phnum = u16(0x38);

if (!is || phoff == 0 || phentsize < 0x38 || phnum == 0) return {};

constexpr std::uint32_t kPtInterp = 3;

for (std::uint16_t i = 0; i < phnum; ++i) {

const auto ph = static_cast<std::streamoff>(phoff)

+ static_cast<std::streamoff>(i) * phentsize;

is.seekg(ph);

unsigned char t[4]{};

is.read(reinterpret_cast<char*>(t), 4);

if (!is) return {};

const std::uint32_t type =

static_cast<std::uint32_t>(t[0]) | (t[1] << 8)

| (t[2] << 16) | (static_cast<std::uint32_t>(t[3]) << 24);

if (type != kPtInterp) continue;

const auto offset = u64(ph + 0x08);

const auto filesz = u64(ph + 0x20);

if (filesz == 0 || filesz > 4096) return {};

std::string str(static_cast<std::size_t>(filesz), '\0');

is.seekg(static_cast<std::streamoff>(offset));

is.read(str.data(), static_cast<std::streamsize>(filesz));

if (!is) return {};

if (auto z = str.find('\0'); z != std::string::npos) str.resize(z);

return str;

}

return {};

if (compilerBin.empty()) return {};

std::error_code ec;

auto from_text = [](const std::string& text) -> std::string {

auto loader = detect_baked_loader(text);

if (loader.empty()) return {};

// The recorded path may name a subos VIEW (`<home>/subos/default/lib/

// ld-linux-...`), which is a symlink into the payload. R6: artifacts

// bind the payload, never the mutable view -- so resolve to the

// payload before reading a version off it. A view path has no version

// component at all, and parsing one yields nothing.

std::error_code cec;

if (auto real = std::filesystem::canonical(loader, cec); !cec)

loader = real.string();

// .../xim-x-glibc/<ver>/lib64/ld-linux-... — the version is the

// grandparent of the lib dir.

auto dir = std::filesystem::path(loader).parent_path(); // lib64

auto ver = dir.parent_path().filename().string(); // <ver>

auto pkg = dir.parent_path().parent_path().filename().string();

if (ver.empty() || pkg.find("glibc") == std::string::npos) return {};

return "glibc@" + ver;

};

// Which glibc payloads are actually installed. Every source below is

// checked against this, because all of them are RECORDS of a past state:

// specs and cfg were written at some install, PT_INTERP at some fixup. A

// payload can be replaced afterwards -- upgraded, garbage-collected -- and

// the record keeps naming what used to be there.

//

// That is not hypothetical. CI resolved `glibc@2.39` from a record while

// the only payload on disk was 2.44, so the exact-match probe correctly

// refused, no payload paths resolved, and the artifact fell through to the

// host loader. A fossil that names something no longer present is not an

// authority; it is just old.

std::vector<std::string> installed;

if (auto xpkgs = mcpp::xlings::paths::xpkgs_from_compiler(compilerBin)) {

for (auto it = std::filesystem::directory_iterator(*xpkgs / "xim-x-glibc", ec);

!ec && it != std::filesystem::directory_iterator{}; it.increment(ec)) {

if (!it->is_directory(ec)) continue;

auto v = it->path().filename().string();

if (!v.empty() && v.front() != '.') installed.push_back(v);

}

}

auto still_there = [&](const std::string& binding) {

if (binding.empty()) return false;

const auto at = binding.find('@');

if (at == std::string::npos) return false;

auto ver = binding.substr(at + 1);

return std::ranges::find(installed, ver) != installed.end();

};

auto read_file = [&](const std::filesystem::path& p) -> std::string {

if (!std::filesystem::exists(p, ec)) return {};

std::ifstream is(p);

std::stringstream ss; ss << is.rdbuf();

return ss.str();

};

// clang: the sibling <driver>.cfg.

auto cfg = compilerBin.parent_path()

/ (compilerBin.stem().string() + ".cfg");

if (auto r = from_text(read_file(cfg)); still_there(r)) return r;

// gcc: lib/gcc/<triple>/<ver>/specs, one level of globbing each.

auto gccRoot = compilerBin.parent_path().parent_path();

for (auto t = std::filesystem::directory_iterator(gccRoot / "lib" / "gcc", ec);

!ec && t != std::filesystem::directory_iterator{}; t.increment(ec)) {

for (auto v = std::filesystem::directory_iterator(t->path(), ec);

!ec && v != std::filesystem::directory_iterator{}; v.increment(ec)) {

if (auto r = from_text(read_file(v->path() / "specs")); still_there(r))

return r;

}

}

// The compiler's OWN interpreter.

//

// The two sources above are files mcpp used to write, and mcpp no longer

// writes them -- so on a machine where the toolchain was installed after

// that change they simply are not there, and the compatibility path that

// depends on them answers nothing. That is not hypothetical: it is what

// turned CI red while every existing developer machine, which still has

// the files from before, stayed green.

//

// PT_INTERP is produced by the patchelf walk, which still runs on every

// install, and it names the glibc payload this toolchain was aligned to --

// the same fact the specs held, from a mechanism that has not gone away.

if (auto r = from_text(read_elf_interp(compilerBin)); still_there(r))

return r;

// Last: the installed payload set, but ONLY when it is a singleton.

//

// This is not the rule this design removed. That rule asked a directory

// for "the glibc" and took whatever `readdir` yielded first -- a CHOICE,

// made by something with no bearing on what the artifact would load, and

// silently wrong the moment a second payload appeared. Where exactly one

// payload is installed there is no choice to make: it is the only glibc

// any artifact from this toolchain could bind, and declining would refuse

// a question that has a single answer.

//

// Two or more and this stays silent. That is the case the incident was,

// and it is the case the subos must answer.

if (installed.size() == 1) {

mcpp::log::verbose("probe", std::format(

"runtime binding glibc@{} — the only glibc payload installed, so "

"there is nothing to choose between", installed[0]));

return "glibc@" + installed[0];

}

if (installed.size() > 1)

mcpp::log::verbose("probe", std::format(

"{} glibc payloads installed and nothing still present declares "

"which one this build binds; declining rather than picking",

installed.size()));

return {};

const std::filesystem::path& compilerBin,

const std::filesystem::path& outputDir)

{

if (compilerBin.empty() || outputDir.empty()) return {};

std::error_code ec;

auto out = outputDir / "mcpp-clean-link.specs";

// Idempotent: the pristine spec is a property of the compiler binary, so

// regenerating it every build would spawn a process for a constant.

if (std::filesystem::exists(out, ec)) return out;

auto r = mcpp::platform::process::capture(std::format(

"{} -dumpspecs 2>/dev/null",

mcpp::platform::shell::quote(compilerBin.string())));

if (r.exit_code != 0 || r.output.empty()) return {};

// `*link:` is a section header on its own line; its body is the next line.

constexpr std::string_view kHead = "*link:\n";

auto pos = r.output.find(kHead);

if (pos == std::string::npos) return {};

auto bodyStart = pos + kHead.size();

auto bodyEnd = r.output.find('\n', bodyStart);

if (bodyEnd == std::string::npos) return {};

auto body = r.output.substr(bodyStart, bodyEnd - bodyStart);

if (body.empty()) return {};

std::filesystem::create_directories(outputDir, ec);

std::ofstream os(out);

if (!os) return {};

os << "*link:\n" << body << "\n\n";

os.close();

return out;