module;

#include <cstdlib> // getenv

// mcpp.toolchain.stdmod — pre-build the `import std` BMI and cache it.

//

// GCC 15 flow (from docs/11-gcc15-cookbook.md §2):

// g++ -std=c++23 -fmodules -Og -c <std.cc> -o std.o

// ⇒ produces gcm.cache/std.gcm + std.o

//

// Clang/libc++ flow:

// clang++ -std=c++23 --precompile <std.cppm> -o pcm.cache/std.pcm

// clang++ -std=c++23 pcm.cache/std.pcm -c -o std.o

//

// We invoke the compiler in a dedicated cache directory so the produced

// BMI is owned by mcpp and reused across all builds with the same fingerprint.

//

// Output layout:

// <cache_root>/<fingerprint>/

// gcm.cache/std.gcm ← GCC BMI

// pcm.cache/std.pcm ← Clang BMI

// std.o ← linked into final binaries

export module mcpp.toolchain.stdmod;

import std;

import mcpp.libs.json;

import mcpp.platform;

import mcpp.toolchain.clang;

import mcpp.toolchain.detect;

import mcpp.toolchain.fingerprint;

import mcpp.toolchain.gcc;

export namespace mcpp::toolchain {

struct StdModule {

std::filesystem::path cacheDir; // <cache_root>/<fp>/

std::filesystem::path bmiPath; // <cacheDir>/gcm.cache/std.gcm

std::filesystem::path objectPath; // <cacheDir>/std.o

std::filesystem::path compatBmiPath; // <cacheDir>/pcm.cache/std.compat.pcm

std::filesystem::path compatObjectPath; // <cacheDir>/std.compat.o

};

struct StdModError { std::string message; };

std::filesystem::path default_cache_root();

// Build std module if not already cached. Returns paths to BMI + object.

// `macos_deployment_target` is the RESOLVED value from

// platform::macos::deployment_target() — it must match what flags.cppm

// emits for normal TUs, or the produced std.pcm targets a different

// arm64-apple-macosxNN triple than the code importing it.

std::expected<StdModule, StdModError> ensure_built(

const Toolchain& tc,

std::string_view fingerprint_hex,

std::string_view cpp_standard,

std::string_view cpp_standard_flag,

std::string_view macos_deployment_target = {},

const std::filesystem::path& cache_root = default_cache_root());

} // namespace mcpp::toolchain

