// Whether to bypass clang's bundled `<driver>.cfg`.

//

// Always — the main build and the std module. The cfg is an

// install-time-generated, non-reproducible artifact, so

// everything it would provide is spelled out explicitly.

// LinuxOnly — the build.mcpp host helper. On macOS/Windows it keeps

// TRUSTING the cfg, because the macOS link additionally

// needs the libc++abi/unwind handling that the main build's

// needs_explicit_libcxx path owns; duplicating that for a

// host compile produced undefined __cxa_* /

// __gxx_personality_v0 (build_program.cppm, pre-existing).

enum class CfgBypass { Always, LinuxOnly };

CfgBypass cfgBypass = CfgBypass::Always;

// binutils `-B` so the driver finds as/ld. A GCC/libstdc++ payload

// concern only: musl and MinGW-w64 bundle their own, and Clang/MSVC never

// take an external binutils. MinGW must NOT get the Linux binutils — its

// PE/SEH output is only assemblable by x86_64-w64-mingw32-as.

bool binutilsPrefix = false;

// `-L` (plus `-Wl,-rpath` where the format has one) for the toolchain's

// own runtime dirs, so the produced program can load private libs in

// tree. The main build routes these through depRuntimeLibraryDirs

// instead, so it leaves this off.

bool runtimeLibDirs = false;

// Emit `-stdlib=libc++` alongside the cfg bypass.

//

// ClangDriverModel deliberately leaves this to callers: flags.cppm's

// string feeds C compiles too, and a C command must not carry it. The std

// module build has no such constraint — it compiles exactly one C++ TU —

// and states the stdlib selection explicitly.

bool clangStdlibSelect = false;

// Resolved value from platform::macos::deployment_target(); empty = omit.

// Must agree across the std BMI and everything that imports it — clang

// rejects a module built for a different deployment target outright.

std::string macosDeploymentTarget;

const HostFlagOptions& opt,

const PathEscape& esc) {

std::vector<std::string> out;

// MSVC carries none of this on the command line: cl.exe and link.exe find

// headers and import libraries through INCLUDE / LIB, which detection

// synthesizes into tc.envOverrides. Emitting the GNU shapes below would

// produce a string of unknown options and then LNK1181.

if (tc.compiler == CompilerId::MSVC) return out;

const auto dm = resolve_clang_driver(tc);

const auto lm = resolve_link_model(tc);

const bool bypassCfg =

dm.hasCfg && (opt.cfgBypass == HostFlagOptions::CfgBypass::Always

|| mcpp::platform::is_linux);

// Trusting the cfg means contributing no include paths, stdlib selection

// or runtime choices — it already carries them. It does NOT mean

// contributing nothing: the deployment target still has to be stated (see

// below), which is why this suppresses the two blocks rather than

// returning early.

const bool trustCfg = !bypassCfg && dm.hasCfg;

if (bypassCfg) {

for (auto& t : dm.compile_tokens(esc, opt.clangStdlibSelect))

out.push_back(t);

}

// Unconditional on macOS, cfg or no cfg. clang refuses to load a module

// built for a different deployment target, and this result feeds every

// compile that touches one — the bundled mcpp module's precompile, its

// object step, and the build.mcpp compile. Skipping it on the trust-cfg

// path is exactly the mismatch e2e 181 catches: the std BMI is built for

// 14.0 while the TU importing it is not.

if (mcpp::platform::is_macos && !opt.macosDeploymentTarget.empty())

out.push_back("-mmacosx-version-min=" + opt.macosDeploymentTarget);

if (!trustCfg && (bypassCfg || lm.mode != CLibMode::None))

for (auto& t : lm.compile_tokens(esc)) out.push_back(t);

return out;

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

std::string_view p = usePrefix;

while (!p.empty() && p.front() == ' ') p.remove_prefix(1);

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

auto sp = p.find_last_of(' ');

if (sp == std::string_view::npos)

return { std::string(p) + bmi.string() };

return { std::string(p.substr(0, sp)),

std::string(p.substr(sp + 1)) + bmi.string() };

const HostFlagOptions& opt,

const PathEscape& esc) {

std::vector<std::string> out;

if (tc.compiler == CompilerId::MSVC) return out;

const auto dm = resolve_clang_driver(tc);

const auto lm = resolve_link_model(tc);

const bool bypassCfg =

dm.hasCfg && (opt.cfgBypass == HostFlagOptions::CfgBypass::Always

|| mcpp::platform::is_linux);

if (bypassCfg) {

for (auto& t : dm.link_tokens(esc)) out.push_back(t);

} else if (dm.hasCfg) {

// Trusting the cfg — with ONE exception, and it is not a preference.

//

// The cfg picks runtimes; it does not pick a linker, so on macOS the

// default is Xcode's /usr/bin/ld. That binary is itself a C++ Mach-O

// linked against libc++, and it runs inside the same DYLD_* the

// payload toolchain sets up, so dyld resolves ITS libc++ to the

// payload's. When that copy lacks a symbol Apple's ld needs, ld

// aborts before it links anything:

//

// dyld: Symbol not found: __ZdaPv (operator delete[])

// Referenced from: .../XcodeDefault.xctoolchain/usr/bin/ld

// Expected in: .../xim-x-llvm/22.1.8/lib/libc++.1.0.dylib

//

// The MAIN build already refuses to use Xcode's ld for exactly this,

// and says so at flags.cppm's macOS branch: "Xcode 15.4's ld aborting

// at launch on macos-14 CI when its libc++ resolution was diverted".

// The host helper links in the same environment, so it cannot be

// allowed to differ — a toolchain that builds the project but not its

// build.mcpp is not a working toolchain (mcpp#437).

//

// lld ships with the very toolchain doing the compile, so it cannot

// be diverted to a libc++ it was not built against.

if constexpr (mcpp::platform::is_macos) out.push_back("-fuse-ld=lld");

return out;

}

for (auto& t : lm.link_tokens(esc)) out.push_back(t);

if (opt.binutilsPrefix) {

if (auto ar = archive_tool(tc); !ar.empty())

out.push_back("-B" + esc(ar.parent_path()));

}

if (opt.runtimeLibDirs) {

// -L is link-time and wanted everywhere; rpath is an ELF-only concept.

// A PE target reaches here too, where the flag is inert and

// self-containment comes from the static link instead (#299).

for (auto& d : tc.linkRuntimeDirs) {

out.push_back("-L" + esc(d));

if constexpr (mcpp::platform::supports_rpath)

out.push_back("-Wl,-rpath," + esc(d));

}

}

return out;