mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-01 22:02:45 +01:00
Chandler CarruthandDavid Blaikie
77808cd5d7
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>
107 lines
3.8 KiB
C++
107 lines
3.8 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_subcommand.h"
|
|
|
|
#include <string>
|
|
|
|
#include "llvm/TargetParser/Host.h"
|
|
#include "toolchain/driver/clang_runner.h"
|
|
|
|
namespace Carbon {
|
|
|
|
auto ClangOptions::Build(CommandLine::CommandBuilder& b) -> void {
|
|
b.AddFlag(
|
|
{
|
|
.name = "build-runtimes",
|
|
.help = R"""(
|
|
Enables on-demand building of target-specific runtimes.
|
|
|
|
When enabled, any link actions using `clang` will build the necessary runtimes
|
|
on-demand. This build will use any customization it can from the link command
|
|
line flags to build the runtimes for the correct target and with any desired
|
|
features enabled.
|
|
|
|
Note: this only has an effect when `--prebuilt-runtimes` are not provided. If
|
|
there are no prebuilt runtimes and building runtimes is disabled, then it is
|
|
assumed the installed toolchain has had the necessary target runtimes added to
|
|
the installation tree in the default searched locations.
|
|
)""",
|
|
},
|
|
[&](auto& arg_b) {
|
|
// TODO: Once runtimes are cached properly, the plan is to enable this
|
|
// by default.
|
|
arg_b.Default(false);
|
|
arg_b.Set(&build_runtimes_on_demand);
|
|
});
|
|
b.AddStringPositionalArg(
|
|
{
|
|
.name = "ARG",
|
|
.help = R"""(
|
|
Arguments passed to Clang.
|
|
)""",
|
|
},
|
|
[&](auto& arg_b) { arg_b.Append(&args); });
|
|
}
|
|
|
|
static constexpr CommandLine::CommandInfo SubcommandInfo = {
|
|
.name = "clang",
|
|
.help = R"""(
|
|
Runs Clang on arguments.
|
|
|
|
This is equivalent to running the `clang` command line directly, and provides
|
|
the full command line interface.
|
|
|
|
Use `carbon clang -- ARGS` to pass flags to `clang`. Although there are
|
|
currently no flags for `carbon clang`, the `--` reserves the ability to add
|
|
flags in the future.
|
|
|
|
This is provided to help guarantee consistent compilation of C++ files, both
|
|
when Clang is invoked directly and when a Carbon file importing a C++ file
|
|
results in an indirect Clang invocation.
|
|
)""",
|
|
};
|
|
|
|
ClangSubcommand::ClangSubcommand() : DriverSubcommand(SubcommandInfo) {}
|
|
|
|
// TODO: This lacks a lot of features from the main driver code. We may need to
|
|
// add more.
|
|
// https://github.com/llvm/llvm-project/blob/main/clang/tools/driver/driver.cpp
|
|
auto ClangSubcommand::Run(DriverEnv& driver_env) -> DriverResult {
|
|
ClangRunner runner(driver_env.installation, driver_env.fs,
|
|
driver_env.vlog_stream);
|
|
|
|
// Don't run Clang when fuzzing, it is known to not be reliable under fuzzing
|
|
// due to many unfixed issues.
|
|
if (TestAndDiagnoseIfFuzzingExternalLibraries(driver_env, "clang")) {
|
|
return {.success = false};
|
|
}
|
|
|
|
ErrorOr<bool> run_result = false;
|
|
if (driver_env.prebuilt_runtimes) {
|
|
run_result = runner.RunWithPrebuiltRuntimes(options_.args,
|
|
*driver_env.prebuilt_runtimes,
|
|
driver_env.enable_leaking);
|
|
} else if (options_.build_runtimes_on_demand) {
|
|
run_result = runner.Run(options_.args, driver_env.runtimes_cache,
|
|
*driver_env.thread_pool, driver_env.enable_leaking);
|
|
} else {
|
|
run_result =
|
|
runner.RunWithNoRuntimes(options_.args, driver_env.enable_leaking);
|
|
}
|
|
if (!run_result.ok()) {
|
|
// This is not a Clang failure, but a failure to even run Clang, so we need
|
|
// to diagnose it here.
|
|
CARBON_DIAGNOSTIC(FailureRunningClang, Error,
|
|
"failure running `clang` subcommand: {0}", std::string);
|
|
driver_env.emitter.Emit(FailureRunningClang, run_result.error().message());
|
|
return {.success = false};
|
|
}
|
|
|
|
// Successfully ran Clang, but return whether Clang itself succeeded.
|
|
return {.success = *run_result};
|
|
}
|
|
|
|
} // namespace Carbon
|