namespace mcpp::toolchain {

namespace {

std::expected<std::string, StdModError> run_capture_command(const std::string& cmd) {

auto r = mcpp::platform::process::capture(cmd);

if (r.exit_code != 0) {

// Include the command: its --sysroot/-isystem flags are the first

// thing needed to diagnose header-resolution failures.

return std::unexpected(StdModError{

std::format("std module precompile failed (rc={}):\n{}\ncommand: {}",

r.exit_code, r.output, cmd)});

}

return r.output;

}

std::filesystem::path metadata_path(const std::filesystem::path& cacheDir) {

return cacheDir / "std-module.json";

}

nlohmann::json metadata_for(const Toolchain& tc,

std::string_view cppStandard,

std::string_view cppStandardFlag,

const std::vector<std::string>& stdCommands,

const std::vector<std::string>& compatCommands) {

nlohmann::json j;

j["schema"] = 1;

j["compiler"] = std::string(tc.compiler_name());

j["compiler_version"] = tc.version;

j["driver_identity"] = tc.driverIdent.empty()

? (tc.binaryPath.empty() ? "" : hash_file(tc.binaryPath))

: hash_string(tc.driverIdent);

j["target_triple"] = tc.targetTriple;

j["stdlib"] = tc.stdlibId;

j["stdlib_version"] = tc.stdlibVersion;

j["cpp_standard"] = std::string(cppStandard);

j["std_flag"] = std::string(cppStandardFlag);

j["std_module_source"] = tc.stdModuleSource.generic_string();

j["std_module_source_hash"] = hash_file(tc.stdModuleSource);

j["std_compat_source"] = tc.stdCompatSource.generic_string();

j["std_compat_source_hash"] = tc.stdCompatSource.empty() ? "" : hash_file(tc.stdCompatSource);

j["std_build_commands"] = stdCommands;

j["std_compat_build_commands"] = compatCommands;

return j;

}

bool metadata_matches(const std::filesystem::path& path, const nlohmann::json& expected) {

std::ifstream is(path);

if (!is) return false;

nlohmann::json actual;

try {

is >> actual;

} catch (...) {

return false;

}

static constexpr std::array<std::string_view, 14> keys = {

"schema",

"compiler",

"compiler_version",

"driver_identity",

"target_triple",

"stdlib",

"stdlib_version",

"cpp_standard",

"std_flag",

"std_module_source",

"std_module_source_hash",

"std_compat_source",

"std_compat_source_hash",

"std_build_commands",

};

for (auto key : keys) {

auto k = std::string(key);

if (!actual.contains(k) || actual[k] != expected[k]) return false;

}

return actual.value("std_compat_build_commands", nlohmann::json::array())

== expected["std_compat_build_commands"];

}

std::expected<void, StdModError> write_metadata(const std::filesystem::path& path,

const nlohmann::json& metadata) {

std::ofstream os(path, std::ios::binary);

if (!os) {

return std::unexpected(StdModError{

std::format("cannot write std module metadata '{}'", path.string())});

}

os << metadata.dump(2) << "\n";

if (!os) {

return std::unexpected(StdModError{

std::format("failed while writing std module metadata '{}'", path.string())});

}

return {};

}

std::expected<std::string, StdModError> run_commands(const std::vector<std::string>& commands) {

std::string out;

for (auto const& cmd : commands) {

if (auto r = run_capture_command(cmd); !r) return std::unexpected(r.error());

else out += *r;

}

return out;

}

} // namespace

std::filesystem::path default_cache_root() {

if (auto* e = std::getenv("MCPP_HOME"); e && *e) {

return std::filesystem::path(e) / "bmi";

}

if (auto* e = std::getenv("HOME"); e && *e) {

return std::filesystem::path(e) / ".mcpp" / "bmi";

}

return std::filesystem::current_path() / ".mcpp-bmi";

}

std::expected<StdModule, StdModError> ensure_built(

const Toolchain& tc,

std::string_view fingerprint_hex,

std::string_view cpp_standard,

std::string_view cpp_standard_flag,

std::string_view macos_deployment_target,

const std::filesystem::path& cache_root)

{

if (tc.stdModuleSource.empty()) {

return std::unexpected(StdModError{

"toolchain has no std module source (import std unsupported on this compiler)"});

}

StdModule sm;

sm.cacheDir = cache_root / std::string(fingerprint_hex);

sm.bmiPath = is_clang(tc)

? mcpp::toolchain::clang::std_bmi_path(sm.cacheDir)

: mcpp::toolchain::gcc::std_bmi_path(sm.cacheDir);

sm.objectPath = sm.cacheDir / "std.o";

// Build sysroot + include flags for std module precompilation.

//

// Payload-first: use fine-grained -isystem paths from xpkgs payloads

// when available, falling back to --sysroot.

//

// For Clang with a cfg file: use --no-default-config to bypass

// potentially-stale paths, then provide all flags explicitly.

// Std module precompilation only needs compile flags (no linker flags),

// so --no-default-config is safe here on all platforms.

std::string sysroot_flag;

if (is_clang(tc)) {

auto cfgPath = tc.binaryPath.parent_path()

/ (tc.binaryPath.stem().string() + ".cfg");

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

auto llvmRoot = tc.binaryPath.parent_path().parent_path();

auto libcxxInclude = llvmRoot / "include" / "c++" / "v1";

sysroot_flag = " --no-default-config -nostdinc++ -stdlib=libc++";

sysroot_flag += std::format(" -isystem'{}'", libcxxInclude.string());

if (!tc.targetTriple.empty()) {

auto targetInclude = llvmRoot / "include"

/ tc.targetTriple / "c++" / "v1";

if (std::filesystem::exists(targetInclude))

sysroot_flag += std::format(" -isystem'{}'", targetInclude.string());

}

// C library + kernel headers from payload paths.

if (tc.payloadPaths) {

sysroot_flag += std::format(" -isystem'{}'", tc.payloadPaths->glibcInclude.string());

if (!tc.payloadPaths->linuxInclude.empty())

sysroot_flag += std::format(" -isystem'{}'", tc.payloadPaths->linuxInclude.string());

} else if (auto sdk = mcpp::platform::macos::sdk_path()) {

sysroot_flag += std::format(" --sysroot='{}'", sdk->string());

} else if (!tc.sysroot.empty()) {

sysroot_flag += std::format(" --sysroot='{}'", tc.sysroot.string());

}

} else if (!tc.sysroot.empty()) {

sysroot_flag = std::format(" --sysroot='{}'", tc.sysroot.string());

}

} else if (!tc.sysroot.empty()) {

// GCC: use --sysroot (required for include-fixed headers).

// Supplement with -isystem for linux kernel headers from payload

// if the probed sysroot is missing them.

sysroot_flag = std::format(" --sysroot='{}'", tc.sysroot.string());

if (tc.payloadPaths && !tc.payloadPaths->linuxInclude.empty()) {

auto sysrootLinux = tc.sysroot / "usr" / "include" / "linux" / "limits.h";

if (!std::filesystem::exists(sysrootLinux))

sysroot_flag += std::format(" -isystem'{}'", tc.payloadPaths->linuxInclude.string());

}

} else if (tc.payloadPaths) {

// No usable sysroot: wire the C library headers from the payload.

// GCC's libstdc++ wraps libc headers via #include_next, which only

// searches directories AFTER the one the current header came from —

// and gcc's built-in dirs are LAST in the search order, so an

// -isystem payload dir (inserted before the built-ins) is unreachable

// from #include_next. -idirafter appends the payload to the very end,

// exactly where #include_next looks.

const bool clang = is_clang(tc);

auto add_inc = [&](const std::filesystem::path& p) {

if (clang) sysroot_flag += std::format(" -isystem'{}'", p.string());

else sysroot_flag += std::format(" -idirafter'{}'", p.string());

};

add_inc(tc.payloadPaths->glibcInclude);

if (!tc.payloadPaths->linuxInclude.empty())

add_inc(tc.payloadPaths->linuxInclude);

}

// Deployment target must mirror what flags.cppm emits for normal TUs

// (single resolver: platform::macos::deployment_target).

if (!macos_deployment_target.empty()) {

sysroot_flag += std::format(" -mmacosx-version-min={}",

macos_deployment_target);

}

std::vector<std::string> stdCommands;

if (is_clang(tc)) {

stdCommands = mcpp::toolchain::clang::std_module_build_commands(

tc, sm.cacheDir, sm.bmiPath, sysroot_flag, cpp_standard_flag);

} else {

stdCommands.push_back(mcpp::toolchain::gcc::std_module_build_command(

tc, sm.cacheDir, sysroot_flag, cpp_standard_flag));

}

std::vector<std::string> compatCommands;

if (is_clang(tc) && !tc.stdCompatSource.empty()) {

auto compatBmi = mcpp::toolchain::clang::std_compat_bmi_path(sm.cacheDir);

compatCommands = mcpp::toolchain::clang::std_compat_build_commands(

tc, sm.cacheDir, compatBmi, sm.bmiPath, sysroot_flag, cpp_standard_flag);

}

auto metadata = metadata_for(tc, cpp_standard, cpp_standard_flag, stdCommands, compatCommands);

auto metaPath = metadata_path(sm.cacheDir);

bool std_cached = std::filesystem::exists(sm.bmiPath)

&& std::filesystem::exists(sm.objectPath)

&& metadata_matches(metaPath, metadata);

bool rebuiltStd = false;

if (!std_cached) {

std::error_code ec;

std::filesystem::create_directories(sm.bmiPath.parent_path(), ec);

if (ec) return std::unexpected(StdModError{

std::format("cannot create '{}': {}", sm.bmiPath.parent_path().string(), ec.message())});

auto out = run_commands(stdCommands);

if (!out) return std::unexpected(out.error());

if (!std::filesystem::exists(sm.bmiPath)) {

return std::unexpected(StdModError{

std::format("expected BMI at '{}' but it wasn't produced; output:\n{}",

sm.bmiPath.string(), *out)});

}

rebuiltStd = true;

}

// Build std.compat after std (std.compat depends on std, Clang only).

if (is_clang(tc) && !tc.stdCompatSource.empty()) {

auto compatBmi = mcpp::toolchain::clang::std_compat_bmi_path(sm.cacheDir);

if (rebuiltStd || !std::filesystem::exists(compatBmi)

|| !metadata_matches(metaPath, metadata)) {

if (auto out = run_commands(compatCommands); !out) {

return std::unexpected(out.error());

}

}

sm.compatBmiPath = compatBmi;

sm.compatObjectPath = sm.cacheDir / "std.compat.o";

}

if (auto r = write_metadata(metaPath, metadata); !r) {

return std::unexpected(r.error());

}

return sm;

}

} // namespace mcpp::toolchain