Jorijn van der Graaf
d22a8603df
Inside the Flatpak the bundled toolchain compiled every bootstrap object, then glslang's configure failed its test link with `unable to find library -lc++`. clang searches its per-target runtime directory (lib/<triple>) and the system library paths for libc++, not <prefix>/lib, so with the classic layout a toolchain outside /usr needs the search path spelled out, just as its loader needs the rpath. LibcxxLinkFlags and build.sh now emit both, the same pair an explicit CRAFTER_BUILD_LIBCXX_DIR already got. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
80 lines
3.9 KiB
C++
80 lines
3.9 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
export module Crafter.Build:Toolchain;
|
|
import std;
|
|
namespace fs = std::filesystem;
|
|
|
|
export namespace Crafter {
|
|
// The compiler crafter-build drives and what sits next to it, resolved
|
|
// once per process by GetToolchain(). Every clang++, clang and llvm-ar
|
|
// the tool spawns, the libclang the linter dlopens, the std module
|
|
// source and the default sysroots come from here, so a toolchain
|
|
// installed anywhere other than /usr (the Flatpak carries its own under
|
|
// /app) needs no per-call-site knowledge.
|
|
struct Toolchain {
|
|
// LLVM install prefix. Empty when the tools are bare names on PATH.
|
|
fs::path prefix;
|
|
fs::path clangxx;
|
|
fs::path clang;
|
|
fs::path llvmAr;
|
|
// Where clang-c/Index.h lives when it is not on the default include
|
|
// path; empty otherwise.
|
|
fs::path llvmIncludeDir;
|
|
// The exact libclang to dlopen; nullopt means search the usual names.
|
|
std::optional<fs::path> libclang;
|
|
// A libc++ install other than the compiler's own
|
|
// (CRAFTER_BUILD_LIBCXX_DIR); empty means clang finds its own.
|
|
fs::path libcxxDir;
|
|
// libc++'s std module source for host builds.
|
|
fs::path stdCppm;
|
|
fs::path wasiSysroot;
|
|
// Holds include/c++/<ver>/bits/std.cc for the mingw target. Passed to
|
|
// clang as --sysroot only when it was set explicitly: clang's own
|
|
// mingw discovery handles the distro layout, and a --sysroot pointing
|
|
// at the triple directory would lose crtbegin.o and libgcc.
|
|
fs::path mingwSysroot;
|
|
bool mingwSysrootExplicit = false;
|
|
// `clang++ -print-target-triple` and the first line of
|
|
// `clang++ --version`; both empty when clang++ could not be run.
|
|
std::string hostTriple;
|
|
std::string clangVersion;
|
|
// Why clang++ could not be resolved or run; empty when it could.
|
|
std::string error;
|
|
|
|
// Flags for compiling against libcxxDir; empty without one.
|
|
std::string LibcxxCompileFlags() const;
|
|
// Flags for linking against the libc++ the compiler will use: a -L
|
|
// and an rpath for <prefix>/lib when the prefix is not the system one
|
|
// (clang searches only its per-target runtime directory and the
|
|
// system paths, and a bundled toolchain's libc++.so.1 is on neither
|
|
// the linker's nor the loader's default path), or for an explicit
|
|
// libcxxDir.
|
|
std::string LibcxxLinkFlags() const;
|
|
// Names this toolchain for cache directory names: the clang version
|
|
// followed by a hash of what decides which headers and libraries a
|
|
// PCM is built against. Two toolchains with different keys never
|
|
// share a PCM.
|
|
std::string Key() const;
|
|
};
|
|
|
|
// What ResolveToolchain reads, so a test can feed it a staged layout.
|
|
struct ToolchainInputs {
|
|
// The CRAFTER_* variables, present only when set and non-empty.
|
|
std::map<std::string, std::string, std::less<>> env;
|
|
// The <prefix> of <prefix>/share/crafter-build; empty when unknown.
|
|
fs::path crafterPrefix;
|
|
};
|
|
// Pure path resolution: an env override wins, then a toolchain installed
|
|
// beside crafter-build (<crafterPrefix>/bin/clang++), then bare names on
|
|
// PATH. Never runs a process, so hostTriple and clangVersion stay empty.
|
|
Toolchain ResolveToolchain(const ToolchainInputs& inputs);
|
|
// ResolveToolchain over the real environment plus the two clang probes,
|
|
// computed once and cached. Never throws.
|
|
const Toolchain& GetToolchain();
|
|
// GetToolchain(), or a std::runtime_error carrying its error.
|
|
const Toolchain& RequireToolchain();
|
|
// The version baked in when crafter-build was built; "0.0.0-dev" for a
|
|
// build that was given none.
|
|
std::string_view CrafterBuildVersion();
|
|
}
|