Jorijn van der Graaf
27697d06aa
A .cpp unit's depfile listed its source and headers, never the BMIs it imports: clang's driver adds -module-file-deps to --precompile only. A std module rebuilt in its directory, which happens whenever its source changes under one compiler and one set of flags (a libc++ update, or mingw-w64's under the same prefix), left every object that imports it as it was, and the next build only relinked them. Implementation units are now compiled with -fmodule-file-deps, so the std PCM and the project's own PCMs are prerequisites of their objects like headers. Depfiles written before this lack the edge, so a std module that moves directories still needs VariantId to move with it (StdPcmKey). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
67 lines
3 KiB
C++
67 lines
3 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
module Crafter.Build:Implementation_impl;
|
|
import std;
|
|
import :Implementation;
|
|
import :Interface;
|
|
import :Platform;
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace Crafter {
|
|
Implementation::Implementation(fs::path&& path) : path(std::move(path)) {
|
|
|
|
}
|
|
bool Implementation::Check(const fs::path& buildDir, const fs::path& pcmDir, fs::file_time_type sourceFloor) const {
|
|
std::string objPath = std::format("{}_impl.o", (buildDir/path.filename()).string());
|
|
std::string cppPath = std::format("{}.cpp", path.string());
|
|
// The depfile clang wrote beside the object lists the headers this TU
|
|
// included; nothing else in the configuration knows about them, since
|
|
// the source scanner only reads `import` lines.
|
|
if(!fs::exists(objPath) || std::max({fs::last_write_time(cppPath), sourceFloor, NewestPrerequisite(std::format("{}.d", objPath))}) >= fs::last_write_time(objPath)) {
|
|
return true;
|
|
}
|
|
fs::file_time_type objTime = fs::last_write_time(objPath);
|
|
for(ModulePartition* dependency : partitionDependencies) {
|
|
if(dependency->Check(pcmDir, sourceFloor)) return true;
|
|
}
|
|
for(Module* dependency : moduleDependencies) {
|
|
if(dependency->Check(pcmDir, sourceFloor)) return true;
|
|
}
|
|
for(const auto& [externalMod, externalPcmPath] : externalModuleDependencies) {
|
|
std::error_code ec;
|
|
fs::file_time_type pcmTime = fs::last_write_time(externalPcmPath, ec);
|
|
if (!ec && pcmTime >= objTime) return true;
|
|
}
|
|
return false;
|
|
}
|
|
void Implementation::Compile(const std::string_view clang, const fs::path& buildDir, std::atomic<bool>& buildCancelled, std::string& buildError) const {
|
|
for(ModulePartition* dependency : partitionDependencies) {
|
|
if(!dependency->compiled.load()) {
|
|
dependency->compiled.wait(false);
|
|
}
|
|
}
|
|
for(Module* dependency : moduleDependencies) {
|
|
if(!dependency->compiled.load()) {
|
|
dependency->compiled.wait(false);
|
|
}
|
|
}
|
|
|
|
if (buildCancelled.load(std::memory_order_relaxed)) {
|
|
return;
|
|
}
|
|
|
|
// -MD leaves <name>_impl.o.d beside the object for Check to read, and
|
|
// -fmodule-file-deps puts the BMIs the unit imported in it with the
|
|
// headers. The driver adds that for --precompile only, so a std
|
|
// module rebuilt in place, for a mingw-w64 or libc++ update under
|
|
// the same compiler, left the objects importing it as they were, and
|
|
// the next build only relinked them.
|
|
std::string result = RunBuildCommand(std::format("{0} {1}.cpp -c -MD -MF {2}_impl.o.d -fmodule-file-deps -o {2}_impl.o", clang, path.string(), (buildDir/path.filename()).string()));
|
|
|
|
bool expected = false;
|
|
if(!result.empty() && buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::move(result);
|
|
}
|
|
}
|
|
}
|