mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Chandler Carruth
8b967943d3
Multiple subcommands all need the ability to disable on-demand runtime building, and this may be needed outside of using _prebuilt_ runtimes. For example, with Bazel the plan is to not build runtimes at all and have Bazel provide them as native Bazel libraries. Updates the `link` subcommand to respect this flag when running Clang to perform links. We didn't have any real testing of the `link` subcommand, in part because it was difficult -- it would try to link runtime libraries. Now that we can prevent building them on demand, we can use that to test the link command. That in turn helped uncover a couple of bugs that are fixed here. 1) The `driver_env_` member of the `Driver` was re-used across `RunCommand` invocations. Some of its fields are constant across these, others can be updated, and still more are not necessarily something we would expect to be re-used. This fixes that by removing the `driver_env_` member, and replacing it with members for just the fields of `DriverEnv` that we want to set initially based on the construction of the `Driver` object. This causes multiple, sequential `RunCommand` calls to not clobber or erroneously inherit state. 2) The temporary directory support in the driver unittest didn't allow the driver to observe the things it wrote to the temporary directory. This PR updates the test logic to create an overlay VFS so that both the in-memory test inputs are observed, but so are the real files written into the temporary directory. 3) The Clang runner, when asked to run Clang without runtimes would still attempt to include runtimes in any link command. This isn't quite what we want, as the whole reason to use this without building runtimes is to reuse ones built in some other way and potentially in some other location. For now, this PR uses a hack to suppress these issues so that we can have a basic test, but in the future we'll need a better solution here. 4) The driver test didn't include the actual driver in the install data. The test even worked around this, but it makes it impossible to link reliably as the `lld` binary isn't available. This adds the data dependency and updates the test to the available digest, etc.
84 lines
2.9 KiB
C++
84 lines
2.9 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.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 (driver_env.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
|