mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-15 18:08:10 +00:00
Chandler Carruth
0546b48a7d
Add support to the driver for CLI flags that select which CPU to target, which CPU to tune performance for, and which CPU features to enable. - `--target-cpu` selects the architecture of CPU to target, similar to `-march` on x86. This combines `-march` with `armv*` strings and `-mcpu` on Arm for specific CPU names. Similarly for RISC-V (if/when we support and test it), etc. Notably, `--target-cpu=native` targets the current native CPU. - `--target-cpu-tune` maps to `-mtune`. This is expected to be rarely if ever desirable, and I'm open to removing it, but if folks are relying on this for performance I didn't want to hide the option. - `--target-cpu-features` allows a "standard" (for LLVM) comma-separated list of LLVM subtarget features, including `+feature` and `-feature` syntax. These flags, when provided, establish the default baseline for CPU targeting and control how on-demand runtimes are built. They can be changed or overridden by additional Clang flags when using `--clang-arg`. A critical part of this is building runtimes on demand using these features. For that, we need to do some amount of canonicalization (re-using Clang's canonicalization to ensure consistent behavior), and extend the runtimes cache features to recognize these customizations. Note that only the top-level Carbon flags impact runtimes, any particular Clang arguments are only used by the specific compiles that receive those arguments. There is some nascent RISC-V support here, but it is incomplete and only minimally tested. Still, it seemed better to record the parts we could test than remove them. Assisted-by: Antigravity with Gemini
64 lines
2.6 KiB
C++
64 lines
2.6 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
|
|
|
|
#ifndef CARBON_TOOLCHAIN_BASE_CLANG_INVOCATION_H_
|
|
#define CARBON_TOOLCHAIN_BASE_CLANG_INVOCATION_H_
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Frontend/CompilerInvocation.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/IntrusiveRefCntPtr.h"
|
|
#include "llvm/Support/VirtualFileSystem.h"
|
|
#include "toolchain/base/install_paths.h"
|
|
#include "toolchain/diagnostics/emitter.h"
|
|
|
|
namespace Carbon {
|
|
|
|
// Converts diagnostics from the Clang driver to Carbon diagnostics.
|
|
class ClangDriverDiagnosticConsumer : public clang::DiagnosticConsumer {
|
|
public:
|
|
// Creates an instance with the location that triggers calling Clang.
|
|
// `context` must not be null.
|
|
explicit ClangDriverDiagnosticConsumer(Diagnostics::NoLocEmitter* emitter)
|
|
: emitter_(emitter) {}
|
|
|
|
// Generates a Carbon warning for each Clang warning and a Carbon error for
|
|
// each Clang error or fatal.
|
|
auto HandleDiagnostic(clang::DiagnosticsEngine::Level diag_level,
|
|
const clang::Diagnostic& info) -> void override;
|
|
|
|
private:
|
|
// Diagnostic emitter. Note that driver diagnostics don't have meaningful
|
|
// locations attached.
|
|
Diagnostics::NoLocEmitter* emitter_;
|
|
};
|
|
|
|
// Builds and returns a clang `CompilerInvocation` to use when building code for
|
|
// interop, from a list of clang driver arguments. Validates the target options
|
|
// and canonicalizes `TargetOptions::Features` via
|
|
// `clang::TargetInfo::CreateTargetInfo`. Emits diagnostics to `consumer` if the
|
|
// arguments or target options are invalid.
|
|
auto BuildClangInvocation(Diagnostics::Consumer& consumer,
|
|
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
|
|
const InstallPaths& install_paths,
|
|
llvm::StringRef target_str,
|
|
llvm::ArrayRef<llvm::StringRef> extra_args = {})
|
|
-> std::unique_ptr<clang::CompilerInvocation>;
|
|
|
|
// Appends the default Clang command line arguments used when building a
|
|
// Carbon-compatible Clang invocation.
|
|
//
|
|
// Where possible, code should use `BuildClangInvocation` above. However, when
|
|
// invoking Clang directly, this can be used to get the core compatible flags.
|
|
auto AppendDefaultClangArgs(const InstallPaths& install_paths,
|
|
llvm::StringRef target_str,
|
|
llvm::SmallVectorImpl<std::string>& args) -> void;
|
|
|
|
} // namespace Carbon
|
|
|
|
#endif // CARBON_TOOLCHAIN_BASE_CLANG_INVOCATION_H_
|