Files
carbon-lang/toolchain/driver/clang_runner.cpp
T
Chandler CarruthandDavid Blaikie 77808cd5d7 Refactor Clang runtimes building into async builder (#6380)
Previously, the Clang runtimes building only considered building the
target resource directory, and was only _internally_ asynchronous.
Because the asynchrony was only internal, it could use the function
frame as a context object throughout the build of the resource dir. This
is simple but doesn't generalize well to more runtimes: if we want to
add 2 or 3 more runtimes, we want them to _all_ build asynchronously.
That means using some asynchronous builder that maintains the context
and allows them to proceed concurrently with other work.

This also factors all the runtimes building code into a separate set of
files. These aren't separate libraries at this point due to the
`ClangRunner` in some cases wanting to build runtimes on-demand, but it
at least lets us organize the code more cleanly.

Because this splits code between `clang_runner.*` and
`clang_runtimes.*`, it also works to update the `#include`s for both to
be roughly accurate. I used ClangD's include cleaner for this and it
probably also did some latent cleaning as it went, but that's the reason
for the churn of `#include` lines.

The archive building is also factored out into a re-usable helper. This
is a bit "over factored" in this PR, but supports the next PR that uses
the same code to build archives for other runtimes.

This also overhauls the synchronization used -- it uses a simple `Latch`
construct introduced in a previous PR to coordinate between the steps of
building the runtimes.

Last but not least, it factors the "enable leaking" state out of a
boolean in the runner to a parameter. This is important in the face of
concurrent calls as otherwise toggling this boolean can create a race.

The next PR will layer building more runtimes on top of this new
factoring.

---------

Co-authored-by: David Blaikie <dblaikie@gmail.com>
2025-11-18 06:08:14 +00:00

499 lines
21 KiB
C++

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "toolchain/driver/clang_runner.h"
#include <stdlib.h>
#include <unistd.h>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticDriver.h"
#include "clang/Basic/DiagnosticIDs.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/CodeGen/ObjectFilePCHContainerWriter.h"
#include "clang/Driver/Compilation.h"
#include "clang/Driver/Driver.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/TextDiagnosticBuffer.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Frontend/Utils.h"
#include "clang/FrontendTool/Utils.h"
#include "clang/Serialization/ObjectFilePCHContainerReader.h"
#include "clang/Serialization/PCHContainerOperations.h"
#include "common/check.h"
#include "common/error.h"
#include "common/vlog.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/BuryPointer.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/LLVMDriver.h"
#include "llvm/Support/ThreadPool.h"
#include "llvm/Support/TimeProfiler.h"
#include "llvm/Support/Timer.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Host.h"
#include "toolchain/driver/clang_runtimes.h"
#include "toolchain/driver/runtimes_cache.h"
#include "toolchain/driver/tool_runner_base.h"
#include "toolchain/install/install_paths.h"
// Defined in:
// https://github.com/llvm/llvm-project/blob/main/clang/tools/driver/driver.cpp
//
// While not in a header, this is the API used by llvm-driver.cpp for
// busyboxing.
//
// NOLINTNEXTLINE(readability-identifier-naming)
auto clang_main(int Argc, char** Argv, const llvm::ToolContext& ToolContext)
-> int;
namespace Carbon {
ClangRunner::ClangRunner(const InstallPaths* install_paths,
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
llvm::raw_ostream* vlog_stream)
: ToolRunnerBase(install_paths, vlog_stream), fs_(std::move(fs)) {}
// Searches an argument list to a Clang execution to determine the expected
// target string, suitable for use with `llvm::Triple`.
//
// If no explicit target flags are present, this defaults to the default
// LLVM target.
//
// Works to handle the most common flags that modify the expected target as
// well as direct target flags.
//
// Note: this has known fidelity issues if the args include separate-value flags
// (`--flag value` style as opposed to `--flag=value`) where the value might
// match the spelling of one of the target flags. For example, args that include
// an output file spelled `-m32` (so `-o` followed by `-m32`) will be
// misinterpreted by considering the value to itself be a flag. Addressing this
// would add substantial complexity, including likely parsing the entire args
// twice with the Clang driver. Instead, our current plan is to document this
// limitation and encourage the use of flags with joined values
// (`--flag=value`).
static auto ComputeClangTarget(llvm::ArrayRef<llvm::StringRef> args)
-> std::string {
std::string target = llvm::sys::getDefaultTargetTriple();
bool explicit_target = false;
for (auto [i, arg] : llvm::enumerate(args)) {
if (llvm::StringRef arg_copy = arg; arg_copy.consume_front("--target=")) {
target = arg_copy.str();
explicit_target = true;
} else if ((arg == "--target" || arg == "-target") &&
(i + 1) < args.size()) {
target = args[i + 1].str();
explicit_target = true;
} else if (!explicit_target &&
(arg == "--driver-mode=cl" ||
((arg == "--driver-mode" || arg == "-driver-mode") &&
(i + 1) < args.size() && args[i + 1] == "cl"))) {
// The `cl.exe` compatible driver mode should switch the default target to
// a `...-pc-windows-msvc` target. However, a subsequent explicit target
// should override this.
llvm::Triple triple(target);
triple.setVendor(llvm::Triple::PC);
triple.setOS(llvm::Triple::Win32);
triple.setEnvironment(llvm::Triple::MSVC);
target = triple.str();
} else if (arg == "-m32") {
llvm::Triple triple(target);
if (!triple.isArch32Bit()) {
target = triple.get32BitArchVariant().str();
}
} else if (arg == "-m64") {
llvm::Triple triple(target);
if (!triple.isArch64Bit()) {
target = triple.get64BitArchVariant().str();
}
}
}
return target;
}
// Tries to detect a a non-linking list of Clang arguments to avoid setting up
// the more complete resource directory needed for linking. False negatives are
// fine here, and we use that to keep things simple.
static auto IsNonLinkCommand(llvm::ArrayRef<llvm::StringRef> args) -> bool {
return llvm::any_of(args, [](llvm::StringRef arg) {
// Only check the most common cases as we have to do this for each argument.
// Everything else is rare and likely not worth the cost of searching for
// since it's fine to have false negatives.
return arg == "-c" || arg == "-E" || arg == "-S" ||
arg == "-fsyntax-only" || arg == "--version" || arg == "--help" ||
arg == "/?" || arg == "--driver-mode=cpp";
});
}
auto ClangRunner::RunWithPrebuiltRuntimes(llvm::ArrayRef<llvm::StringRef> args,
Runtimes& prebuilt_runtimes,
bool enable_leaking)
-> ErrorOr<bool> {
// Check the args to see if we have a known target-independent command. If so,
// directly dispatch it to avoid the cost of building the target resource
// directory.
// TODO: Maybe handle response file expansion similar to the Clang CLI?
if (args.empty() || args[0].starts_with("-cc1") || IsNonLinkCommand(args)) {
return RunWithNoRuntimes(args, enable_leaking);
}
std::string target = ComputeClangTarget(args);
CARBON_ASSIGN_OR_RETURN(std::filesystem::path prebuilt_resource_dir_path,
prebuilt_runtimes.Get(Runtimes::ClangResourceDir));
return RunInternal(args, target, prebuilt_resource_dir_path.native(),
enable_leaking);
}
auto ClangRunner::Run(llvm::ArrayRef<llvm::StringRef> args,
Runtimes::Cache& runtimes_cache,
llvm::ThreadPoolInterface& runtimes_build_thread_pool,
bool enable_leaking) -> ErrorOr<bool> {
// Check the args to see if we have a known target-independent command. If so,
// directly dispatch it to avoid the cost of building the target resource
// directory.
// TODO: Maybe handle response file expansion similar to the Clang CLI?
if (args.empty() || args[0].starts_with("-cc1") || IsNonLinkCommand(args)) {
return RunWithNoRuntimes(args, enable_leaking);
}
std::string target = ComputeClangTarget(args);
CARBON_VLOG("Building target resource dir...\n");
Runtimes::Cache::Features features = {.target = target};
CARBON_ASSIGN_OR_RETURN(Runtimes runtimes, runtimes_cache.Lookup(features));
// We need to build the Clang resource directory for these runtimes. This
// requires a temporary directory as well as the destination directory for
// the build. The temporary directory should only be used during the build,
// not once we are running Clang with the built runtime.
std::filesystem::path resource_dir_path;
{
ClangResourceDirBuilder builder(this, &runtimes_build_thread_pool,
llvm::Triple(features.target), &runtimes);
CARBON_ASSIGN_OR_RETURN(resource_dir_path, std::move(builder).Wait());
}
// Note that this function always successfully runs `clang` and returns a bool
// to indicate whether `clang` itself succeeded, not whether the runner was
// able to run it. As a consequence, even a `false` here is a non-`Error`
// return.
return RunInternal(args, target, resource_dir_path.native(), enable_leaking);
}
auto ClangRunner::RunWithNoRuntimes(llvm::ArrayRef<llvm::StringRef> args,
bool enable_leaking) -> bool {
std::string target = ComputeClangTarget(args);
return RunInternal(args, target, std::nullopt, enable_leaking);
}
auto ClangRunner::RunCC1(llvm::SmallVectorImpl<const char*>& cc1_args,
bool enable_leaking) -> int {
llvm::BumpPtrAllocator allocator;
llvm::cl::ExpansionContext expansion_context(
allocator, llvm::cl::TokenizeGNUCommandLine);
if (llvm::Error error = expansion_context.expandResponseFiles(cc1_args)) {
llvm::errs() << toString(std::move(error)) << '\n';
return 1;
}
CARBON_CHECK(cc1_args[1] == llvm::StringRef("-cc1"));
llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diag_ids =
clang::DiagnosticIDs::create();
// Register the support for object-file-wrapped Clang modules.
auto pch_ops = std::make_shared<clang::PCHContainerOperations>();
pch_ops->registerWriter(
std::make_unique<clang::ObjectFilePCHContainerWriter>());
pch_ops->registerReader(
std::make_unique<clang::ObjectFilePCHContainerReader>());
// Buffer diagnostics from argument parsing so that we can output them using a
// well formed diagnostic object.
clang::DiagnosticOptions diag_opts;
clang::TextDiagnosticBuffer diag_buffer;
clang::DiagnosticsEngine diags(diag_ids, diag_opts, &diag_buffer,
/*ShouldOwnClient=*/false);
// Setup round-trip remarks for the DiagnosticsEngine used in CreateFromArgs.
if (llvm::find(cc1_args, llvm::StringRef("-Rround-trip-cc1-args")) !=
cc1_args.end()) {
diags.setSeverity(clang::diag::remark_cc1_round_trip_generated,
clang::diag::Severity::Remark, {});
}
auto invocation = std::make_shared<clang::CompilerInvocation>();
bool success = clang::CompilerInvocation::CreateFromArgs(
*invocation, llvm::ArrayRef(cc1_args).slice(1), diags, cc1_args[0]);
// Heap allocate the compiler instance so that if we disable freeing we can
// discard the pointer without destroying or deallocating it.
auto clang_instance = std::make_unique<clang::CompilerInstance>(
std::move(invocation), std::move(pch_ops));
// Override the disabling of free when we don't want to leak memory.
if (!enable_leaking) {
clang_instance->getFrontendOpts().DisableFree = false;
clang_instance->getCodeGenOpts().DisableFree = false;
}
if (!clang_instance->getFrontendOpts().TimeTracePath.empty()) {
llvm::timeTraceProfilerInitialize(
clang_instance->getFrontendOpts().TimeTraceGranularity, cc1_args[0],
clang_instance->getFrontendOpts().TimeTraceVerbose);
}
// TODO: These options should take priority over the actual compilation.
// However, their implementation is currently not accessible from a library.
// We should factor the implementation into a reusable location and then use
// that here.
CARBON_CHECK(!clang_instance->getFrontendOpts().PrintSupportedCPUs &&
!clang_instance->getFrontendOpts().PrintSupportedExtensions &&
!clang_instance->getFrontendOpts().PrintEnabledExtensions);
// Infer the builtin include path if unspecified.
if (clang_instance->getHeaderSearchOpts().UseBuiltinIncludes &&
clang_instance->getHeaderSearchOpts().ResourceDir.empty()) {
clang_instance->getHeaderSearchOpts().ResourceDir =
installation_->clang_resource_path();
}
// Create the filesystem.
clang_instance->createVirtualFileSystem(fs_, &diag_buffer);
// Create the actual diagnostics engine.
clang_instance->createDiagnostics();
if (!clang_instance->hasDiagnostics()) {
return EXIT_FAILURE;
}
// Now flush the buffered diagnostics into the Clang instance's diagnostic
// engine. If we've already hit an error, we can exit early once that's done.
diag_buffer.FlushDiagnostics(clang_instance->getDiagnostics());
if (!success) {
clang_instance->getDiagnosticClient().finish();
return EXIT_FAILURE;
}
// Execute the frontend actions.
{
llvm::TimeTraceScope time_scope("ExecuteCompiler");
bool time_passes = clang_instance->getCodeGenOpts().TimePasses;
if (time_passes) {
clang_instance->createFrontendTimer();
}
llvm::TimeRegion timer(time_passes ? &clang_instance->getFrontendTimer()
: nullptr);
success = clang::ExecuteCompilerInvocation(clang_instance.get());
}
// If any timers were active but haven't been destroyed yet, print their
// results now. This happens in -disable-free mode.
std::unique_ptr<llvm::raw_ostream> io_file = llvm::CreateInfoOutputFile();
if (clang_instance->getCodeGenOpts().TimePassesJson) {
*io_file << "{\n";
llvm::TimerGroup::printAllJSONValues(*io_file, "");
*io_file << "\n}\n";
} else if (!clang_instance->getCodeGenOpts().TimePassesStatsFile) {
llvm::TimerGroup::printAll(*io_file);
}
llvm::TimerGroup::clearAll();
if (llvm::timeTraceProfilerEnabled()) {
// It is possible that the compiler instance doesn't own a file manager here
// if we're compiling a module unit, since the file manager is owned by the
// AST when we're compiling a module unit. So the file manager may be
// invalid here.
//
// It should be fine to create file manager here since the file system
// options are stored in the compiler invocation and we can recreate the VFS
// from the compiler invocation.
if (!clang_instance->hasFileManager()) {
clang_instance->createFileManager();
}
if (auto profiler_output = clang_instance->createOutputFile(
clang_instance->getFrontendOpts().TimeTracePath, /*Binary=*/false,
/*RemoveFileOnSignal=*/false,
/*useTemporary=*/false)) {
llvm::timeTraceProfilerWrite(*profiler_output);
profiler_output.reset();
llvm::timeTraceProfilerCleanup();
clang_instance->clearOutputFiles(false);
}
}
// When running with -disable-free, don't do any destruction or shutdown.
if (clang_instance->getFrontendOpts().DisableFree) {
llvm::BuryPointer(std::move(clang_instance));
}
return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
auto ClangRunner::RunInternal(
llvm::ArrayRef<llvm::StringRef> args, llvm::StringRef target,
std::optional<llvm::StringRef> target_resource_dir_path,
bool enable_leaking) -> bool {
std::string clang_path = installation_->clang_path();
// Rebuild the args as C-string args.
llvm::OwningArrayRef<char> cstr_arg_storage;
llvm::SmallVector<const char*, 64> cstr_args =
BuildCStrArgs("Clang", clang_path, "-v", args, cstr_arg_storage);
// Handle special dispatch for CC1 commands as they don't use the driver.
if (!args.empty() && args[0].starts_with("-cc1")) {
if (args[0] == "-cc1") {
CARBON_VLOG("Dispatching `-cc1` command line");
int exit_code = RunCC1(cstr_args, enable_leaking);
// TODO: Should this be forwarding the full exit code?
return exit_code == 0;
}
// Other CC1-based invocations need to dispatch into the `clang_main`
// routine to work correctly. This means they're not reliable in a library
// context but currently there is too much logic to reasonably extract here.
// This at least allows simple cases (often when directly used on the
// command line) to work correctly.
//
// TODO: Factor the relevant code paths into a library API or move this into
// the busybox dispatch logic.
CARBON_VLOG("Calling clang_main for a cc1-based invocation...");
// cstr_args[0] will be the `clang_path` so we don't need the prepend arg.
llvm::ToolContext tool_context = {
.Path = cstr_args[0], .PrependArg = "clang", .NeedsPrependArg = false};
int exit_code = clang_main(
cstr_args.size(), const_cast<char**>(cstr_args.data()), tool_context);
// TODO: Should this be forwarding the full exit code?
return exit_code == 0;
}
CARBON_VLOG("Preparing Clang driver...\n");
// Create the diagnostic options and parse arguments controlling them out of
// our arguments.
std::unique_ptr<clang::DiagnosticOptions> diagnostic_options =
clang::CreateAndPopulateDiagOpts(cstr_args);
// TODO: We don't yet support serializing diagnostics the way the actual
// `clang` command line does. Unclear if we need to or not, but it would need
// a bit more logic here to set up chained consumers.
clang::TextDiagnosticPrinter diagnostic_client(llvm::errs(),
*diagnostic_options);
// Note that the `DiagnosticsEngine` takes ownership (via a ref count) of the
// DiagnosticIDs, unlike the other parameters.
clang::DiagnosticsEngine diagnostics(clang::DiagnosticIDs::create(),
*diagnostic_options, &diagnostic_client,
/*ShouldOwnClient=*/false);
clang::ProcessWarningOptions(diagnostics, *diagnostic_options, *fs_);
// Note that we configure the driver's *default* target here, not the expected
// target as that will be parsed out of the command line below.
clang::driver::Driver driver(clang_path, llvm::sys::getDefaultTargetTriple(),
diagnostics, "clang LLVM compiler", fs_);
llvm::Triple target_triple(target);
// We need to set an SDK system root on macOS by default. Setting it here
// allows a custom sysroot to still be specified on the command line.
//
// TODO: A different system root should be used for iOS, watchOS, tvOS.
// Currently, we're only targeting macOS support though.
if (target_triple.isMacOSX()) {
// This is the default CLT system root, shown by `xcrun --show-sdk-path`.
// We hard code it here to avoid the overhead of subprocessing to `xcrun` on
// each Clang invocation, but this may need to be updated to search or
// reflect macOS versions if this changes in the future.
driver.SysRoot = "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk";
}
// If we have a target-specific resource directory, set it as the default
// here.
if (target_resource_dir_path) {
driver.ResourceDir = target_resource_dir_path->str();
}
// Configure the install directory to find other tools and data files.
//
// We directly override the detected directory as we use a synthetic path
// above. This makes it appear that our binary was in the installed binaries
// directory, and allows finding tools relative to it.
driver.Dir = installation_->llvm_install_bin();
CARBON_VLOG("Setting bin directory to: {0}\n", driver.Dir);
// When there's only one command being run, this will run it in-process.
// However, a `clang` invocation may cause multiple `cc1` invocations, which
// still subprocess. See `InProcess` comment at:
// https://github.com/llvm/llvm-project/blob/86ce8e4504c06ecc3cc42f002ad4eb05cac10925/clang/lib/Driver/Job.cpp#L411-L413
//
// Note the subprocessing will effectively call `clang -cc1`, which turns into
// `carbon-busybox clang -cc1`, which results in an equivalent `clang_main`
// call.
//
// Also note that we only do `-disable-free` filtering in the in-process
// execution here, as subprocesses leaking memory won't impact this process.
auto cc1_main = [this, enable_leaking](
llvm::SmallVectorImpl<const char*>& cc1_args) -> int {
return RunCC1(cc1_args, enable_leaking);
};
driver.CC1Main = cc1_main;
std::unique_ptr<clang::driver::Compilation> compilation(
driver.BuildCompilation(cstr_args));
CARBON_CHECK(compilation, "Should always successfully allocate!");
if (compilation->containsError()) {
// These should have been diagnosed by the driver.
return false;
}
// Make sure our target detection matches Clang's. Sadly, we can't just reuse
// Clang's as it is available too late.
// TODO: Use nice diagnostics here rather than a check failure.
CARBON_CHECK(llvm::Triple(target) == llvm::Triple(driver.getTargetTriple()),
"Mismatch between the expected target '{0}' and the one "
"computed by Clang '{1}'",
target, driver.getTargetTriple());
CARBON_VLOG("Running Clang driver...\n");
llvm::SmallVector<std::pair<int, const clang::driver::Command*>>
failing_commands;
int result = driver.ExecuteCompilation(*compilation, failing_commands);
// Finish diagnosing any failures before we verbosely log the source of those
// failures.
diagnostic_client.finish();
CARBON_VLOG("Execution result code: {0}\n", result);
for (const auto& [command_result, failing_command] : failing_commands) {
CARBON_VLOG("Failing command '{0}' with code '{1}' was:\n",
failing_command->getExecutable(), command_result);
if (vlog_stream_) {
failing_command->Print(*vlog_stream_, "\n\n", /*Quote=*/true);
}
}
// Return whether the command was executed successfully.
return result == 0 && failing_commands.empty();
}
} // namespace Carbon