362 lines
16 KiB
C++
362 lines
16 KiB
C++
|
/*
|
||
|
|
Crafter® Build
|
||
|
|
Copyright (C) 2026 Catcrafts®
|
||
|
|
Catcrafts.net
|
||
|
|
|
||
|
|
This library is free software; you can redistribute it and/or
|
||
|
|
modify it under the terms of the GNU Lesser General Public
|
||
|
|
License version 3.0 as published by the Free Software Foundation;
|
||
|
|
|
||
|
|
This library is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
|
Lesser General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU Lesser General Public
|
||
|
|
License along with this library; if not, write to the Free Software
|
||
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||
|
|
*/
|
||
|
|
|
||
|
|
export module Crafter.Build:Clang_impl;
|
||
|
|
import std;
|
||
|
|
import :Clang;
|
||
|
|
namespace fs = std::filesystem;
|
||
|
|
|
||
|
|
BuildResult Build(const Configuration& config, std::unordered_set<fs::path>& depSet, std::mutex& depMutex) {
|
||
|
|
fs::path pwd = std::filesystem::path cwd = std::filesystem::current_path();
|
||
|
|
fs::path buildDir = pwd/"build";
|
||
|
|
fs::path outputDir = pwd/"bin";
|
||
|
|
|
||
|
|
if (!fs::exists(buildDir)) {
|
||
|
|
fs::create_directories(buildDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fs::exists(outputDir)) {
|
||
|
|
fs::create_directories(outputDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::vector<std::thread> threads;
|
||
|
|
threads.reserve(config.shaders.size() + 1 + config.interfaces.size() + config.implementations.size());
|
||
|
|
|
||
|
|
std::string buildError;
|
||
|
|
std::atomic<bool> buildCancelled{false};
|
||
|
|
for (const Shader& shader : config.shaders) {
|
||
|
|
if (shader.Check(outputDir)) continue;
|
||
|
|
threads.emplace_back([&shader, &outputDir, &buildError, &buildCancelled]() {
|
||
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
||
|
|
|
||
|
|
std::string result = shader.Compile(outputDir);
|
||
|
|
if (result.empty()) return;
|
||
|
|
|
||
|
|
bool expected = false;
|
||
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
||
|
|
buildError = std::move(result);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
threads.emplace_back([&config, &outputDir, &buildCancelled, &buildError]() {
|
||
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
||
|
|
try {
|
||
|
|
for (const fs::path& additionalFile : config.files) {
|
||
|
|
fs::path destination = outputDir / additionalFile.filename();
|
||
|
|
|
||
|
|
if (fs::is_directory(additionalFile)) {
|
||
|
|
for (const auto& entry : fs::recursive_directory_iterator(additionalFile)) {
|
||
|
|
|
||
|
|
const fs::path& sourcePath = entry.path();
|
||
|
|
|
||
|
|
// Compute relative path inside the directory
|
||
|
|
fs::path relativePath = fs::relative(sourcePath, additionalFile);
|
||
|
|
fs::path destPath = destination / relativePath;
|
||
|
|
|
||
|
|
if (entry.is_directory()) {
|
||
|
|
// Ensure directory exists in destination
|
||
|
|
if (!fs::exists(destPath)) {
|
||
|
|
fs::create_directories(destPath);
|
||
|
|
}
|
||
|
|
} else if (entry.is_regular_file()) {
|
||
|
|
// Ensure parent directory exists
|
||
|
|
fs::create_directories(destPath.parent_path());
|
||
|
|
|
||
|
|
if (!fs::exists(destPath)) {
|
||
|
|
fs::copy_file(sourcePath, destPath);
|
||
|
|
}
|
||
|
|
else if (fs::last_write_time(sourcePath) > fs::last_write_time(destPath)) {
|
||
|
|
fs::copy_file(sourcePath, destPath, fs::copy_options::overwrite_existing);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
// Handle regular file
|
||
|
|
if (!fs::exists(destination)) {
|
||
|
|
fs::copy_file(additionalFile, destination);
|
||
|
|
}
|
||
|
|
else if (fs::last_write_time(additionalFile) > fs::last_write_time(destination)) {
|
||
|
|
fs::copy_file(additionalFile, destination, fs::copy_options::overwrite_existing);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch(std::exception& e) {
|
||
|
|
bool expected = false;
|
||
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
||
|
|
buildError = e.what();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
fs::path stdPcmDir = GetCacheDir()/config.target/"-"/config.march;
|
||
|
|
|
||
|
|
if (!fs::exists(stdPcmDir)) {
|
||
|
|
fs::create_directories(stdPcmDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string stdPcmResult = BuildStdPcm(config, stdPcmDir/"std.pcm");
|
||
|
|
if(!stdPcmResult.empty()) {
|
||
|
|
return {result, false, {}};
|
||
|
|
}
|
||
|
|
|
||
|
|
fs::path pcmDir;
|
||
|
|
|
||
|
|
if(config.type != ConfigurationType::Executable) {
|
||
|
|
pcmDir = outputDir;
|
||
|
|
} else {
|
||
|
|
pcmDir = buildDir;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string command = std::format("{} --target={} -march={} -mtune={} -std=c++26 -D CRAFTER_BUILD_CONFIGURATION_TARGET=\\\"{}\\\" -D CRAFTER_BUILD_CONFIGURATION_TARGET_{} -fprebuilt-module-path={} -fprebuilt-module-path={}", GetBaseCommand(), config.target, config.march, config.mtune, editedTarget, editedTarget, stdPcm.parent_path().string(), stdPcmDir);
|
||
|
|
|
||
|
|
if(config.type == CRAFTER_CONFIGURATION_TYPE_SHARED_LIBRARY) {
|
||
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
||
|
|
command += " -fPIC -D CRAFTER_BUILD_CONFIGURATION_TYPE_SHARED_LIBRARY";
|
||
|
|
#endif
|
||
|
|
#if defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_windows_msvc) || defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_w64_mingw32)
|
||
|
|
command += " -D CRAFTER_BUILD_CONFIGURATION_TYPE_SHARED_LIBRARY";
|
||
|
|
#endif
|
||
|
|
} else if(config.type == CRAFTER_CONFIGURATION_TYPE_LIBRARY) {
|
||
|
|
command += " -D CRAFTER_BUILD_CONFIGURATION_TYPE_LIBRARY";
|
||
|
|
} else {
|
||
|
|
command += " -D CRAFTER_BUILD_CONFIGURATION_TYPE_EXECUTABLE";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string files;
|
||
|
|
std::unordered_set<std::string> libSet;
|
||
|
|
std::mutex fileMutex;
|
||
|
|
std::vector<std::thread> depThreads;
|
||
|
|
depThreads.reserve(config.dependencies);
|
||
|
|
std::atomic<bool> repack(false);
|
||
|
|
|
||
|
|
for(const Dependency& dep : config.dependencies) {
|
||
|
|
for (const auto& entry : fs::recursive_directory_iterator(dep.path)) {
|
||
|
|
if (entry.is_directory() && entry.path().filename() == "include") {
|
||
|
|
command += " -I" + entry.path().string();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
command += std::format(" -I{} -fprebuilt-module-path={}", dep.path.string(), (dep.path/"bin"/(config.target+config.march)).string());
|
||
|
|
|
||
|
|
depThreads.emplace_back([&](){
|
||
|
|
if (!buildCancelled.load(std::memory_order_relaxed)) {
|
||
|
|
depMutex.lock();
|
||
|
|
if(!depSet.contains(dep.path)) {
|
||
|
|
depSet.insert(dep.path);
|
||
|
|
depMutex.unlock();
|
||
|
|
BuildResult result = Build(dep.path, depSet, depMutex);
|
||
|
|
fileMutex.lock();
|
||
|
|
libSet.merge(result.libs);
|
||
|
|
fileMutex.unlock();
|
||
|
|
if (buildCancelled.compare_exchange_strong(false, true)) {
|
||
|
|
buildError = std::move(result.result);
|
||
|
|
}
|
||
|
|
if(result.repack) {
|
||
|
|
repack = true;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
depMutex.unlock();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
for(const Define& define : config.defines) {
|
||
|
|
if(define.value.empty()) {
|
||
|
|
command += std::format(" -D {}", define.name);
|
||
|
|
} else {
|
||
|
|
command += std::format(" -D {}={}", define.name, define.value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string cmakeBuildType;
|
||
|
|
|
||
|
|
if(config.debug) {
|
||
|
|
cmakeBuildType = "Debug";
|
||
|
|
command += " -g -D CRAFTER_BUILD_CONFIGURATION_DEBUG";
|
||
|
|
} else {
|
||
|
|
cmakeBuildType = "Release";
|
||
|
|
command += " -O3";
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const fs::path& cFile : config.c_files) {
|
||
|
|
files += std::format(" {}_source.o ", (buildDir / cFile.filename()).string());
|
||
|
|
const std::string objPath = (buildDir / cFile.filename()).string() + "_source.o";
|
||
|
|
const std::string srcPath = cFile.string() + ".c";
|
||
|
|
if (!fs::exists(objPath) || fs::last_write_time(srcPath) > fs::last_write_time(objPath)) {
|
||
|
|
threads.emplace_back([&cFile, &buildDir, &buildError, &buildCancelled]() {
|
||
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
||
|
|
|
||
|
|
std::string result = RunCommand(std::format("clang {}.c --target={} -march={} -mtune={} -O3 -c -o {}_source.o", cFile.string(), config.target, config.march, config.mtune, (buildDir / cFile.filename()).string()));
|
||
|
|
if (result.empty()) return;
|
||
|
|
|
||
|
|
bool expected = false;
|
||
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
||
|
|
buildError = std::move(result);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const fs::path& cFile : config.cuda) {
|
||
|
|
files += std::format(" {}_source.o ", (buildDir / cFile.filename()).string());
|
||
|
|
const std::string objPath = (buildDir / cFile.filename()).string() + "_source.o";
|
||
|
|
const std::string srcPath = cFile.string() + ".cu";
|
||
|
|
if (!fs::exists(objPath) || fs::last_write_time(srcPath) > fs::last_write_time(objPath)) {
|
||
|
|
threads.emplace_back([&cFile, &buildDir, &buildError, &buildCancelled]() {
|
||
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
||
|
|
|
||
|
|
std::string result = RunCommand(std::format("nvcc {}.cu -c -o {}_source.o -O3 -arch=sm_89", cFile.string(), (buildDir / cFile.filename()).string()));
|
||
|
|
if (result.empty()) return;
|
||
|
|
|
||
|
|
bool expected = false;
|
||
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
||
|
|
buildError = std::move(result);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for(std::thread& thread : depThreads) {
|
||
|
|
thread.join();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(buildCancelled.load()) {
|
||
|
|
return {buildError, false, {}};
|
||
|
|
}
|
||
|
|
|
||
|
|
std::vector<std::unique_ptr<Module>> interfaces;
|
||
|
|
std::vector<std::tuple<fs::path, std::string, ModulePartition*, Module*>> tempModulePaths = std::vector<std::tuple<fs::path, std::string, ModulePartition*, Module*>>(config.interfaces.size());
|
||
|
|
for(std::uint16_t i = 0; i < config.interfaces.size(); i++){
|
||
|
|
const std::filesystem::path file = workingDir / (config.interfaces[i]+".cppm");
|
||
|
|
std::ifstream t(file);
|
||
|
|
std::stringstream buffer;
|
||
|
|
buffer << t.rdbuf();
|
||
|
|
std::string fileContent = buffer.str();
|
||
|
|
fileContent = std::regex_replace(fileContent, std::regex(R"(//[^\n]*)"), "");
|
||
|
|
fileContent = std::regex_replace(fileContent, std::regex(R"(/\*.*?\*/)"), "");
|
||
|
|
tempModulePaths[i] = {file, fileContent, nullptr, nullptr};
|
||
|
|
}
|
||
|
|
|
||
|
|
std::erase_if(tempModulePaths, [this](std::tuple<fs::path, std::string, ModulePartition*, Module*>& file) {
|
||
|
|
std::smatch match;
|
||
|
|
if (std::regex_search(std::get<1>(file), match, std::regex(R"(export module ([a-zA-Z0-9_\.\-]+);)"))) {
|
||
|
|
std::get<0>(file).replace_extension("");
|
||
|
|
interfaces.push_back(std::make_unique<Module>(std::move(match[1].str()), std::move(std::get<0>(file))));
|
||
|
|
return true;
|
||
|
|
} else {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
for(std::uint16_t i = 0; i < tempModulePaths.size(); i++) {
|
||
|
|
std::smatch match;
|
||
|
|
if (std::regex_search(std::get<1>(tempModulePaths[i]), match, std::regex(R"(export module ([a-zA-Z_0-9\.\-]+):([a-zA-Z_0-9\.\-]+);)"))) {
|
||
|
|
for(const std::unique_ptr<Module>& modulee : interfaces) {
|
||
|
|
if(modulee->name == match[1]) {
|
||
|
|
std::string name = match[2].str();
|
||
|
|
fs::path pthCpy = std::get<0>(tempModulePaths[i]);
|
||
|
|
pthCpy.replace_extension("");
|
||
|
|
std::unique_ptr<ModulePartition> partition = std::make_unique<ModulePartition>(std::move(name), std::move(pthCpy));
|
||
|
|
std::get<2>(tempModulePaths[i]) = partition.get();
|
||
|
|
modulee->partitions.push_back(std::move(partition));
|
||
|
|
std::get<3>(tempModulePaths[i]) = modulee.get();
|
||
|
|
goto next;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw std::runtime_error(std::format("Module {} not found, referenced in {}", match[1].str(), std::get<0>(tempModulePaths[i]).string()));
|
||
|
|
} else {
|
||
|
|
throw std::runtime_error(std::format("No module declaration found in {}", std::get<0>(tempModulePaths[i]).string()));
|
||
|
|
}
|
||
|
|
next:;
|
||
|
|
}
|
||
|
|
|
||
|
|
for(std::tuple<fs::path, std::string, ModulePartition*, Module*>& file : tempModulePaths) {
|
||
|
|
std::regex pattern(R"(import :([a-zA-Z_\-0-9\.]+);)");
|
||
|
|
std::sregex_iterator currentMatch(std::get<1>(file).begin(), std::get<1>(file).end(), pattern);
|
||
|
|
std::sregex_iterator lastMatch;
|
||
|
|
|
||
|
|
while (currentMatch != lastMatch) {
|
||
|
|
std::smatch match = *currentMatch;
|
||
|
|
for(std::unique_ptr<ModulePartition>& partition2 : std::get<3>(file)->partitions) {
|
||
|
|
if(partition2->name == match[1]) {
|
||
|
|
std::get<2>(file)->partitionDependencies.push_back(partition2.get());
|
||
|
|
goto next2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw std::runtime_error(std::format("imported partition {}:{} not found, referenced in {}", std::get<3>(file)->name, match[1].str(), std::get<0>(file).string()));
|
||
|
|
next2: ++currentMatch;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for(Module& interface : interfaces) {
|
||
|
|
if(config.interfaces[i]->Check(pcmDir)) {
|
||
|
|
threads.emplace_back(&Module::Compile, interface, command, pcmDir, buildDir, buildCancelled, buildError);
|
||
|
|
buildResult.repack = true;
|
||
|
|
}
|
||
|
|
files += std::format(" {}/{}.o", buildDir.string(), interface.path.filename().string());
|
||
|
|
for(std::unique_ptr<ModulePartition>& part : interface.partitions) {
|
||
|
|
files += std::format(" {}/{}.o", buildDir.string(), part->path.filename().string());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for(Implementation& interface : implementations) {
|
||
|
|
if(config.implementations[i].Check(buildDir, pcmDir)) {
|
||
|
|
buildResult.repack = true;
|
||
|
|
threads.emplace_back(&Implementation::Compile, &config.implementations[i], command, buildDir, buildCancelled, buildError);
|
||
|
|
}
|
||
|
|
files += std::format(" {}/{}_impl.o", buildDir.string(), config.implementations[i].path.filename().string());
|
||
|
|
}
|
||
|
|
|
||
|
|
for(std::thread& thread : threads) {
|
||
|
|
thread.join();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(buildCancelled.load()) {
|
||
|
|
return {buildError, false, {}};
|
||
|
|
}
|
||
|
|
|
||
|
|
if(buildResult.repack) {
|
||
|
|
if(config.type == CRAFTER_CONFIGURATION_TYPE_EXECUTABLE) {
|
||
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
||
|
|
buildResult.result = RunCommand(std::format("{}{} -o {} -fuse-ld=lld ", command, files, (binDir/outputName).string()));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_windows_msvc) || defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_w64_mingw32)
|
||
|
|
system(std::format("copy \"%LIBCXX_DIR%\\lib\\c++.dll\" \"{}\\c++.dll\"", binDir.string()).c_str());
|
||
|
|
buildResult.result = RunCommand(std::format("{}{} -o {}.exe -fuse-ld=lld -L %LIBCXX_DIR%\\lib -lc++ -nostdinc++ -nostdlib++", command, files, (binDir/outputName).string()));
|
||
|
|
#endif
|
||
|
|
} else if(config.type == CRAFTER_CONFIGURATION_TYPE_LIBRARY) {
|
||
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
||
|
|
buildResult.result = RunCommand(std::format("ar r {}.a {}", (binDir/fs::path(std::string("lib")+outputName)).string(), files));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_windows_msvc) || defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_w64_mingw32)
|
||
|
|
buildResult.result = RunCommand(std::format("llvm-lib.exe {} /OUT:{}.lib", files, (binDir/fs::path(outputName)).string()));
|
||
|
|
#endif
|
||
|
|
} else {
|
||
|
|
buildResult.result = RunCommand(std::format("{}{} -shared -o {}.so -Wl,-rpath,'$ORIGIN' -fuse-ld=lld", command, files, (binDir/(std::string("lib")+outputName)).string()));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
return buildResult;
|
||
|
|
}
|