60#include "clang/Config/config.h"
77#include "llvm/ADT/ArrayRef.h"
78#include "llvm/ADT/STLExtras.h"
79#include "llvm/ADT/ScopeExit.h"
80#include "llvm/ADT/SmallSet.h"
81#include "llvm/ADT/SmallVector.h"
82#include "llvm/ADT/StringExtras.h"
83#include "llvm/ADT/StringRef.h"
84#include "llvm/ADT/StringSet.h"
85#include "llvm/ADT/StringSwitch.h"
86#include "llvm/Config/llvm-config.h"
87#include "llvm/MC/TargetRegistry.h"
88#include "llvm/Option/Arg.h"
89#include "llvm/Option/ArgList.h"
90#include "llvm/Option/OptSpecifier.h"
91#include "llvm/Option/OptTable.h"
92#include "llvm/Option/Option.h"
93#include "llvm/Support/CommandLine.h"
94#include "llvm/Support/ErrorHandling.h"
95#include "llvm/Support/ExitCodes.h"
96#include "llvm/Support/FileSystem.h"
97#include "llvm/Support/FileUtilities.h"
98#include "llvm/Support/FormatVariadic.h"
99#include "llvm/Support/IOSandbox.h"
100#include "llvm/Support/JSON.h"
101#include "llvm/Support/MD5.h"
102#include "llvm/Support/MemoryBuffer.h"
103#include "llvm/Support/Path.h"
104#include "llvm/Support/PrettyStackTrace.h"
105#include "llvm/Support/Process.h"
106#include "llvm/Support/Program.h"
107#include "llvm/Support/Regex.h"
108#include "llvm/Support/StringSaver.h"
109#include "llvm/Support/TarWriter.h"
110#include "llvm/Support/VirtualFileSystem.h"
111#include "llvm/Support/raw_ostream.h"
112#include "llvm/TargetParser/Host.h"
113#include "llvm/TargetParser/RISCVISAInfo.h"
126using namespace clang;
129template <
typename F>
static bool usesInput(
const ArgList &Args, F &&Fn) {
130 return llvm::any_of(Args, [&](Arg *A) {
131 return (A->getOption().matches(options::OPT_x) &&
133 (A->getOption().
getKind() == Option::InputClass &&
134 StringRef(A->getValue()).rfind(
'.') != StringRef::npos &&
136 &A->getValue()[StringRef(A->getValue()).rfind(
'.') + 1])));
141 return Arg ==
"-internal-isystem" || Arg ==
"-internal-externc-isystem" ||
142 Arg ==
"-isystem" || Arg ==
"-cxx-isystem" || Arg ==
"-idirafter";
146 const ArgList &Args) {
147 ArgStringList CC1Args;
148 if (Args.hasArg(options::OPT_stdlibxx_isystem))
153 for (
size_t I = 0; I < CC1Args.size(); ++I) {
154 StringRef Arg(CC1Args[I]);
156 llvm::outs() << CC1Args[++I] <<
'\n';
162 if (Arg *A = Args.getLastArg(options::OPT_fuse_cuid_EQ)) {
163 StringRef UseCUIDStr = A->getValue();
164 UseCUID = llvm::StringSwitch<Kind>(UseCUIDStr)
165 .Case(
"hash", Kind::Hash)
166 .Case(
"random", Kind::Random)
167 .Case(
"none", Kind::None)
168 .Default(Kind::Invalid);
169 if (UseCUID == Kind::Invalid)
170 D.Diag(clang::diag::err_drv_invalid_value)
171 << A->getAsString(Args) << UseCUIDStr;
174 FixedCUID = Args.getLastArgValue(options::OPT_cuid_EQ);
175 if (!FixedCUID.empty())
180 llvm::opt::DerivedArgList &Args)
const {
181 std::string CUID = FixedCUID.str();
184 CUID = llvm::utohexstr(llvm::sys::Process::GetRandomNumber(),
188 llvm::MD5::MD5Result
Hash;
189 Hasher.update(InputFile);
190 for (
auto *A : Args) {
191 if (A->getOption().matches(options::OPT_INPUT))
193 Hasher.update(A->getAsString(Args));
196 CUID = llvm::utohexstr(
Hash.low(),
true);
204 : Diags(Diags), VFS(
std::move(VFS)), Mode(GCCMode),
205 SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
211 TargetTriple(TargetTriple), Saver(Alloc), PrependArg(
nullptr),
212 PreferredLinker(CLANG_DEFAULT_LINKER), CheckInputsExist(
true),
213 ProbePrecompiled(
true), SuppressMissingInputWarning(
false) {
216 this->VFS = llvm::vfs::getRealFileSystem();
221 if ((!
SysRoot.empty()) && llvm::sys::path::is_relative(
SysRoot)) {
224 llvm::sys::path::append(P,
SysRoot);
228#if defined(CLANG_CONFIG_FILE_SYSTEM_DIR)
229 if (llvm::sys::path::is_absolute(CLANG_CONFIG_FILE_SYSTEM_DIR)) {
233 llvm::sys::path::append(configFileDir, CLANG_CONFIG_FILE_SYSTEM_DIR);
234 llvm::sys::path::remove_dots(configFileDir,
true);
238#if defined(CLANG_CONFIG_FILE_USER_DIR)
241 llvm::sys::fs::expand_tilde(CLANG_CONFIG_FILE_USER_DIR, P);
250void Driver::setDriverMode(StringRef
Value) {
251 static StringRef OptName =
252 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
253 if (
auto M = llvm::StringSwitch<std::optional<DriverMode>>(
Value)
254 .Case(
"gcc", GCCMode)
255 .Case(
"g++", GXXMode)
256 .Case(
"cpp", CPPMode)
258 .Case(
"flang", FlangMode)
259 .Case(
"dxc", DXCMode)
263 Diag(diag::err_drv_unsupported_option_argument) << OptName <<
Value;
268 bool &ContainsError)
const {
269 llvm::PrettyStackTraceString CrashInfo(
"Command line argument parsing");
270 ContainsError =
false;
272 llvm::opt::Visibility VisibilityMask = getOptionVisibilityMask(UseDriverMode);
273 unsigned MissingArgIndex, MissingArgCount;
274 InputArgList Args =
getOpts().ParseArgs(ArgStrings, MissingArgIndex,
275 MissingArgCount, VisibilityMask);
278 if (MissingArgCount) {
279 Diag(diag::err_drv_missing_argument)
280 << Args.getArgString(MissingArgIndex) << MissingArgCount;
282 Diags.getDiagnosticLevel(diag::err_drv_missing_argument,
287 for (
const Arg *A : Args) {
289 Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
290 ContainsError |= Diags.getDiagnosticLevel(diag::err_drv_unsupported_opt,
297 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue(
"")) {
298 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
299 ContainsError |= Diags.getDiagnosticLevel(
300 diag::warn_drv_empty_joined_argument,
305 for (
const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {
307 auto ArgString = A->getAsString(Args);
309 if (
getOpts().findNearest(ArgString, Nearest, VisibilityMask) > 1) {
311 if (
getOpts().findExact(ArgString, Nearest,
313 DiagID = diag::err_drv_unknown_argument_with_suggestion;
314 Diags.Report(DiagID) << ArgString <<
"-Xflang " + Nearest;
316 DiagID = diag::err_drv_unknown_argument;
317 Diags.Report(DiagID) << ArgString;
320 llvm::opt::Visibility(
322 DiagID = diag::err_drv_unknown_argument_with_suggestion;
323 Diags.Report(DiagID) << ArgString <<
"-Xclang " + Nearest;
325 DiagID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl
326 : diag::err_drv_unknown_argument;
327 Diags.Report(DiagID) << ArgString;
331 ? diag::warn_drv_unknown_argument_clang_cl_with_suggestion
332 : diag::err_drv_unknown_argument_with_suggestion;
333 Diags.Report(DiagID) << ArgString << Nearest;
335 ContainsError |= Diags.getDiagnosticLevel(DiagID,
SourceLocation()) >
339 for (
const Arg *A : Args.filtered(options::OPT_o)) {
340 if (ArgStrings[A->getIndex()] == A->getSpelling())
344 std::string ArgString = ArgStrings[A->getIndex()];
346 if (
getOpts().findExact(
"-" + ArgString, Nearest, VisibilityMask))
347 Diags.Report(diag::warn_drv_potentially_misspelled_joined_argument)
348 << A->getAsString(Args) << Nearest;
358 Arg **FinalPhaseArg)
const {
359 Arg *PhaseArg =
nullptr;
363 if (
CCCIsCPP() || (PhaseArg = Args.getLastArg(options::OPT_E)) ||
364 (PhaseArg = Args.getLastArg(options::OPT__SLASH_EP)) ||
365 (PhaseArg = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
372 }
else if ((PhaseArg = Args.getLastArg(options::OPT__precompile)) ||
374 Args.getLastArg(options::OPT__precompile_reduced_bmi)) ||
375 (PhaseArg = Args.getLastArg(options::OPT_extract_api)) ||
376 (PhaseArg = Args.getLastArg(options::OPT_fmodule_header,
377 options::OPT_fmodule_header_EQ))) {
380 }
else if ((PhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) ||
381 (PhaseArg = Args.getLastArg(options::OPT_print_supported_cpus)) ||
383 Args.getLastArg(options::OPT_print_supported_tune_cpus)) ||
385 Args.getLastArg(options::OPT_print_enabled_extensions)) ||
386 (PhaseArg = Args.getLastArg(options::OPT_module_file_info)) ||
387 (PhaseArg = Args.getLastArg(options::OPT_verify_pch)) ||
388 (PhaseArg = Args.getLastArg(options::OPT_rewrite_objc)) ||
389 (PhaseArg = Args.getLastArg(options::OPT_rewrite_legacy_objc)) ||
390 (PhaseArg = Args.getLastArg(options::OPT__analyze)) ||
391 (PhaseArg = Args.getLastArg(options::OPT_emit_cir)) ||
392 (PhaseArg = Args.getLastArg(options::OPT_emit_ast))) {
396 }
else if ((PhaseArg = Args.getLastArg(options::OPT_S))) {
400 }
else if ((PhaseArg = Args.getLastArg(options::OPT_c))) {
403 }
else if ((PhaseArg = Args.getLastArg(options::OPT_emit_interface_stubs))) {
411 *FinalPhaseArg = PhaseArg;
419 llvm::sys::fs::createTemporaryFile(
"driver-program",
"txt", OutputFile,
420 llvm::sys::fs::OF_Text);
421 llvm::FileRemover OutputRemover(OutputFile.c_str());
422 std::optional<llvm::StringRef> Redirects[] = {
428 std::string ErrorMessage;
429 int SecondsToWait = 60;
430 if (std::optional<std::string> Str =
431 llvm::sys::Process::GetEnv(
"CLANG_TOOLCHAIN_PROGRAM_TIMEOUT")) {
432 if (!llvm::to_integer(*Str, SecondsToWait))
433 return llvm::createStringError(std::error_code(),
434 "CLANG_TOOLCHAIN_PROGRAM_TIMEOUT expected "
435 "an integer, got '" +
437 SecondsToWait = std::max(SecondsToWait, 0);
439 StringRef Executable = Args[0];
440 if (llvm::sys::ExecuteAndWait(Executable, Args, {}, Redirects, SecondsToWait,
442 return llvm::createStringError(std::error_code(),
443 Executable +
": " + ErrorMessage);
445 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
446 llvm::MemoryBuffer::getFile(OutputFile.c_str());
448 return llvm::createStringError(OutputBuf.getError(),
449 "Failed to read stdout of " + Executable +
450 ": " + OutputBuf.getError().message());
451 return std::move(*OutputBuf);
455 StringRef
Value,
bool Claim) {
456 Arg *A =
new Arg(Opts.getOption(options::OPT_INPUT),
Value,
457 Args.getBaseArgs().MakeIndex(
Value),
Value.data());
458 Args.AddSynthesizedArg(A);
464DerivedArgList *Driver::TranslateInputArgs(
const InputArgList &Args,
465 const llvm::Triple &Triple)
const {
466 const llvm::opt::OptTable &Opts =
getOpts();
467 DerivedArgList *DAL =
new DerivedArgList(Args);
469 std::optional<ClangCLArgs> CLArgs;
471 CLArgs.emplace(Args, Triple);
473 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
474 bool HasNostdlibxx = Args.hasArg(options::OPT_nostdlibxx);
475 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
476 bool IgnoreUnused =
false;
477 for (Arg *A : Args) {
481 if (A->getOption().matches(options::OPT_start_no_unused_arguments)) {
485 if (A->getOption().matches(options::OPT_end_no_unused_arguments)) {
486 IgnoreUnused =
false;
490 if (CLArgs && CLArgs->translateArg(A, *DAL))
494 if ((CLArgs || Triple.isWindowsMSVCEnvironment()) &&
495 A->getOption().matches(options::OPT_D)) {
498 if (
Value == A->getValue())
501 DAL->AddJoinedArg(A, Opts.getOption(options::OPT_D),
Value);
511 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
512 A->getOption().matches(options::OPT_Xlinker)) &&
513 A->containsValue(
"--no-demangle")) {
515 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_Xlinker__no_demangle));
518 for (StringRef Val : A->getValues())
519 if (Val !=
"--no-demangle")
520 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_Xlinker), Val);
528 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
529 A->getNumValues() > 0 &&
530 (A->getValue(0) == StringRef(
"-MD") ||
531 A->getValue(0) == StringRef(
"-MMD"))) {
533 if (A->getValue(0) == StringRef(
"-MD"))
534 DAL->AddFlagArg(A, Opts.getOption(options::OPT_MD));
536 DAL->AddFlagArg(A, Opts.getOption(options::OPT_MMD));
537 if (A->getNumValues() == 2)
538 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(1));
543 if (A->getOption().matches(options::OPT_l)) {
544 StringRef
Value = A->getValue();
547 if (!HasNostdlib && !HasNodefaultlib && !HasNostdlibxx &&
549 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_stdcxx));
554 if (
Value ==
"cc_kext") {
555 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_cckext));
561 if (A->getOption().matches(options::OPT__DASH_DASH)) {
563 for (StringRef Val : A->getValues())
572 if (
IsDXCMode() && !Args.hasArg(options::OPT_dxc_Fo))
573 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_S));
576 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false))
577 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_static));
581#if defined(HOST_LINK_VERSION)
582 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
583 strlen(HOST_LINK_VERSION) > 0) {
584 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mlinker_version_EQ),
586 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
594 StringRef ArgTarget) {
596 static bool BeSilent =
false;
597 auto IsTooOldToBeSupported = [](
int v,
int r) ->
bool {
return v < 3; };
600 if (ArgTarget.equals_insensitive(
"CURRENT")) {
604 unsigned int Version = 0;
605 unsigned int Release = 0;
606 unsigned int Modification = 0;
608 llvm::Regex ZOsvRegex(
"[zZ][oO][sS][vV]([0-9])[rR]([0-9])");
609 llvm::Regex HexRegex(
612 "([0-9a-fA-F][0-9a-fA-F])"
613 "([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])" );
616 if (ZOsvRegex.match(ArgTarget, &Matches)) {
617 Matches[1].getAsInteger(10, Version);
618 Matches[2].getAsInteger(10, Release);
620 if (IsTooOldToBeSupported(Version, Release)) {
622 D.
Diag(diag::err_zos_target_release_discontinued) << ArgTarget;
625 }
else if (HexRegex.match(ArgTarget, &Matches)) {
626 Matches[1].getAsInteger(16, Version);
627 Matches[2].getAsInteger(16, Release);
628 Matches[3].getAsInteger(16, Modification);
629 if (IsTooOldToBeSupported(Version, Release)) {
631 D.
Diag(diag::err_zos_target_release_discontinued) << ArgTarget;
637 D.
Diag(diag::err_zos_target_unrecognized_release) << ArgTarget;
642 llvm::VersionTuple
V(Version, Release, Modification);
643 llvm::VersionTuple TV =
Target.getOSVersion();
646 if (TV.empty() ||
V < TV) {
648 Str = llvm::Triple::getOSTypeName(
Target.getOS());
649 Str +=
V.getAsString();
663 StringRef ArchName =
"") {
665 if (
const Arg *A = Args.getLastArg(options::OPT_target))
666 TargetTriple = A->getValue();
668 llvm::Triple
Target(llvm::Triple::normalize(TargetTriple));
673 if (TargetTriple.contains(
"-unknown-gnu") || TargetTriple.contains(
"-pc-gnu"))
677 if (
Target.isOSBinFormatMachO()) {
679 if (!ArchName.empty()) {
681 return llvm::Triple(
Target.normalize());
685 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
686 StringRef ArchName = A->getValue();
689 }
else if (!ArchName.empty()) {
690 Target.setArchName(ArchName);
696 if (Arg *A = Args.getLastArgNoClaim(options::OPT_mlittle_endian,
697 options::OPT_mbig_endian)) {
698 llvm::Triple
T = A->getOption().matches(options::OPT_mlittle_endian)
699 ?
Target.getLittleEndianArchVariant()
700 :
Target.getBigEndianArchVariant();
701 if (
T.getArch() != llvm::Triple::UnknownArch) {
702 Target = llvm::Triple(
T.normalize());
703 Args.claimAllArgs(options::OPT_mlittle_endian, options::OPT_mbig_endian);
708 if (
Target.getArch() == llvm::Triple::tce)
714 if (!Args.hasArg(options::OPT_target)) {
715 if (std::optional<std::string> ObjectModeValue =
716 llvm::sys::Process::GetEnv(
"OBJECT_MODE")) {
717 StringRef ObjectMode = *ObjectModeValue;
718 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
721 if (ObjectMode ==
"64") {
722 AT =
Target.get64BitArchVariant().getArch();
723 }
else if (ObjectMode ==
"32" || ObjectMode ==
"32_64" ||
724 ObjectMode ==
"any") {
726 if (Args.hasArg(options::OPT_maix64, options::OPT_m64))
727 AT =
Target.get64BitArchVariant().getArch();
729 D.
Diag(diag::err_drv_compile_mode_unsupported_aix);
731 D.
Diag(diag::err_drv_invalid_object_mode) << ObjectMode;
735 const bool OtherAllowedMode =
736 ObjectMode ==
"32_64" || ObjectMode ==
"any";
737 if (ObjectMode ==
"64")
738 AT =
Target.get64BitArchVariant().getArch();
739 else if (ObjectMode ==
"32")
740 AT =
Target.get32BitArchVariant().getArch();
741 else if (!OtherAllowedMode)
742 D.
Diag(diag::err_drv_invalid_object_mode) << ObjectMode;
745 if (AT != llvm::Triple::UnknownArch && AT !=
Target.getArch()) {
750 !Args.hasArg(options::OPT_maix64, options::OPT_m64)) {
753 D.
Diag(diag::err_drv_compile_mode_unsupported_aix);
760 if (
Target.isUEFI() &&
Target.getArch() != llvm::Triple::x86_64 &&
761 Target.getArch() != llvm::Triple::aarch64)
762 D.
Diag(diag::err_target_unknown_triple) <<
Target.str();
765 if (Arg *A = Args.getLastArgNoClaim(options::OPT_maix32, options::OPT_maix64);
767 D.
Diag(diag::err_drv_unsupported_opt_for_target)
768 << A->getAsString(Args) <<
Target.str();
771 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
772 options::OPT_m32, options::OPT_m16,
773 options::OPT_maix32, options::OPT_maix64);
775 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
777 if (A->getOption().matches(options::OPT_m64) ||
778 A->getOption().matches(options::OPT_maix64)) {
779 AT =
Target.get64BitArchVariant().getArch();
780 if (
Target.getEnvironment() == llvm::Triple::GNUX32 ||
781 Target.getEnvironment() == llvm::Triple::GNUT64)
782 Target.setEnvironment(llvm::Triple::GNU);
783 else if (
Target.getEnvironment() == llvm::Triple::MuslX32)
784 Target.setEnvironment(llvm::Triple::Musl);
785 }
else if (A->getOption().matches(options::OPT_mx32) &&
786 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
787 AT = llvm::Triple::x86_64;
788 if (
Target.getEnvironment() == llvm::Triple::Musl)
789 Target.setEnvironment(llvm::Triple::MuslX32);
791 Target.setEnvironment(llvm::Triple::GNUX32);
792 }
else if (A->getOption().matches(options::OPT_m32) ||
793 A->getOption().matches(options::OPT_maix32)) {
796 D.
Diag(diag::err_drv_compile_mode_unsupported_aix);
798 D.
Diag(diag::err_drv_unsupported_opt_for_target)
799 << A->getAsString(Args) <<
Target.str();
802 AT =
Target.get32BitArchVariant().getArch();
803 if (
Target.getEnvironment() == llvm::Triple::GNUX32)
804 Target.setEnvironment(llvm::Triple::GNU);
805 else if (
Target.getEnvironment() == llvm::Triple::MuslX32)
806 Target.setEnvironment(llvm::Triple::Musl);
808 }
else if (A->getOption().matches(options::OPT_m16) &&
809 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
810 AT = llvm::Triple::x86;
811 Target.setEnvironment(llvm::Triple::CODE16);
814 if (AT != llvm::Triple::UnknownArch && AT !=
Target.getArch()) {
816 if (
Target.isWindowsGNUEnvironment())
824 if ((A = Args.getLastArg(options::OPT_mzos_target_EQ))) {
830 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
831 if (
Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
832 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-miamcu"
835 if (A && !A->getOption().matches(options::OPT_m32))
836 D.
Diag(diag::err_drv_argument_not_allowed_with)
837 <<
"-miamcu" << A->getBaseArg().getAsString(Args);
839 Target.setArch(llvm::Triple::x86);
840 Target.setArchName(
"i586");
841 Target.setEnvironmentName(
"");
842 Target.setOS(llvm::Triple::ELFIAMCU);
843 Target.setVendor(llvm::Triple::Intel);
849 if ((A = Args.getLastArg(options::OPT_mabi_EQ))) {
850 StringRef ABIName = A->getValue();
851 if (ABIName ==
"32") {
853 if (
Target.getEnvironment() == llvm::Triple::GNUABI64 ||
854 Target.getEnvironment() == llvm::Triple::GNUABIN32)
855 Target.setEnvironment(llvm::Triple::GNU);
856 }
else if (ABIName ==
"n32") {
858 if (
Target.getEnvironment() == llvm::Triple::GNU ||
859 Target.getEnvironment() == llvm::Triple::GNUT64 ||
860 Target.getEnvironment() == llvm::Triple::GNUABI64)
861 Target.setEnvironment(llvm::Triple::GNUABIN32);
862 else if (
Target.getEnvironment() == llvm::Triple::Musl ||
863 Target.getEnvironment() == llvm::Triple::MuslABI64)
864 Target.setEnvironment(llvm::Triple::MuslABIN32);
865 }
else if (ABIName ==
"64") {
867 if (
Target.getEnvironment() == llvm::Triple::GNU ||
868 Target.getEnvironment() == llvm::Triple::GNUT64 ||
869 Target.getEnvironment() == llvm::Triple::GNUABIN32)
870 Target.setEnvironment(llvm::Triple::GNUABI64);
871 else if (
Target.getEnvironment() == llvm::Triple::Musl ||
872 Target.getEnvironment() == llvm::Triple::MuslABIN32)
873 Target.setEnvironment(llvm::Triple::MuslABI64);
883 if (Args.hasArg(options::OPT_march_EQ) ||
884 Args.hasArg(options::OPT_mcpu_EQ)) {
886 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
888 if (!llvm::errorToBool(ISAInfo.takeError())) {
889 unsigned XLen = (*ISAInfo)->getXLen();
891 if (
Target.isLittleEndian())
892 Target.setArch(llvm::Triple::riscv32);
894 Target.setArch(llvm::Triple::riscv32be);
896 }
else if (XLen == 64) {
897 if (
Target.isLittleEndian())
898 Target.setArch(llvm::Triple::riscv64);
900 Target.setArch(llvm::Triple::riscv64be);
907 if (
Target.getArch() == llvm::Triple::riscv32be ||
908 Target.getArch() == llvm::Triple::riscv64be) {
909 static bool WarnedRISCVBE =
false;
910 if (!WarnedRISCVBE) {
911 D.
Diag(diag::warn_drv_riscv_be_experimental);
912 WarnedRISCVBE =
true;
921 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
923 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
925 RuntimeName = A->getValue();
927 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
935 Diag(diag::err_drv_unsupported_option_argument)
936 << A->getSpelling() << A->getValue();
939 Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
948 StringRef Program =
C.getArgs().getLastArgValue(
949 options::OPT_offload_arch_tool_EQ,
"offload-arch");
952 if (llvm::ErrorOr<std::string> Executable =
953 llvm::sys::findProgramByName(Program, {
C.getDriver().Dir})) {
955 bool UsesLLVMOffloading =
956 C.getArgs().hasFlag(options::OPT_foffload_via_llvm,
957 options::OPT_fno_offload_via_llvm,
false);
958 if (!UsesLLVMOffloading) {
960 Args.push_back(
"--only=amdgpu");
962 Args.push_back(
"--only=nvptx");
964 Args.push_back(
"--only=intel");
966 auto StdoutOrErr =
C.getDriver().executeProgram(Args);
969 C.getDriver().Diag(diag::err_drv_undetermined_gpu_arch)
974 if ((*StdoutOrErr)->getBuffer().empty()) {
975 C.getDriver().Diag(diag::err_drv_undetermined_gpu_arch)
981 for (StringRef
Arch : llvm::split((*StdoutOrErr)->getBuffer(),
"\n"))
983 GPUArchs.push_back(
Arch.str());
985 C.getDriver().Diag(diag::err_drv_command_failure) <<
"offload-arch";
995 return llvm::Triple(HostTriple.isArch64Bit() ? llvm::Triple::spirv64
996 : llvm::Triple::spirv32);
1003 std::set<std::string> Archs;
1004 for (Arg *A :
C.getInputArgs()) {
1005 for (StringRef
Arch : A->getValues()) {
1006 if (A->getOption().matches(options::OPT_offload_arch_EQ)) {
1007 if (
Arch ==
"native") {
1009 Archs.insert(Str.str());
1011 Archs.insert(
Arch.str());
1013 }
else if (A->getOption().matches(options::OPT_no_offload_arch_EQ)) {
1017 Archs.erase(
Arch.str());
1023 for (llvm::StringRef
Arch : Archs) {
1025 if (ID.isUnknown()) {
1026 llvm::Triple AMDGPUTriple(llvm::Triple::amdgpu, llvm::Triple::NoSubArch,
1027 llvm::Triple::AMD, llvm::Triple::AMDHSA);
1031 bool UsesLLVMOffloading =
1032 C.getArgs().hasFlag(options::OPT_foffload_via_llvm,
1033 options::OPT_fno_offload_via_llvm,
false);
1034 if (!UsesLLVMOffloading) {
1035 if (Kind ==
Action::OFK_HIP && !ID.isAMDGPU() && !ID.isAMDGCNSPIRV()) {
1036 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
1041 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
1047 C.getDriver().Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch)
1051 if (ID.isUnknown() || ID.isUnused()) {
1052 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
1053 <<
"offload" <<
Arch;
1057 llvm::Triple Triple =
1064 if (UsesLLVMOffloading)
1065 Triple.setEnvironment(llvm::Triple::LLVM);
1070 Option Opt =
C.getDriver().getOpts().getOption(options::OPT_Xarch__);
1071 unsigned Index =
C.getArgs().getBaseArgs().MakeIndex(
"-Xarch_");
1072 Arg *A =
new Arg(Opt,
C.getArgs().getArgString(Index), Index,
1073 C.getArgs().MakeArgString(Triple.getArchName()),
1074 C.getArgs().MakeArgString(
"--offload-arch=" +
Arch));
1076 C.getArgs().append(A);
1077 C.getArgs().AddSynthesizedArg(A);
1079 auto It = Triples.lower_bound(Triple);
1080 if (It == Triples.end() || *It != Triple)
1081 Triples.insert(It, Triple);
1086 Triples.insert(llvm::Triple(llvm::Triple::amdgpu, llvm::Triple::NoSubArch,
1087 llvm::Triple::AMD, llvm::Triple::AMDHSA));
1089 llvm::Triple::ArchType
Arch =
1090 C.getDefaultToolChain().getTriple().isArch64Bit()
1091 ? llvm::Triple::nvptx64
1092 : llvm::Triple::nvptx;
1093 Triples.insert(llvm::Triple(
Arch, llvm::Triple::NoSubArch,
1094 llvm::Triple::NVIDIA, llvm::Triple::CUDA));
1099 C.getArgs().eraseArg(options::OPT_offload_arch_EQ);
1100 C.getArgs().eraseArg(options::OPT_no_offload_arch_EQ);
1108 llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
1112 (llvm::any_of(Inputs,
1113 [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
1116 C.getInputArgs().hasArg(options::OPT_hip_link) ||
1117 C.getInputArgs().hasArg(options::OPT_hipstdpar));
1118 bool IsSYCL =
C.getInputArgs().hasFlag(options::OPT_fsycl,
1119 options::OPT_fno_sycl,
false);
1120 bool IsOpenMPOffloading =
1121 (
C.getInputArgs().
hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
1122 options::OPT_fno_openmp,
false) &&
1123 (
C.getInputArgs().hasArg(options::OPT_offload_targets_EQ) ||
1124 (
C.getInputArgs().hasArg(options::OPT_offload_arch_EQ) &&
1125 !(IsCuda || IsHIP))));
1127 llvm::SmallSet<Action::OffloadKind, 4> Kinds;
1128 const std::pair<bool, Action::OffloadKind> ActiveKinds[] = {
1133 for (
const auto &[Active, Kind] : ActiveKinds)
1138 if (Kinds.size() > 1) {
1139 Diag(clang::diag::err_drv_mix_offload)
1146 if (IsCuda || IsHIP)
1153 if (
C.getInputArgs().hasArg(options::OPT_offload_targets_EQ)) {
1154 std::vector<std::string> ArgValues =
1155 C.getInputArgs().getAllArgValues(options::OPT_offload_targets_EQ);
1156 for (llvm::StringRef
Target : ArgValues) {
1160 if (ArgValues.empty())
1161 Diag(clang::diag::warn_drv_empty_joined_argument)
1163 .getLastArg(options::OPT_offload_targets_EQ)
1164 ->getAsString(
C.getInputArgs());
1171 llvm::StringMap<StringRef> FoundNormalizedTriples;
1172 bool UsesLLVMOffloading =
C.getInputArgs().hasFlag(
1173 options::OPT_foffload_via_llvm, options::OPT_fno_offload_via_llvm,
false);
1174 for (
const llvm::Triple &
Target : Triples) {
1179 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
1187 {options::OPT_static_libstdcxx, options::OPT_ffreestanding})
1188 if (Arg *IncompatArg =
C.getInputArgs().getLastArg(ID))
1189 Diag(clang::diag::err_drv_argument_not_allowed_with)
1190 << IncompatArg->getSpelling() <<
"-fsycl";
1194 if (
Target.isNVPTX() && !UsesLLVMOffloading) {
1195 Diag(diag::err_drv_invalid_or_unsupported_offload_target)
1203 if (
Target.getArch() == llvm::Triple::ArchType::UnknownArch) {
1204 Diag(diag::err_drv_invalid_or_unsupported_offload_target)
1209 std::string NormalizedName =
Target.normalize();
1210 auto [TripleIt, Inserted] =
1211 FoundNormalizedTriples.try_emplace(NormalizedName,
Target.str());
1213 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
1214 <<
Target.str() << TripleIt->second;
1218 auto &TC = getOffloadToolChain(
C.getInputArgs(), Kind,
Target,
1219 C.getDefaultToolChain().getTriple());
1223 auto &CudaInstallation =
1225 if (CudaInstallation.isValid())
1226 CudaInstallation.WarnIfUnsupportedVersion();
1229 C.addOffloadDeviceToolChain(&TC, Kind);
1237 const Arg *RDCArg =
C.getInputArgs().getLastArg(options::OPT_fgpu_rdc,
1238 options::OPT_fno_gpu_rdc);
1239 if (RDCArg && RDCArg->getOption().matches(options::OPT_fno_gpu_rdc)) {
1241 if (std::distance(TCRange.first, TCRange.second) > 1)
1242 Diag(clang::diag::err_drv_sycl_no_rdc_multiple_targets)
1243 << RDCArg->getAsString(
C.getInputArgs());
1248bool Driver::loadZOSCustomizationFile(llvm::cl::ExpansionContext &ExpCtx) {
1253 StringRef PathLIBEnv = StringRef(getenv(
"CLANG_CONFIG_PATH")).trim();
1257 if (!PathLIBEnv.empty()) {
1258 llvm::sys::path::append(CustomizationFile, PathLIBEnv);
1259 if (llvm::sys::fs::is_directory(PathLIBEnv))
1260 llvm::sys::path::append(CustomizationFile,
"/clang.cfg");
1261 if (llvm::sys::fs::is_regular_file(CustomizationFile))
1262 return readConfigFile(CustomizationFile, ExpCtx);
1263 Diag(diag::err_drv_config_file_not_found) << CustomizationFile;
1268 llvm::sys::path::append(CustomizationFile, BaseDir +
"/etc/clang.cfg");
1269 if (llvm::sys::fs::is_regular_file(CustomizationFile))
1270 return readConfigFile(CustomizationFile, ExpCtx);
1280 unsigned Index = Args.MakeIndex(Opt->getSpelling());
1281 Arg *
Copy =
new Arg(Opt->getOption(), Args.getArgString(Index), Index);
1282 Copy->getValues() = Opt->getValues();
1283 if (Opt->isClaimed())
1285 Copy->setOwnsValues(Opt->getOwnsValues());
1286 Opt->setOwnsValues(
false);
1288 if (Opt->getAlias()) {
1289 const Arg *Alias = Opt->getAlias();
1290 unsigned Index = Args.MakeIndex(Alias->getSpelling());
1291 auto AliasCopy = std::make_unique<Arg>(Alias->getOption(),
1292 Args.getArgString(Index), Index);
1293 AliasCopy->getValues() = Alias->getValues();
1294 AliasCopy->setOwnsValues(
false);
1295 if (Alias->isClaimed())
1297 Copy->setAlias(std::move(AliasCopy));
1301bool Driver::readConfigFile(StringRef
FileName,
1302 llvm::cl::ExpansionContext &ExpCtx) {
1306 Diag(diag::err_drv_cannot_open_config_file)
1307 <<
FileName << Status.getError().message();
1310 if (Status->getType() != llvm::sys::fs::file_type::regular_file) {
1311 Diag(diag::err_drv_cannot_open_config_file)
1312 <<
FileName <<
"not a regular file";
1317 SmallVector<const char *, 32> NewCfgFileArgs;
1318 if (llvm::Error Err = ExpCtx.readConfigFile(
FileName, NewCfgFileArgs)) {
1319 Diag(diag::err_drv_cannot_read_config_file)
1325 SmallVector<const char *, 32> NewCfgHeadArgs, NewCfgTailArgs;
1326 for (
const char *Opt : NewCfgFileArgs) {
1328 if (Opt[0] ==
'$' && Opt[1])
1329 NewCfgTailArgs.push_back(Opt + 1);
1331 NewCfgHeadArgs.push_back(Opt);
1335 llvm::SmallString<128> CfgFileName(
FileName);
1336 llvm::sys::path::native(CfgFileName);
1337 bool ContainErrors =
false;
1338 auto NewHeadOptions = std::make_unique<InputArgList>(
1342 auto NewTailOptions = std::make_unique<InputArgList>(
1349 for (Arg *A : *NewHeadOptions)
1351 for (Arg *A : *NewTailOptions)
1354 if (!CfgOptionsHead)
1355 CfgOptionsHead = std::move(NewHeadOptions);
1358 for (
auto *Opt : *NewHeadOptions)
1362 if (!CfgOptionsTail)
1363 CfgOptionsTail = std::move(NewTailOptions);
1366 for (
auto *Opt : *NewTailOptions)
1370 ConfigFiles.push_back(std::string(CfgFileName));
1374bool Driver::loadConfigFiles() {
1375 llvm::cl::ExpansionContext ExpCtx(Saver.getAllocator(),
1376 llvm::cl::tokenizeConfigFile, &
getVFS());
1380 if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
1381 SmallString<128> CfgDir;
1383 CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
1384 if (CfgDir.empty() ||
getVFS().makeAbsolute(CfgDir))
1389 if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
1390 SmallString<128> CfgDir;
1391 llvm::sys::fs::expand_tilde(
1392 CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ), CfgDir);
1393 if (CfgDir.empty() ||
getVFS().makeAbsolute(CfgDir))
1402 ExpCtx.setSearchDirs(CfgFileSearchDirs);
1405 if (loadDefaultConfigFiles(ExpCtx))
1409 SmallString<128> CfgFilePath;
1411 for (
auto CfgFileName : CLOptions->getAllArgValues(options::OPT_config)) {
1414 if (llvm::sys::path::has_parent_path(CfgFileName)) {
1415 CfgFilePath.assign(CfgFileName);
1416 if (llvm::sys::path::is_relative(CfgFilePath)) {
1417 if (
getVFS().makeAbsolute(CfgFilePath)) {
1418 Diag(diag::err_drv_cannot_open_config_file)
1419 << CfgFilePath <<
"cannot get absolute path";
1423 }
else if (!ExpCtx.findConfigFile(CfgFileName, CfgFilePath)) {
1425 Diag(diag::err_drv_config_file_not_found) << CfgFileName;
1426 for (
const StringRef &SearchDir : CfgFileSearchDirs)
1427 if (!SearchDir.empty())
1428 Diag(diag::note_drv_config_file_searched_in) << SearchDir;
1433 if (readConfigFile(CfgFilePath, ExpCtx))
1444 llvm::Triple Triple, std::string Suffix) {
1446 if (ExpCtx.findConfigFile(Triple.str() + Suffix, ConfigFilePath))
1450 VersionTuple OSVersion = Triple.getOSVersion();
1451 if (!OSVersion.getMinor().has_value())
1454 std::string BaseOSName = Triple.getOSTypeName(Triple.getOS()).str();
1458 if (OSVersion.getMajor() != 0) {
1459 Triple.setOSName(BaseOSName + llvm::utostr(OSVersion.getMajor()));
1460 if (ExpCtx.findConfigFile(Triple.str() + Suffix, ConfigFilePath))
1466 Triple.setOSName(BaseOSName);
1467 return ExpCtx.findConfigFile(Triple.str() + Suffix, ConfigFilePath);
1470bool Driver::loadDefaultConfigFiles(llvm::cl::ExpansionContext &ExpCtx) {
1473 if (
const char *NoConfigEnv = ::getenv(
"CLANG_NO_DEFAULT_CONFIG")) {
1477 if (CLOptions && CLOptions->hasArg(options::OPT_no_default_config))
1480 std::string RealMode = getExecutableForDriverMode(Mode);
1481 llvm::Triple Triple;
1490 if (PrefixTriple.getArch() == llvm::Triple::UnknownArch ||
1491 PrefixTriple.isOSUnknown())
1492 Triple = std::move(PrefixTriple);
1496 llvm::Triple RealTriple =
1498 if (Triple.str().empty()) {
1499 Triple = RealTriple;
1500 assert(!Triple.str().empty());
1505 if (RealTriple.isOSzOS() && loadZOSCustomizationFile(ExpCtx))
1519 SmallString<128> CfgFilePath;
1521 "-" + RealMode +
".cfg"))
1522 return readConfigFile(CfgFilePath, ExpCtx);
1526 if (TryModeSuffix) {
1529 return readConfigFile(CfgFilePath, ExpCtx);
1534 std::string CfgFileName = RealMode +
".cfg";
1535 if (ExpCtx.findConfigFile(CfgFileName, CfgFilePath)) {
1536 if (readConfigFile(CfgFilePath, ExpCtx))
1538 }
else if (TryModeSuffix) {
1540 if (ExpCtx.findConfigFile(CfgFileName, CfgFilePath) &&
1541 readConfigFile(CfgFilePath, ExpCtx))
1547 return readConfigFile(CfgFilePath, ExpCtx);
1555 llvm::PrettyStackTraceString CrashInfo(
"Compilation construction");
1564 if (!DriverMode.empty())
1565 setDriverMode(DriverMode);
1571 CLOptions = std::make_unique<InputArgList>(
1576 ContainsError = loadConfigFiles();
1577 bool HasConfigFileHead = !ContainsError && CfgOptionsHead;
1578 bool HasConfigFileTail = !ContainsError && CfgOptionsTail;
1582 HasConfigFileHead ? std::move(*CfgOptionsHead) : std::move(*CLOptions);
1584 if (HasConfigFileHead)
1585 for (
auto *Opt : *CLOptions)
1586 if (!Opt->getOption().matches(options::OPT_config))
1590 if (
IsCLMode() && !ContainsError) {
1592 for (
const auto *A : Args.filtered(options::OPT__SLASH_clang)) {
1594 CLModePassThroughArgList.push_back(A->getValue());
1597 if (!CLModePassThroughArgList.empty()) {
1600 auto CLModePassThroughOptions = std::make_unique<InputArgList>(
1605 for (
auto *Opt : *CLModePassThroughOptions)
1611 if (Arg *WD = Args.getLastArg(options::OPT_working_directory))
1612 if (VFS->setCurrentWorkingDirectory(WD->getValue()))
1613 Diag(diag::err_drv_unable_to_set_working_directory) << WD->getValue();
1616 if (!Diags.isIgnored(diag::warn_missing_include_dirs,
SourceLocation())) {
1617 for (
auto IncludeDir : Args.getAllArgValues(options::OPT_I_Group)) {
1618 if (!VFS->exists(IncludeDir))
1619 Diag(diag::warn_missing_include_dirs) << IncludeDir;
1624 bool CCCPrintPhases;
1627 Args.ClaimAllArgs(options::OPT_canonical_prefixes);
1628 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
1631 Args.ClaimAllArgs(options::OPT_fintegrated_cc1);
1632 Args.ClaimAllArgs(options::OPT_fno_integrated_cc1);
1635 Args.ClaimAllArgs(options::OPT_pipe);
1643 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
1645 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
1646 CCCGenericGCCName = A->getValue();
1649 if (
const Arg *A = Args.getLastArg(options::OPT_fproc_stat_report_EQ)) {
1653 if (Args.hasArg(options::OPT_fproc_stat_report))
1660 llvm::Triple
T(TargetTriple);
1661 T.setOS(llvm::Triple::Win32);
1662 T.setVendor(llvm::Triple::PC);
1663 T.setEnvironment(llvm::Triple::MSVC);
1664 T.setObjectFormat(llvm::Triple::COFF);
1665 if (Args.hasArg(options::OPT__SLASH_arm64EC))
1666 T.setArch(llvm::Triple::aarch64, llvm::Triple::AArch64SubArch_arm64ec);
1667 TargetTriple =
T.str();
1670 if (
const Arg *A = Args.getLastArg(options::OPT_target_profile)) {
1671 StringRef TargetProfile = A->getValue();
1674 TargetTriple = *Triple;
1676 Diag(diag::err_drv_invalid_directx_shader_module) << TargetProfile;
1680 if (Args.hasArg(options::OPT_spirv)) {
1681 const llvm::StringMap<llvm::Triple::SubArchType> ValidTargets = {
1682 {
"vulkan1.2", llvm::Triple::SPIRVSubArch_v15},
1683 {
"vulkan1.3", llvm::Triple::SPIRVSubArch_v16}};
1684 llvm::Triple
T(TargetTriple);
1687 auto TargetInfo = ValidTargets.find(
"vulkan1.3");
1689 if (
const Arg *A = Args.getLastArg(options::OPT_fspv_target_env_EQ)) {
1690 TargetInfo = ValidTargets.find(A->getValue());
1692 Diag(diag::err_drv_invalid_value)
1693 << A->getAsString(Args) << A->getValue();
1699 T.setArch(llvm::Triple::spirv,
TargetInfo->getValue());
1700 TargetTriple =
T.str();
1704 Diag(diag::err_drv_dxc_missing_target_profile);
1708 if (
const Arg *A = Args.getLastArg(options::OPT_target))
1709 TargetTriple = A->getValue();
1710 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
1711 Dir = A->getValue();
1712 for (
const Arg *A : Args.filtered(options::OPT_B)) {
1716 if (std::optional<std::string> CompilerPathValue =
1717 llvm::sys::Process::GetEnv(
"COMPILER_PATH")) {
1718 StringRef CompilerPath = *CompilerPathValue;
1719 while (!CompilerPath.empty()) {
1720 std::pair<StringRef, StringRef> Split =
1721 CompilerPath.split(llvm::sys::EnvPathSeparator);
1722 PrefixDirs.push_back(std::string(Split.first));
1723 CompilerPath = Split.second;
1726 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1728 if (
const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
1731 if (
const Arg *A = Args.getLastArg(options::OPT_resource_dir))
1734 if (
const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
1735 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
1736 .Case(
"cwd", SaveTempsCwd)
1737 .Case(
"obj", SaveTempsObj)
1738 .Default(SaveTempsCwd);
1741 if (
const Arg *A = Args.getLastArg(options::OPT_offload_host_only,
1742 options::OPT_offload_device_only,
1743 options::OPT_offload_host_device)) {
1744 if (A->getOption().matches(options::OPT_offload_host_only))
1745 Offload = OffloadHost;
1746 else if (A->getOption().matches(options::OPT_offload_device_only))
1747 Offload = OffloadDevice;
1749 Offload = OffloadHostDevice;
1753 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
1754 StringRef
Name = A->getValue();
1755 unsigned Model = llvm::StringSwitch<unsigned>(
Name)
1756 .Case(
"off", EmbedNone)
1757 .Case(
"all", EmbedBitcode)
1758 .Case(
"bitcode", EmbedBitcode)
1759 .Case(
"marker", EmbedMarker)
1762 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1765 BitcodeEmbed =
static_cast<BitcodeEmbedMode
>(Model);
1769 if (Arg *A = Args.getLastArg(options::OPT_MJ))
1770 llvm::sys::fs::remove(A->getValue());
1776 const Arg *Std = Args.getLastArg(options::OPT_std_EQ);
1778 !Args.hasArg(options::OPT_fmodules) && Std &&
1779 (Std->containsValue(
"c++20") || Std->containsValue(
"c++2a") ||
1780 Std->containsValue(
"c++23") || Std->containsValue(
"c++2b") ||
1781 Std->containsValue(
"c++26") || Std->containsValue(
"c++2c") ||
1782 Std->containsValue(
"c++2d") || Std->containsValue(
"c++latest"));
1785 if (Arg *A = Args.getLastArg(options::OPT_fmodule_header_EQ,
1786 options::OPT_fmodule_header)) {
1788 ModulesModeCXX20 =
true;
1789 if (A->getOption().matches(options::OPT_fmodule_header))
1792 StringRef ArgName = A->getValue();
1793 unsigned Kind = llvm::StringSwitch<unsigned>(ArgName)
1798 Diags.Report(diag::err_drv_invalid_value)
1799 << A->getAsString(Args) << ArgName;
1805 std::unique_ptr<llvm::opt::InputArgList> UArgs =
1806 std::make_unique<InputArgList>(std::move(Args));
1816 llvm::map_range(MultilibMacroDefinesStr, [&UArgs](
const auto &S) {
1817 return UArgs->MakeArgString(Twine(
"-D") + Twine(S));
1819 bool MLContainsError;
1820 auto MultilibMacroDefineList =
1822 MLMacroDefinesChar,
false, MLContainsError));
1823 if (!MLContainsError) {
1824 for (
auto *Opt : *MultilibMacroDefineList) {
1831 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs, TC.
getTriple());
1835 if (!Triple.isWasm()) {
1836 StringRef TripleVersionName = Triple.getEnvironmentVersionString();
1837 StringRef TripleObjectFormat =
1838 Triple.getObjectFormatTypeName(Triple.getObjectFormat());
1839 if (Triple.getEnvironmentVersion().empty() && TripleVersionName !=
"" &&
1840 TripleVersionName != TripleObjectFormat) {
1841 Diags.Report(diag::err_drv_triple_version_invalid)
1843 ContainsError =
true;
1848 if ((TC.
getTriple().getArch() != llvm::Triple::aarch64 ||
1849 TC.
getTriple().getSubArch() != llvm::Triple::AArch64SubArch_arm64ec) &&
1850 UArgs->hasArg(options::OPT__SLASH_arm64EC)) {
1858 if (TC.
getTriple().getOS() == llvm::Triple::UnknownOS &&
1859 TC.
getTriple().getVendor() == llvm::Triple::UnknownVendor) {
1861 case llvm::Triple::arm:
1862 case llvm::Triple::armeb:
1863 case llvm::Triple::thumb:
1864 case llvm::Triple::thumbeb:
1865 if (TC.
getTriple().getEnvironmentName() ==
"elf") {
1866 Diag(diag::warn_target_unrecognized_env)
1868 << (TC.
getTriple().getArchName().str() +
"-none-eabi");
1871 case llvm::Triple::aarch64:
1872 case llvm::Triple::aarch64_be:
1873 case llvm::Triple::aarch64_32:
1874 if (TC.
getTriple().getEnvironmentName().starts_with(
"eabi")) {
1875 Diag(diag::warn_target_unrecognized_env)
1877 << (TC.
getTriple().getArchName().str() +
"-none-elf");
1894 BuildInputs(
C->getDefaultToolChain(), *TranslatedArgs, Inputs);
1895 if (HasConfigFileTail && Inputs.size()) {
1898 DerivedArgList TranslatedLinkerIns(*CfgOptionsTail);
1899 for (Arg *A : *CfgOptionsTail)
1900 TranslatedLinkerIns.append(A);
1901 BuildInputs(
C->getDefaultToolChain(), TranslatedLinkerIns, Inputs);
1908 bool UseModulesDriver =
C->getArgs().hasFlag(
1909 options::OPT_fmodules_driver, options::OPT_fno_modules_driver,
false);
1911 if (UseModulesDriver) {
1912 Diags.Report(diag::remark_performing_driver_managed_module_build);
1920 const auto StdModuleManifestPath =
1923 if (!llvm::sys::fs::exists(StdModuleManifestPath))
1924 Diags.Report(diag::remark_modules_manifest_not_found);
1926 Diags.Report(diag::remark_using_modules_manifest)
1927 << StdModuleManifestPath;
1928 if (
auto ManifestOrErr =
1930 ModulesManifest = std::move(*ManifestOrErr);
1932 llvm::erase_if(ModulesManifest.
Modules, [](
const auto &ModuleEntry) {
1933 return !ModuleEntry.IsStdlib;
1938 llvm::handleAllErrors(
1939 ManifestOrErr.takeError(),
1940 [&](llvm::json::ParseError &Err) {
1941 Diags.Report(diag::err_modules_manifest_failed_parse)
1944 [&](llvm::FileError &Err) {
1945 Diags.Report(diag::err_cannot_open_file)
1946 << Err.getFileName() << Err.messageWithoutFileInfo();
1954 if (TC.
getTriple().isOSBinFormatMachO())
1959 if (CCCPrintPhases) {
1966 if (UseModulesDriver)
1973 llvm::opt::ArgStringList ASL;
1974 for (
const auto *A : Args) {
1978 while (A->getAlias())
1980 A->render(Args, ASL);
1983 for (
auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
1984 if (I != ASL.begin())
1986 llvm::sys::printArg(OS, *I,
true);
1991bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename,
1992 SmallString<128> &CrashDiagDir) {
1993 using namespace llvm::sys;
1994 assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&
1995 "Only knows about .crash files on Darwin");
1997 auto BypassSandbox = sandbox::scopedDisable();
2002 path::home_directory(CrashDiagDir);
2003 if (CrashDiagDir.starts_with(
"/var/root"))
2005 path::append(CrashDiagDir,
"Library/Logs/DiagnosticReports");
2013 fs::file_status FileStatus;
2014 TimePoint<> LastAccessTime;
2015 SmallString<128> CrashFilePath;
2018 for (fs::directory_iterator
File(CrashDiagDir, EC), FileEnd;
2019 File != FileEnd && !EC;
File.increment(EC)) {
2023 if (fs::status(
File->path(), FileStatus))
2025 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
2026 llvm::MemoryBuffer::getFile(
File->path());
2031 StringRef
Data = CrashFile.get()->getBuffer();
2032 if (!
Data.starts_with(
"Process:"))
2035 size_t ParentProcPos =
Data.find(
"Parent Process:");
2036 if (ParentProcPos == StringRef::npos)
2038 size_t LineEnd =
Data.find_first_of(
"\n", ParentProcPos);
2039 if (LineEnd == StringRef::npos)
2041 StringRef ParentProcess =
Data.slice(ParentProcPos+15, LineEnd).trim();
2042 int OpenBracket = -1, CloseBracket = -1;
2043 for (
size_t i = 0, e = ParentProcess.size(); i < e; ++i) {
2044 if (ParentProcess[i] ==
'[')
2046 if (ParentProcess[i] ==
']')
2052 if (OpenBracket < 0 || CloseBracket < 0 ||
2053 ParentProcess.slice(OpenBracket + 1, CloseBracket)
2054 .getAsInteger(10, CrashPID) || CrashPID != PID) {
2064 const auto FileAccessTime = FileStatus.getLastModificationTime();
2065 if (FileAccessTime > LastAccessTime) {
2066 CrashFilePath.assign(
File->path());
2067 LastAccessTime = FileAccessTime;
2072 if (!CrashFilePath.empty()) {
2073 EC = fs::copy_file(CrashFilePath, ReproCrashFilename);
2083 "\n********************\n\n"
2084 "PLEASE ATTACH THE FOLLOWING CRASH REPRODUCER FILES TO THE BUG REPORT:";
2092 if (
C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
2095 bool HasCrashTar =
C.getArgs().hasArg(options::OPT_fcrash_diagnostics_tar);
2098 if (Arg *A =
C.getArgs().getLastArg(options::OPT_fcrash_diagnostics_EQ)) {
2099 Level = llvm::StringSwitch<unsigned>(A->getValue())
2101 .Case(
"compiler", 1)
2113 ArgStringList SavedTemps;
2115 C.getDefaultToolChain().GetLinkerPath(&IsLLD);
2116 if (!IsLLD || Level < 2)
2123 SavedTemps = std::move(
C.getTempFiles());
2124 assert(!
C.getTempFiles().size());
2141 C.initCompilationForDiagnostics();
2146 Command NewLLDInvocation = Cmd;
2147 llvm::opt::ArgStringList ArgList = NewLLDInvocation.
getArguments();
2148 StringRef ReproduceOption =
2149 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment()
2152 ArgList.push_back(Saver.save(Twine(ReproduceOption) + TmpName).data());
2156 NewLLDInvocation.
Execute({std::nullopt, {
""}, {
""}},
nullptr,
nullptr);
2158 Diag(clang::diag::note_drv_command_failed_diag_msg) << TmpName;
2159 Diag(clang::diag::note_drv_command_failed_diag_msg)
2160 <<
"\n\n********************";
2162 Report->TemporaryFiles.push_back(TmpName);
2170 ArgStringList IRInputs;
2171 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
2172 bool IgnoreInput =
false;
2178 IRInputs.push_back(it->second->getValue());
2182 }
else if (!strcmp(it->second->getValue(),
"-")) {
2183 Diag(clang::diag::note_drv_command_failed_diag_msg)
2184 <<
"Error generating preprocessed source(s) - "
2185 "ignoring input from stdin.";
2190 it = Inputs.erase(it);
2197 if (Inputs.empty() && IRInputs.empty()) {
2198 Diag(clang::diag::note_drv_command_failed_diag_msg)
2199 <<
"Error generating preprocessed source(s) - "
2200 "no preprocessable inputs.";
2206 llvm::StringSet<> ArchNames;
2207 for (
const Arg *A :
C.getArgs()) {
2208 if (A->getOption().matches(options::OPT_arch)) {
2209 StringRef ArchName = A->getValue();
2210 ArchNames.insert(ArchName);
2213 if (ArchNames.size() > 1) {
2216 if (FailingArch.empty()) {
2217 Diag(clang::diag::note_drv_command_failed_diag_msg)
2218 <<
"Error generating preprocessed source(s) - cannot generate "
2219 "preprocessed source with multiple -arch options.";
2222 C.getArgs().eraseArg(options::OPT_arch);
2223 C.getArgs().AddJoinedArg(
nullptr,
getOpts().getOption(options::OPT_arch),
2228 if (!Inputs.empty()) {
2231 const ToolChain &TC =
C.getDefaultToolChain();
2232 if (TC.
getTriple().isOSBinFormatMachO())
2241 Diag(clang::diag::note_drv_command_failed_diag_msg)
2242 <<
"Error generating preprocessed source(s).";
2247 C.ExecuteJobs(
C.getJobs(), FailingCommands);
2250 if (!FailingCommands.empty()) {
2251 Diag(clang::diag::note_drv_command_failed_diag_msg)
2252 <<
"Error generating preprocessed source(s).";
2256 const ArgStringList &TempFiles =
C.getTempFiles();
2257 if (TempFiles.empty()) {
2258 Diag(clang::diag::note_drv_command_failed_diag_msg)
2259 <<
"Error generating preprocessed source(s).";
2265 const ArgStringList &Files =
C.getTempFiles();
2270 for (
auto const *Input : IRInputs) {
2274 StringRef extension = llvm::sys::path::extension(Input);
2275 if (!extension.empty())
2276 extension = extension.drop_front();
2278 std::error_code EC = llvm::sys::fs::createTemporaryFile(
2279 llvm::sys::path::stem(Input), extension, FD, Path);
2281 Diag(clang::diag::note_drv_command_failed_diag_msg)
2282 <<
"Error generating run script: " <<
"Failed copying IR input files"
2283 <<
" " << EC.message();
2287 EC = llvm::sys::fs::copy_file(Input, FD);
2289 Diag(clang::diag::note_drv_command_failed_diag_msg)
2290 <<
"Error generating run script: " <<
"Failed copying IR input files"
2291 <<
" " << EC.message();
2295 TempFiles.push_back(std::string(Path.begin(), Path.end()));
2302 for (std::string &TempFile : TempFiles) {
2304 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
2306 Report->TemporaryFiles.push_back(TempFile);
2307 if (ReproCrashFilename.empty()) {
2308 ReproCrashFilename = TempFile;
2309 llvm::sys::path::replace_extension(ReproCrashFilename,
".crash");
2311 if (StringRef(TempFile).ends_with(
".cache")) {
2314 VFS = llvm::sys::path::filename(TempFile);
2315 llvm::sys::path::append(VFS,
"vfs",
"vfs.yaml");
2319 for (
const char *TempFile : SavedTemps)
2320 TempFiles.push_back(TempFile);
2326 llvm::sys::path::replace_extension(Script,
"sh");
2328 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::CD_CreateNew,
2329 llvm::sys::fs::FA_Write,
2330 llvm::sys::fs::OF_Text);
2332 Diag(clang::diag::note_drv_command_failed_diag_msg)
2333 <<
"Error generating run script: " << Script <<
" " << EC.message();
2336 <<
"# Driver args: ";
2338 ScriptOS <<
"# Original command: ";
2339 Cmd.
Print(ScriptOS,
"\n",
true);
2340 Cmd.
Print(ScriptOS,
"\n",
true, &CrashInfo);
2341 if (!AdditionalInformation.empty())
2342 ScriptOS <<
"\n# Additional information: " << AdditionalInformation
2345 Report->TemporaryFiles.push_back(std::string(Script));
2346 TempFiles.push_back(std::string(Script));
2349 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
2352 if (Arg *A =
C.getArgs().getLastArg(options::OPT_fcrash_diagnostics_tar)) {
2353 StringRef CrashDiagnosticsTar = A->getValue();
2355 llvm::TarWriter::create(CrashDiagnosticsTar,
2356 llvm::sys::path::stem(CrashDiagnosticsTar));
2358 Diag(clang::diag::note_drv_command_failed_diag_msg)
2359 << (std::string(
"Error creating reproducer tarball: ") +
2360 llvm::toString(TarOrErr.takeError()));
2362 std::unique_ptr<llvm::TarWriter> &Tar = *TarOrErr;
2363 for (
const std::string &TempFile : TempFiles) {
2364 if (llvm::sys::fs::is_directory(TempFile)) {
2366 for (llvm::sys::fs::recursive_directory_iterator I(TempFile, EC), E;
2367 I != E && !EC; I.increment(EC)) {
2368 if (llvm::sys::fs::is_regular_file(I->path())) {
2369 auto BufferOrErr = llvm::MemoryBuffer::getFile(I->path());
2373 llvm::sys::path::filename(TempFile);
2374 StringRef SubPath = I->path();
2375 if (SubPath.consume_front(TempFile)) {
2376 if (!SubPath.empty() &&
2377 llvm::sys::path::is_separator(SubPath.front())) {
2378 SubPath = SubPath.drop_front();
2380 llvm::sys::path::append(PathInTar, SubPath);
2381 Tar->append(PathInTar, (*BufferOrErr)->getBuffer());
2384 Diag(clang::diag::note_drv_command_failed_diag_msg)
2385 << (std::string(
"Error reading file for tarball: ") +
2391 Diag(clang::diag::note_drv_command_failed_diag_msg)
2392 << (std::string(
"Error iterating directory for tarball: ") +
2393 TempFile +
" " + EC.message());
2396 auto BufferOrErr = llvm::MemoryBuffer::getFile(TempFile);
2398 Tar->append(llvm::sys::path::filename(TempFile),
2399 (*BufferOrErr)->getBuffer());
2401 Diag(clang::diag::note_drv_command_failed_diag_msg)
2402 << (std::string(
"Error reading file for tarball: ") + TempFile);
2406 Diag(clang::diag::note_drv_command_failed_diag_msg)
2407 << CrashDiagnosticsTar;
2412 if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) {
2414 if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) {
2415 Diag(clang::diag::note_drv_command_failed_diag_msg)
2416 << ReproCrashFilename.str();
2418 llvm::sys::path::append(CrashDiagDir,
Name);
2419 CrashDiagDir +=
"_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
2420 Diag(clang::diag::note_drv_command_failed_diag_msg)
2421 <<
"Crash backtrace is located in";
2422 Diag(clang::diag::note_drv_command_failed_diag_msg)
2423 << CrashDiagDir.str();
2424 Diag(clang::diag::note_drv_command_failed_diag_msg)
2425 <<
"(choose the .crash file that corresponds to your crash)";
2429 Diag(clang::diag::note_drv_command_failed_diag_msg)
2430 <<
"\n\n********************";
2440 llvm::sys::commandLineFitsWithinSystemLimits(Cmd.
getExecutable(),
2451 if (
C.getArgs().hasArg(options::OPT_fdriver_only)) {
2452 if (
C.getArgs().hasArg(options::OPT_v))
2453 C.getJobs().Print(llvm::errs(),
"\n",
true);
2455 C.ExecuteJobs(
C.getJobs(), FailingCommands,
true);
2458 if (!FailingCommands.empty() || Diags.hasErrorOccurred())
2465 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
2466 C.getJobs().Print(llvm::errs(),
"\n",
true);
2467 return Diags.hasErrorOccurred() ? 1 : 0;
2471 if (Diags.hasErrorOccurred())
2475 for (
auto &Job :
C.getJobs())
2476 setUpResponseFiles(
C, Job);
2478 C.ExecuteJobs(
C.getJobs(), FailingCommands);
2481 if (FailingCommands.empty())
2487 for (
const auto &CmdPair : FailingCommands) {
2488 int CommandRes = CmdPair.first;
2489 const Command *FailingCommand = CmdPair.second;
2494 C.CleanupFileMap(
C.getResultFiles(), JA,
true);
2498 C.CleanupFileMap(
C.getFailureResultFiles(), JA,
true);
2503 if (CommandRes == EX_IOERR) {
2523 if (CommandRes > 128 && CommandRes != 255)
2527 Diag(clang::diag::err_drv_command_signalled)
2530 Diag(clang::diag::err_drv_command_failed)
2538 llvm::opt::Visibility VisibilityMask = getOptionVisibilityMask();
2540 std::string Usage = llvm::formatv(
"{0} [options] file...",
Name).str();
2554 const ToolChain &TC =
C.getDefaultToolChain();
2558 if (Arg *A =
C.getArgs().getLastArg(options::OPT_mthread_model)) {
2561 OS <<
"Thread model: " << A->getValue();
2567 OS <<
"InstalledDir: " <<
Dir <<
'\n';
2572 if (!llvm::cl::getCompilerBuildConfig().empty())
2573 llvm::cl::printBuildConfig(OS);
2576 for (
auto ConfigFile : ConfigFiles)
2577 OS <<
"Configuration file: " << ConfigFile <<
'\n';
2590 if (PassedFlags ==
"")
2594 std::vector<std::string> SuggestedCompletions;
2595 std::vector<std::string> Flags;
2607 const bool HasSpace = PassedFlags.ends_with(
",");
2611 StringRef TargetFlags = PassedFlags;
2612 while (TargetFlags !=
"") {
2614 std::tie(CurFlag, TargetFlags) = TargetFlags.split(
",");
2615 Flags.push_back(std::string(CurFlag));
2620 if (llvm::is_contained(Flags,
"-Xclang") || llvm::is_contained(Flags,
"-cc1"))
2623 const llvm::opt::OptTable &Opts =
getOpts();
2625 Cur = Flags.at(Flags.size() - 1);
2627 if (Flags.size() >= 2) {
2628 Prev = Flags.at(Flags.size() - 2);
2629 SuggestedCompletions = Opts.suggestValueCompletions(Prev, Cur);
2632 if (SuggestedCompletions.empty())
2633 SuggestedCompletions = Opts.suggestValueCompletions(Cur,
"");
2640 if (SuggestedCompletions.empty() && HasSpace && !Flags.empty()) {
2641 llvm::outs() <<
'\n';
2647 if (SuggestedCompletions.empty() && !Cur.ends_with(
"=")) {
2651 SuggestedCompletions = Opts.findByPrefix(
2652 Cur, VisibilityMask,
2659 if (S.starts_with(Cur))
2660 SuggestedCompletions.push_back(std::string(S));
2667 llvm::sort(SuggestedCompletions, [](StringRef A, StringRef B) {
2668 if (
int X = A.compare_insensitive(B))
2670 return A.compare(B) > 0;
2673 llvm::outs() << llvm::join(SuggestedCompletions,
"\n") <<
'\n';
2680 if (
C.getArgs().hasArg(options::OPT_dumpmachine)) {
2681 llvm::outs() <<
C.getDefaultToolChain().getTripleString() <<
'\n';
2685 if (
C.getArgs().hasArg(options::OPT_dumpversion)) {
2688 llvm::outs() << CLANG_VERSION_STRING <<
"\n";
2692 if (
C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
2697 if (
C.getArgs().hasArg(options::OPT_help) ||
2698 C.getArgs().hasArg(options::OPT__help_hidden)) {
2699 PrintHelp(
C.getArgs().hasArg(options::OPT__help_hidden));
2703 if (
C.getArgs().hasArg(options::OPT__version)) {
2710 bool ListExtractors =
C.getArgs().hasArg(options::OPT__ssaf_list_extractors);
2711 bool ListFormats =
C.getArgs().hasArg(options::OPT__ssaf_list_formats);
2712 if (ListExtractors || ListFormats) {
2720 if (
C.getArgs().hasArg(options::OPT__ssaf_list_formats)) {
2725 if (
C.getArgs().hasArg(options::OPT_v) ||
2726 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
2727 C.getArgs().hasArg(options::OPT_print_supported_cpus) ||
2728 C.getArgs().hasArg(options::OPT_print_supported_tune_cpus) ||
2729 C.getArgs().hasArg(options::OPT_print_supported_extensions) ||
2730 C.getArgs().hasArg(options::OPT_print_enabled_extensions)) {
2732 SuppressMissingInputWarning =
true;
2735 if (
C.getArgs().hasArg(options::OPT_v)) {
2737 llvm::errs() <<
"System configuration file directory: "
2740 llvm::errs() <<
"User configuration file directory: "
2744 const ToolChain &TC =
C.getDefaultToolChain();
2746 if (
C.getArgs().hasArg(options::OPT_v))
2749 if (
C.getArgs().hasArg(options::OPT_print_resource_dir)) {
2754 if (
C.getArgs().hasArg(options::OPT_print_search_dirs)) {
2755 llvm::outs() <<
"programs: =";
2756 bool separator =
false;
2760 llvm::outs() << llvm::sys::EnvPathSeparator;
2761 llvm::outs() << Path;
2766 llvm::outs() << llvm::sys::EnvPathSeparator;
2767 llvm::outs() << Path;
2770 llvm::outs() <<
"\n";
2773 StringRef sysroot =
C.getSysRoot();
2777 llvm::outs() << llvm::sys::EnvPathSeparator;
2780 llvm::outs() << sysroot << Path.substr(1);
2782 llvm::outs() << Path;
2784 llvm::outs() <<
"\n";
2788 if (
C.getArgs().hasArg(options::OPT_print_cxx_stdlib)) {
2793 if (
C.getArgs().hasArg(options::OPT_print_cxx_stdlib_include_dirs)) {
2798 if (
C.getArgs().hasArg(options::OPT_print_std_module_manifest_path)) {
2804 if (
C.getArgs().hasArg(options::OPT_print_runtime_dir)) {
2805 for (
auto RuntimePath :
2807 if (RuntimePath &&
getVFS().exists(*RuntimePath)) {
2808 llvm::outs() << *RuntimePath <<
'\n';
2812 llvm::outs() <<
"(runtime dir is not present)" <<
'\n';
2816 if (
C.getArgs().hasArg(options::OPT_print_diagnostic_options)) {
2818 for (std::size_t I = 0; I != Flags.size(); I += 2)
2819 llvm::outs() <<
" " << Flags[I] <<
"\n " << Flags[I + 1] <<
"\n\n";
2825 if (Arg *A =
C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
2826 llvm::outs() <<
GetFilePath(A->getValue(), TC) <<
"\n";
2830 if (Arg *A =
C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
2831 StringRef ProgName = A->getValue();
2834 if (! ProgName.empty())
2837 llvm::outs() <<
"\n";
2841 if (Arg *A =
C.getArgs().getLastArg(options::OPT_autocomplete)) {
2842 StringRef PassedFlags = A->getValue();
2847 if (
C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
2857 C.getArgsForToolChain(&TC,
BoundArch(Triple.getArchName()),
2862 llvm::outs() << TC.
getCompilerRT(
C.getArgs(),
"builtins") <<
"\n";
2865 llvm::outs() <<
GetFilePath(
"libgcc.a", TC) <<
"\n";
2871 if (
C.getArgs().hasArg(options::OPT_print_multi_lib)) {
2878 if (
C.getArgs().hasArg(options::OPT_print_multi_flags)) {
2881 std::set<llvm::StringRef> SortedFlags;
2882 for (
const auto &FlagEntry : ExpandedFlags)
2883 SortedFlags.insert(FlagEntry.getKey());
2884 for (
auto Flag : SortedFlags)
2885 llvm::outs() << Flag <<
'\n';
2889 if (
C.getArgs().hasArg(options::OPT_print_multi_directory)) {
2892 llvm::outs() <<
".\n";
2895 assert(Suffix.front() ==
'/');
2896 llvm::outs() << Suffix.substr(1) <<
"\n";
2902 if (
C.getArgs().hasArg(options::OPT_print_target_triple)) {
2907 if (
C.getArgs().hasArg(options::OPT_print_effective_triple)) {
2909 llvm::outs() << Triple.getTriple() <<
"\n";
2913 if (
C.getArgs().hasArg(options::OPT_print_targets)) {
2914 llvm::TargetRegistry::printRegisteredTargetsForVersion(llvm::outs());
2931 std::map<Action *, unsigned> &Ids,
2933 if (
auto It = Ids.find(A); It != Ids.end())
2937 llvm::raw_string_ostream os(str);
2939 auto getSibIndent = [](
int K) -> Twine {
2943 Twine SibIndent =
Indent + getSibIndent(Kind);
2947 os <<
"\"" << IA->getInputArg().getValue() <<
"\"";
2949 os <<
'"' << BIA->getArch().ArchName <<
'"' <<
", {"
2950 <<
PrintActions1(
C, *BIA->input_begin(), Ids, SibIndent, SibKind) <<
"}";
2951 }
else if (
OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
2953 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC, BoundArch BA) {
2954 assert(TC &&
"Unknown host toolchain");
2969 os <<
" {" <<
PrintActions1(
C, A, Ids, SibIndent, SibKind) <<
"}";
2977 const char *Prefix =
"{";
2978 for (
Action *PreRequisite : *AL) {
2979 os << Prefix <<
PrintActions1(
C, PreRequisite, Ids, SibIndent, SibKind);
2990 std::string offload_str;
2991 llvm::raw_string_ostream offload_os(offload_str);
2995 offload_os <<
", (" << S;
3002 auto getSelfIndent = [](
int K) -> Twine {
3006 unsigned Id = Ids.size();
3008 llvm::errs() <<
Indent + getSelfIndent(Kind) << Id <<
": " << os.str() <<
", "
3017 std::map<Action *, unsigned> Ids;
3018 for (
Action *A :
C.getActions())
3034 DerivedArgList &Args =
C.getArgs();
3036 llvm::PrettyStackTraceString CrashInfo(
"Building universal build actions");
3039 llvm::StringSet<> ArchNames;
3041 for (Arg *A : Args) {
3042 if (A->getOption().matches(options::OPT_arch)) {
3045 llvm::Triple::ArchType
Arch =
3047 if (
Arch == llvm::Triple::UnknownArch) {
3048 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
3053 if (ArchNames.insert(A->getValue()).second)
3054 Archs.push_back(A->getValue());
3068 for (
Action* Act : SingleActions) {
3076 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
3080 for (
unsigned i = 0, e = Archs.size(); i != e; ++i)
3085 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
3086 Actions.append(Inputs.begin(), Inputs.end());
3088 Actions.push_back(
C.MakeAction<
LipoJobAction>(Inputs, Act->getType()));
3091 Arg *A = Args.getLastArg(options::OPT_g_Group);
3092 bool enablesDebugInfo = A && !A->getOption().matches(options::OPT_g0) &&
3093 !A->getOption().matches(options::OPT_gstabs);
3094 bool enablesPseudoProbe =
3095 Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
3096 options::OPT_fno_pseudo_probe_for_profiling,
false);
3097 bool enablesDebugInfoForProfiling =
3098 Args.hasFlag(options::OPT_fdebug_info_for_profiling,
3099 options::OPT_fno_debug_info_for_profiling,
false);
3100 if ((enablesDebugInfo ||
willEmitRemarks(Args) || enablesPseudoProbe ||
3101 enablesDebugInfoForProfiling) &&
3109 if (Act->getType() == types::TY_Image) {
3111 Inputs.push_back(Actions.back());
3118 if (Args.hasArg(options::OPT_verify_debug_info)) {
3119 Action *LastAction = Actions.pop_back_val();
3121 LastAction, types::TY_Nothing));
3128 bool TypoCorrect)
const {
3140 if (Ty == types::TY_CXXSHeader || Ty == types::TY_CXXUHeader ||
3141 (ModulesModeCXX20 && Ty == types::TY_CXXHeader))
3153 std::string Nearest;
3154 if (
getOpts().findNearest(
Value, Nearest, getOptionVisibilityMask()) <= 1) {
3155 Diag(clang::diag::err_drv_no_such_file_with_suggestion)
3156 <<
Value << Nearest;
3195 if (
IsCLMode() && Ty == types::TY_Object && !
Value.starts_with(
"/"))
3198 Diag(clang::diag::err_drv_no_such_file) <<
Value;
3206 return types::TY_CXXUHeader;
3208 return types::TY_CXXSHeader;
3212 llvm_unreachable(
"should not be called in this case");
3214 return types::TY_CXXHUHeader;
3220 const llvm::opt::OptTable &Opts =
getOpts();
3224 types::ID InputType = types::TY_Nothing;
3225 Arg *InputTypeArg =
nullptr;
3228 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
3229 options::OPT__SLASH_TP)) {
3230 InputTypeArg = TCTP;
3231 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
3236 bool ShowNote =
false;
3238 Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) {
3240 Diag(clang::diag::warn_drv_overriding_option)
3241 <<
Previous->getSpelling() << A->getSpelling();
3247 Diag(clang::diag::note_drv_t_option_is_global);
3252 Arg *LastXArg = Args.getLastArgNoClaim(options::OPT_x);
3253 Arg *LastInputArg = Args.getLastArgNoClaim(options::OPT_INPUT);
3254 if (LastXArg && LastInputArg &&
3255 LastInputArg->getIndex() < LastXArg->getIndex())
3256 Diag(clang::diag::warn_drv_unused_x) << LastXArg->getValue();
3259 bool IsSYCL = Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false);
3261 for (Arg *A : Args) {
3262 if (A->getOption().
getKind() == Option::InputClass) {
3263 const char *
Value = A->getValue();
3267 if (InputType == types::TY_Nothing) {
3270 InputTypeArg->claim();
3273 if (strcmp(
Value,
"-") == 0) {
3275 Ty = types::TY_Fortran;
3277 Ty = types::TY_HLSL;
3278 }
else if (IsSYCL) {
3288 if (!Args.hasArgNoClaim(options::OPT_E) && !
CCCIsCPP())
3289 Diag(
IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
3290 : clang::diag::err_drv_unknown_stdin_type);
3299 if (
const char *Ext = strrchr(
Value,
'.'))
3308 Ty = types::TY_HLSL;
3310 Ty = types::TY_Object;
3321 if (Ty != OldTy && !(OldTy == types::TY_CHeader &&
hasHeaderMode()))
3322 Diag(clang::diag::warn_drv_treating_input_as_cxx)
3323 << getTypeName(OldTy) << getTypeName(Ty);
3328 if (Args.hasArgNoClaim(options::OPT_fthinlto_index_EQ) &&
3329 Ty == types::TY_Object)
3330 Ty = types::TY_LLVM_BC;
3338 if (Ty != types::TY_Object) {
3339 if (Args.hasArg(options::OPT_ObjC))
3340 Ty = types::TY_ObjC;
3341 else if (Args.hasArg(options::OPT_ObjCXX))
3342 Ty = types::TY_ObjCXX;
3349 if ((Ty == types::TY_CXXHeader || Ty == types::TY_CHeader) &&
3353 assert(InputTypeArg &&
"InputType set w/o InputTypeArg");
3354 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
3357 const char *Ext = strrchr(
Value,
'.');
3359 Ty = types::TY_Object;
3363 InputTypeArg->claim();
3367 if ((Ty == types::TY_C || Ty == types::TY_CXX) &&
3368 Args.hasArgNoClaim(options::OPT_hipstdpar))
3372 Inputs.push_back(std::make_pair(Ty, A));
3374 }
else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
3375 StringRef
Value = A->getValue();
3378 Arg *InputArg =
makeInputArg(Args, Opts, A->getValue());
3379 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
3382 }
else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
3383 StringRef
Value = A->getValue();
3386 Arg *InputArg =
makeInputArg(Args, Opts, A->getValue());
3387 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
3393 Inputs.push_back(std::make_pair(types::TY_Object, A));
3395 }
else if (A->getOption().matches(options::OPT_x)) {
3404 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
3405 InputType = types::TY_Object;
3412 }
else if (A->getOption().getID() == options::OPT_U) {
3413 assert(A->getNumValues() == 1 &&
"The /U option has one value.");
3414 StringRef Val = A->getValue(0);
3415 if (Val.find_first_of(
"/\\") != StringRef::npos) {
3417 Diag(diag::warn_slash_u_filename) << Val;
3418 Diag(diag::note_use_dashdash);
3422 if (
CCCIsCPP() && Inputs.empty()) {
3426 Inputs.push_back(std::make_pair(types::TY_C, A));
3430void Driver::handleArguments(
Compilation &
C, DerivedArgList &Args,
3435 if (Arg *FoArg = Args.getLastArg(options::OPT__SLASH_Fo),
3436 *FaArg = Args.getLastArg(options::OPT__SLASH_Fa);
3439 unsigned NumCompiledInputs = llvm::count_if(
3440 Inputs, [](
const InputTy &I) {
return I.first != types::TY_Object; });
3442 for (Arg *A : {FoArg, FaArg}) {
3445 StringRef
V = A->getValue();
3446 if (NumCompiledInputs > 1 && !
V.empty() &&
3447 !llvm::sys::path::is_separator(
V.back())) {
3449 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
3450 << A->getSpelling() <<
V;
3451 Args.eraseArg(A->getOption().getID());
3457 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
3458 if (A->getValue()[0] ==
'\0') {
3460 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
3461 Args.eraseArg(options::OPT__SLASH_o);
3466 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
3467 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
3468 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
3469 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
3470 Args.eraseArg(options::OPT__SLASH_Yc);
3471 Args.eraseArg(options::OPT__SLASH_Yu);
3472 YcArg = YuArg =
nullptr;
3474 if (YcArg && Inputs.size() > 1) {
3475 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
3476 Args.eraseArg(options::OPT__SLASH_Yc);
3484 if (Args.hasArgNoClaim(options::OPT_hipstdpar)) {
3485 Args.AddFlagArg(
nullptr,
getOpts().getOption(options::OPT_hip_link));
3486 Args.AddFlagArg(
nullptr,
3487 getOpts().getOption(options::OPT_frtlib_add_rpath));
3491 if (Args.hasArg(options::OPT_emit_llvm) &&
3492 !Args.hasArg(options::OPT_hip_link) &&
3493 !
C.getDefaultToolChain().getTriple().isSPIRV())
3494 Diag(clang::diag::err_drv_emit_llvm_link);
3495 if (
C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment() &&
3496 C.getDefaultToolChain().isUsingLTO(Args) &&
3497 !Args.getLastArgValue(options::OPT_fuse_ld_EQ)
3498 .starts_with_insensitive(
"lld"))
3499 Diag(clang::diag::err_drv_lto_without_lld);
3505 if (!Args.hasArg(options::OPT_dumpdir)) {
3506 Arg *FinalOutput = Args.getLastArg(options::OPT_o, options::OPT__SLASH_o);
3507 Arg *Arg = Args.MakeSeparateArg(
3508 nullptr,
getOpts().getOption(options::OPT_dumpdir),
3510 (FinalOutput ? FinalOutput->getValue()
3522 Args.eraseArg(options::OPT__SLASH_Fp);
3523 Args.eraseArg(options::OPT__SLASH_Yc);
3524 Args.eraseArg(options::OPT__SLASH_Yu);
3525 YcArg = YuArg =
nullptr;
3528 if (Args.hasArg(options::OPT_include_pch) &&
3529 Args.hasArg(options::OPT_ignore_pch)) {
3533 Args.eraseArg(options::OPT_include_pch);
3536 bool LinkOnly =
phases::Link == FinalPhase && Inputs.size() > 0;
3537 for (
auto &I : Inputs) {
3539 const Arg *InputArg = I.second;
3544 LinkOnly = LinkOnly &&
phases::Link == InitialPhase && PL.size() == 1;
3548 if (InitialPhase > FinalPhase) {
3549 if (InputArg->isClaimed())
3556 if (Args.hasArg(options::OPT_Qunused_arguments))
3562 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
3563 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase);
3567 (Args.getLastArg(options::OPT__SLASH_EP,
3568 options::OPT__SLASH_P) ||
3569 Args.getLastArg(options::OPT_E) ||
3570 Args.getLastArg(options::OPT_M, options::OPT_MM)) &&
3572 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
3573 << InputArg->getAsString(Args) << !FinalPhaseArg
3574 << (FinalPhaseArg ? FinalPhaseArg->getSpelling() :
"");
3576 Diag(clang::diag::warn_drv_input_file_unused)
3577 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase)
3579 << (FinalPhaseArg ? FinalPhaseArg->getSpelling() :
"");
3588 Action *ClangClPch =
C.MakeAction<InputAction>(*InputArg,
HeaderType);
3589 auto HostLTO =
C.getDefaultToolChain().getLTOMode(Args);
3594 Actions.push_back(ClangClPch);
3606 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
3607 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
3615 const llvm::opt::DerivedArgList &Args,
3618 !Args.hasArg(options::OPT_S) || Args.hasArg(options::OPT_emit_llvm) ||
3620 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false))
3623 bool HasAMDGCNHIPDevice =
false;
3625 for (
auto It = HIPTCs.first; It != HIPTCs.second; ++It) {
3627 const llvm::Triple &Tr = TC->
getTriple();
3630 HasAMDGCNHIPDevice =
true;
3632 return HasAMDGCNHIPDevice;
3637 llvm::PrettyStackTraceString CrashInfo(
"Building compilation actions");
3639 if (!SuppressMissingInputWarning && Inputs.empty()) {
3640 Diag(clang::diag::err_drv_no_input_files);
3644 handleArguments(
C, Args, Inputs, Actions);
3649 if (Arg *A = Args.getLastArg(options::OPT_no_offload_new_driver))
3650 Diag(clang::diag::warn_drv_deprecated_custom)
3651 << A->getAsString(Args)
3652 <<
"the legacy offloading driver has been removed";
3653 Args.ClaimAllArgs(options::OPT_no_offload_new_driver);
3654 Args.ClaimAllArgs(options::OPT_offload_new_driver);
3656 bool HIPRDCDeviceOnlyFatBin =
3658 Args.hasArg(options::OPT_hip_link) &&
3659 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false) &&
3661 !Args.hasArg(options::OPT_emit_llvm) &&
3662 Args.hasFlag(options::OPT_gpu_bundle_output,
3663 options::OPT_no_gpu_bundle_output,
true);
3670 for (
auto &I : Inputs) {
3672 const Arg *InputArg = I.second;
3684 if (HIPRDCDeviceOnlyFatBin && InputType == types::TY_LLVM_BC) {
3685 LinkerInputs.push_back(Current);
3691 CUID = CUIDOpts.getCUID(InputArg->getValue(), Args);
3703 assert(Phase == PL.back() &&
"linking must be final compilation step.");
3706 if (!(
C.getInputArgs().hasArg(options::OPT_hip_link) &&
3707 (
C.getInputArgs().hasArg(options::OPT_emit_llvm))) &&
3709 LinkerInputs.push_back(Current);
3719 assert(Phase == PL.back() &&
"merging must be final compilation step.");
3720 MergerInputs.push_back(Current);
3737 C.getDefaultToolChain().getLTOMode(Args));
3740 if (NewCurrent == Current)
3743 if (
auto *EAA = dyn_cast<ExtractAPIJobAction>(NewCurrent))
3746 Current = NewCurrent;
3751 &HIPAsmDeviceActions);
3753 if (Current->
getType() == types::TY_Nothing)
3759 if (Current && !HIPAsmDeviceActions.empty()) {
3761 BundleInputs.append(HIPAsmDeviceActions);
3762 BundleInputs.push_back(Current);
3768 Actions.push_back(Current);
3775 if (!LinkerInputs.empty()) {
3781 Args.hasArg(options::OPT_offload_link)) {
3784 HIPRDCDeviceOnlyFatBin ? types::TY_HIP_FATBIN : types::TY_Image);
3791 bool LinkingIR = Args.hasArg(options::OPT_emit_llvm) &&
3792 C.getDefaultToolChain().getTriple().isSPIRV();
3793 types::ID LT = LinkingIR && !Diags.hasErrorOccurred() ? types::TY_LLVM_BC
3797 Actions.push_back(LA);
3801 if (!MergerInputs.empty())
3805 if (Args.hasArg(options::OPT_emit_interface_stubs)) {
3812 for (
auto &I : Inputs) {
3814 const Arg *InputArg = I.second;
3819 if (InputType == types::TY_IFS || InputType == types::TY_PP_Asm ||
3820 InputType == types::TY_Asm)
3825 for (
auto Phase : PhaseList) {
3829 "IFS Pipeline can only consist of Compile followed by IfsMerge.");
3834 if (InputType == types::TY_Object)
3841 assert(Phase == PhaseList.back() &&
3842 "merging must be final compilation step.");
3843 MergerInputs.push_back(Current);
3852 Actions.push_back(Current);
3856 if (!MergerInputs.empty())
3861 for (
auto Opt : {options::OPT_print_supported_cpus,
3862 options::OPT_print_supported_tune_cpus,
3863 options::OPT_print_supported_extensions,
3864 options::OPT_print_enabled_extensions}) {
3871 if (Arg *A = Args.getLastArg(Opt)) {
3872 if (Opt == options::OPT_print_supported_extensions &&
3873 !
C.getDefaultToolChain().getTriple().isRISCV() &&
3874 !
C.getDefaultToolChain().getTriple().isAArch64() &&
3875 !
C.getDefaultToolChain().getTriple().isARM()) {
3876 C.getDriver().Diag(diag::err_opt_not_valid_on_target)
3877 <<
"--print-supported-extensions";
3880 if (Opt == options::OPT_print_enabled_extensions &&
3881 !
C.getDefaultToolChain().getTriple().isRISCV() &&
3882 !
C.getDefaultToolChain().getTriple().isAArch64()) {
3883 C.getDriver().Diag(diag::err_opt_not_valid_on_target)
3884 <<
"--print-enabled-extensions";
3891 *A,
IsFlangMode() ? types::TY_Fortran : types::TY_C);
3894 for (
auto &I : Inputs)
3899 llvm::Triple TargetTriple(
C.getDriver().getTargetTriple());
3900 if (TargetTriple.getOS() == llvm::Triple::Vulkan ||
3901 TargetTriple.getOS() == llvm::Triple::ShaderModel) {
3907 if (TC.requiresObjcopy(Args)) {
3908 Action *LastAction = Actions.back();
3910 if (LastAction->
getType() == types::TY_Object) {
3918 auto ValInfo = TC.getValidationInfo(Args);
3919 if (ValInfo.NeedsValidation) {
3920 Action *LastAction = Actions.back();
3921 if (LastAction->
getType() == types::TY_Object) {
3923 ValInfo.ProducesOutput ? types::TY_DX_CONTAINER : types::TY_Object;
3930 if (TC.requiresBinaryTranslation(Args)) {
3931 Action *LastAction = Actions.back();
3935 if (LastAction->
getType() == types::TY_DX_CONTAINER ||
3936 LastAction->
getType() == types::TY_Object)
3938 LastAction, types::TY_DX_CONTAINER));
3943 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
3949 return Triple.isSPIRV() &&
3950 Triple.getVendor() == llvm::Triple::UnknownVendor &&
3951 Triple.getOS() == llvm::Triple::UnknownOS;
3958 const llvm::opt::DerivedArgList &Args,
3960 const llvm::Triple &Triple,
3966 if (Triple.isSPIRV() && (
Arch.isIntel() ||
Arch.isGeneric()) &&
3967 ArchStr.contains(
':'))
3969 if (Triple.isNVPTX() && (
Arch.isUnknown() || !
Arch.isNVPTX())) {
3970 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
3971 <<
"CUDA" << ArchStr;
3973 }
else if (Triple.isAMDGPU()) {
3974 if (
Arch.isUnknown() || (!
Arch.isAMDGPU() && !
Arch.isAMDGCNSPIRV())) {
3975 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
3976 <<
"HIP" << ArchStr;
3980 if (Triple.getSubArch() != llvm::Triple::NoSubArch) {
3982 if (ArchSubArch != Triple.getSubArch() &&
3983 llvm::AMDGPU::getMajorSubArch(ArchSubArch) != Triple.getSubArch()) {
3984 C.getDriver().Diag(clang::diag::err_target_unsupported_arch)
3985 << ArchStr << Triple.getArchName();
3989 }
else if (Triple.isSPIRV() && ArchStr.starts_with(
"igca") &&
3990 !
Arch.isIntelIGCA()) {
3993 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
3994 <<
"IGCA" << ArchStr;
3997 !ArchStr.empty() && !
Arch.isIntel() && !
Arch.isGeneric()) {
4001 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
4002 <<
"SYCL" << ArchStr;
4008 C.getDriver().Diag(clang::diag::err_target_unsupported_arch)
4009 << ArchStr << Triple.str();
4016 if (
Arch.isAMDGPU() ||
Arch.isAMDGCNSPIRV()) {
4019 C.getDriver().Diag(clang::diag::err_drv_bad_target_id) << ArchStr;
4022 return Args.MakeArgStringRef(*TargetID);
4031static std::optional<std::pair<llvm::StringRef, llvm::StringRef>>
4033 llvm::Triple Triple) {
4034 if (!Triple.isAMDGPU())
4035 return std::nullopt;
4037 std::set<StringRef> ArchSet;
4038 llvm::copy(Archs, std::inserter(ArchSet, ArchSet.begin()));
4042llvm::SmallVector<BoundArch>
4046 if (Args.hasArgNoClaim(options::OPT_offload_EQ) &&
4047 Args.hasArgNoClaim(options::OPT_offload_arch_EQ,
4048 options::OPT_no_offload_arch_EQ)) {
4049 C.getDriver().Diag(diag::err_opt_not_valid_with_opt)
4051 << (Args.hasArgNoClaim(options::OPT_offload_arch_EQ)
4053 :
"--no-offload-arch");
4056 llvm::DenseSet<StringRef> Archs;
4057 for (
auto *Arg :
C.getArgsForToolChain(&TC, {}, Kind)) {
4060 if (Arg->getOption().matches(options::OPT_offload_arch_EQ)) {
4061 for (StringRef
Arch : Arg->getValues()) {
4062 if (
Arch ==
"native" ||
Arch.empty()) {
4067 << llvm::toString(GPUsOrErr.takeError()) <<
"--offload-arch";
4071 for (
auto ArchStr : *GPUsOrErr) {
4073 C, Args, Args.MakeArgString(ArchStr), TC.
getTriple(), Kind);
4074 if (!CanonicalStr.empty())
4075 Archs.insert(CanonicalStr);
4080 StringRef CanonicalStr =
4082 if (!CanonicalStr.empty())
4083 Archs.insert(CanonicalStr);
4088 }
else if (Arg->getOption().matches(options::OPT_no_offload_arch_EQ)) {
4089 for (StringRef
Arch : Arg->getValues()) {
4090 if (
Arch ==
"all") {
4095 Archs.erase(ArchStr);
4101 if (
auto ConflictingArchs =
4103 C.getDriver().Diag(clang::diag::err_drv_bad_offload_arch_combo)
4104 << ConflictingArchs->first << ConflictingArchs->second;
4107 bool HasSubArch = TC.
getTriple().isAMDGCN() &&
4108 TC.
getTriple().getSubArch() != llvm::Triple::NoSubArch;
4109 if (Archs.empty() && !HasSubArch) {
4119 Archs.insert(StringRef());
4122 if (
auto *Arg =
C.getArgsForToolChain(&TC, {}, Kind)
4123 .getLastArg(options::OPT_march_EQ)) {
4124 Archs.insert(Arg->getValue());
4129 << TC.
getArchName() << llvm::toString(ArchsOrErr.takeError())
4130 <<
"--offload-arch";
4131 }
else if (!ArchsOrErr->empty()) {
4132 for (
auto Arch : *ArchsOrErr)
4133 Archs.insert(Args.MakeArgStringRef(
Arch));
4135 Archs.insert(StringRef());
4139 }
else if (Archs.empty() && HasSubArch) {
4146 llvm::StringRef ArchStr = TripleOffloadArch.
isUnknown()
4149 StringRef CanonicalStr =
4151 if (!CanonicalStr.empty())
4152 Archs.insert(CanonicalStr);
4155 Args.ClaimAllArgs(options::OPT_offload_arch_EQ);
4156 Args.ClaimAllArgs(options::OPT_no_offload_arch_EQ);
4163 Result.reserve(Sorted.size());
4164 for (StringRef
Arch : Sorted)
4171 const InputTy &Input, StringRef CUID,
4181 !Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4186 !Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
4189 bool HIPRelocatableObj =
4191 Args.hasFlag(options::OPT_fhip_emit_relocatable,
4192 options::OPT_fno_hip_emit_relocatable,
false);
4194 if (!HIPNoRDC && HIPRelocatableObj)
4195 C.getDriver().Diag(diag::err_opt_not_valid_with_opt)
4196 <<
"-fhip-emit-relocatable"
4200 C.getDriver().Diag(diag::err_opt_not_valid_without_opt)
4201 <<
"-fhip-emit-relocatable"
4202 <<
"--offload-device-only";
4210 bool UsesLLVMOffloading = Args.hasArg(
4211 options::OPT_foffload_via_llvm, options::OPT_fno_offload_via_llvm,
false);
4223 auto TCRange =
C.getOffloadToolChains(Kind);
4224 for (
auto TI = TCRange.first, TE = TCRange.second; TI != TE; ++TI)
4225 ToolChains.push_back(TI->second);
4227 if (ToolChains.empty())
4231 const Arg *InputArg = Input.second;
4240 for (
const ToolChain *TC : ToolChains) {
4242 TCAndArchs.push_back(std::make_pair(TC,
Arch));
4243 DeviceActions.push_back(
4244 C.MakeAction<
InputAction>(*InputArg, InputType, CUID));
4248 if (DeviceActions.empty())
4254 HostAction->
getType() != types::TY_Nothing &&
4264 assert(Phase == PL.back() &&
"linking must be final compilation step.");
4273 auto *TCAndArch = TCAndArchs.begin();
4274 for (
Action *&A : DeviceActions) {
4275 if (A->
getType() == types::TY_Nothing)
4282 TCAndArch->first->getLTOMode(Args, Kind));
4286 HostAction->
getType() != types::TY_Nothing) {
4293 TCAndArch->second, Kind);
4295 DDep.
add(*A, *TCAndArch->first, TCAndArch->second, Kind);
4305 for (
Action *&A : DeviceActions) {
4310 OffloadTriple && OffloadTriple->isSPIRV() &&
4311 (OffloadTriple->getOS() == llvm::Triple::OSType::AMDHSA ||
4312 OffloadTriple->getOS() == llvm::Triple::OSType::ChipStar);
4314 if ((A->
getType() != types::TY_Object && !IsHIPSPV &&
4315 A->
getType() != types::TY_LTO_BC) ||
4322 auto *TCAndArch = TCAndArchs.begin();
4323 for (
Action *A : DeviceActions) {
4324 DDeps.
add(*A, *TCAndArch->first, TCAndArch->second, Kind);
4326 DDep.
add(*A, *TCAndArch->first, TCAndArch->second, Kind);
4333 A->
getType() == types::TY_Object &&
4334 !Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
4336 DDep.
add(*Input, *TCAndArch->first, TCAndArch->second, Kind);
4345 bool ShouldBundleHIP =
4346 Args.hasFlag(options::OPT_gpu_bundle_output,
4347 options::OPT_no_gpu_bundle_output,
false) ||
4348 (!Args.getLastArg(options::OPT_no_gpu_bundle_output) && HIPNoRDC &&
4350 return A->
getType() != types::TY_Image;
4361 if (OffloadActions.empty())
4366 (!Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false) ||
4367 Args.hasArg(options::OPT_cuda_emit_nvcc_abi))) {
4371 C.MakeAction<
LinkJobAction>(OffloadActions, types::TY_CUDA_FATBIN);
4378 C.MakeAction<
LinkJobAction>(OffloadActions, types::TY_HIP_FATBIN);
4379 DDep.
add(*FatbinAction,
4382 }
else if ((!UsesLLVMOffloading && HIPNoRDC) || SYCLNoRDC) {
4385 if (HIPNoRDC && HIPAsmBundleDeviceOut &&
4387 for (
Action *OA : OffloadActions)
4388 HIPAsmBundleDeviceOut->push_back(OA);
4401 SYCLNoRDC ? types::TY_SYCL_FATBIN : types::TY_HIP_FATBIN;
4404 DDep.
add(*PackagerAction, *
C.getOffloadToolChains(Kind).first->second,
4412 {},
C.getActiveOffloadKinds());
4421 bool SingleDeviceOutput = !llvm::any_of(OffloadActions, [](
Action *A) {
4422 return A->
getType() == types::TY_Nothing;
4426 {}, SingleDeviceOutput ? DDep : DDeps);
4427 return C.MakeAction<
OffloadAction>(HDep, SingleDeviceOutput ? DDep : DDeps);
4433 llvm::PrettyStackTraceString CrashInfo(
"Constructing phase actions");
4443 if (Args.hasArg(options::OPT_sycl_link) && Phase !=
phases::Link)
4449 llvm_unreachable(
"link action invalid here.");
4451 llvm_unreachable(
"ifsmerge action invalid here.");
4456 if (Args.hasArg(options::OPT_M, options::OPT_MM) &&
4457 !Args.hasArg(options::OPT_MD, options::OPT_MMD)) {
4458 OutputTy = types::TY_Dependencies;
4463 if (!Args.hasFlag(options::OPT_frewrite_includes,
4464 options::OPT_fno_rewrite_includes,
false) &&
4465 !Args.hasFlag(options::OPT_frewrite_imports,
4466 options::OPT_fno_rewrite_imports,
false) &&
4467 !Args.hasFlag(options::OPT_fdirectives_only,
4468 options::OPT_fno_directives_only,
false) &&
4472 "Cannot preprocess this input type!");
4478 if (Args.hasArg(options::OPT_extract_api))
4483 if (Input->
getType() == types::TY_CXXStdModule ||
4484 Input->
getType() == types::TY_PP_CXXStdModule)
4486 Input, getPrecompiledType(Input->
getType()));
4494 if (!Args.hasArg(options::OPT_fno_modules_reduced_bmi) &&
4495 (Input->
getType() == driver::types::TY_CXXModule ||
4496 Input->
getType() == driver::types::TY_PP_CXXModule) &&
4497 !Args.getLastArg(options::OPT__precompile) &&
4498 !Args.getLastArg(options::OPT__precompile_reduced_bmi))
4503 "Cannot precompile this input type!");
4507 const char *ModName =
nullptr;
4508 if (OutputTy == types::TY_PCH) {
4509 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name_EQ))
4510 ModName = A->getValue();
4512 OutputTy = types::TY_ModuleFile;
4515 if (Args.hasArg(options::OPT_fsyntax_only)) {
4517 OutputTy = types::TY_Nothing;
4523 if (Args.hasArg(options::OPT_fsyntax_only))
4525 if (Args.hasArg(options::OPT_rewrite_objc))
4527 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
4529 types::TY_RewrittenLegacyObjC);
4530 if (Args.hasArg(options::OPT__analyze))
4532 if (Args.hasArg(options::OPT_emit_ast))
4534 if (Args.hasArg(options::OPT_emit_cir)) {
4537 if (Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S))
4541 if (Args.hasArg(options::OPT_module_file_info))
4543 if (Args.hasArg(options::OPT_verify_pch))
4545 if (Args.hasArg(options::OPT_extract_api))
4552 if (!IsDeviceOffload) {
4554 if (Args.hasArg(options::OPT_ffat_lto_objects) &&
4555 !Args.hasArg(options::OPT_emit_llvm))
4556 Output = types::TY_PP_Asm;
4557 else if (Args.hasArg(options::OPT_S))
4558 Output = types::TY_LTO_IR;
4560 Output = types::TY_LTO_BC;
4564 if (Args.hasArg(options::OPT_emit_llvm)) {
4566 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
4568 !Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
4572 Output = types::TY_PP_Asm;
4573 }
else if (Args.hasArg(options::OPT_S)) {
4574 Output = types::TY_LTO_IR;
4576 Output = types::TY_LTO_BC;
4582 if (Args.hasArg(options::OPT_emit_llvm) ||
4586 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
4595 const llvm::Triple
Target(llvm::Triple::normalize(TargetTriple));
4596 if (
Target.isOSWindows() && Args.hasArg(options::OPT_marm64x)) {
4607 llvm_unreachable(
"invalid phase in ConstructPhaseAction");
4630 return Triple.isAMDGPU() || Triple.isNVPTX() || Triple.isSPIROrSPIRV();
4650 if (!OffloadJobs.isValid())
4651 D.
Diag(diag::err_drv_invalid_int_value)
4652 << OffloadJobs.A->getAsString(Args) << OffloadJobs.Value;
4654 OffloadJobs.A->claim();
4658 for (
auto &Job :
C.getJobs()) {
4662 Job.setOffloadDeviceParallelJobGroup(
4668 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
4670 Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o);
4690 unsigned NumOutputs = 0;
4691 unsigned NumIfsOutputs = 0;
4692 for (
const Action *A :
C.getActions()) {
4702 (A->
getInputs().front()->getType() == types::TY_CXXStdModule ||
4703 A->
getInputs().front()->getType() == types::TY_PP_CXXStdModule))
4706 if (A->
getType() != types::TY_Nothing &&
4708 (A->
getType() == clang::driver::types::TY_IFS_CPP &&
4710 0 == NumIfsOutputs++) ||
4715 A->
getType() == types::TY_Nothing &&
4716 !
C.getArgs().hasArg(options::OPT_fsyntax_only))
4717 NumOutputs += A->
size();
4720 if (NumOutputs > 1) {
4721 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
4722 FinalOutput =
nullptr;
4726 const llvm::Triple &RawTriple =
C.getDefaultToolChain().getTriple();
4729 llvm::StringSet<> ArchNames;
4730 if (RawTriple.isOSBinFormatMachO())
4731 for (
const Arg *A :
C.getArgs())
4732 if (A->getOption().matches(options::OPT_arch))
4733 ArchNames.insert(A->getValue());
4736 std::map<std::pair<const Action *, std::string>,
InputInfoList> CachedResults;
4737 for (
Action *A :
C.getActions()) {
4744 const char *LinkingOutput =
nullptr;
4747 LinkingOutput = FinalOutput->getValue();
4755 ArchNames.size() > 1 ||
4756 C.getArgs().hasArgNoClaim(options::OPT_marm64x),
4757 LinkingOutput, CachedResults,
4764 for (
auto &J :
C.getJobs())
4765 J.InProcess =
false;
4772 C.setPostCallback([=](
const Command &Cmd,
int Res) {
4773 std::optional<llvm::sys::ProcessStatistics> ProcStat =
4778 const char *LinkingOutput =
nullptr;
4780 LinkingOutput = FinalOutput->getValue();
4787 using namespace llvm;
4790 <<
"output=" << LinkingOutput;
4791 outs() <<
", total="
4792 <<
format(
"%.3f", ProcStat->TotalTime.count() / 1000.) <<
" ms"
4794 <<
format(
"%.3f", ProcStat->UserTime.count() / 1000.) <<
" ms"
4795 <<
", mem=" << ProcStat->PeakMemory <<
" Kb\n";
4799 llvm::raw_string_ostream Out(Buffer);
4800 llvm::sys::printArg(Out, llvm::sys::path::filename(Cmd.
getExecutable()),
4803 llvm::sys::printArg(Out, LinkingOutput,
true);
4804 Out <<
',' << ProcStat->TotalTime.count() <<
','
4805 << ProcStat->UserTime.count() <<
',' << ProcStat->PeakMemory
4810 llvm::sys::fs::OF_Append |
4811 llvm::sys::fs::OF_Text);
4816 llvm::errs() <<
"ERROR: Cannot lock file "
4818 <<
toString(L.takeError()) <<
"\n";
4829 bool ReportUnusedArguments =
4830 !Diags.hasErrorOccurred() &&
4831 !
C.getArgs().hasArg(options::OPT_Qunused_arguments);
4834 (void)
C.getArgs().hasArg(options::OPT_fdriver_only);
4836 (void)
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
4839 (void)
C.getArgs().hasArg(options::OPT_driver_mode);
4840 (void)
C.getArgs().hasArg(options::OPT_rsp_quoting);
4842 bool HasAssembleJob = llvm::any_of(
C.getJobs(), [](
auto &J) {
4846 return strstr(J.getCreator().getShortName(),
"assembler");
4848 for (Arg *A :
C.getArgs()) {
4852 if (!A->isClaimed()) {
4858 const Option &Opt = A->getOption();
4859 if (Opt.getKind() == Option::FlagClass) {
4860 bool DuplicateClaimed =
false;
4862 for (
const Arg *AA :
C.getArgs().filtered(&Opt)) {
4863 if (AA->isClaimed()) {
4864 DuplicateClaimed =
true;
4869 if (DuplicateClaimed)
4875 if (!
IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN)) {
4877 !A->isIgnoredTargetSpecific() && !HasAssembleJob &&
4882 !
C.getActions().empty()) {
4883 Diag(diag::err_drv_unsupported_opt_for_target)
4885 }
else if (ReportUnusedArguments) {
4886 Diag(clang::diag::warn_drv_unused_argument)
4887 << A->getAsString(
C.getArgs());
4897class ToolSelector final {
4908 bool IsHostSelector;
4919 bool CanBeCollapsed =
true) {
4921 if (Inputs.size() != 1)
4924 Action *CurAction = *Inputs.begin();
4925 if (CanBeCollapsed &&
4931 if (
auto *OA = dyn_cast<OffloadAction>(CurAction)) {
4935 if (!IsHostSelector) {
4936 if (OA->hasSingleDeviceDependence(
true)) {
4938 OA->getSingleDeviceDependence(
true);
4939 if (CanBeCollapsed &&
4942 SavedOffloadAction.push_back(OA);
4943 return dyn_cast<JobAction>(CurAction);
4945 }
else if (OA->hasHostDependence()) {
4946 CurAction = OA->getHostDependence();
4947 if (CanBeCollapsed &&
4950 SavedOffloadAction.push_back(OA);
4951 return dyn_cast<JobAction>(CurAction);
4956 return dyn_cast<JobAction>(CurAction);
4960 bool canCollapseAssembleAction()
const {
4961 return TC.useIntegratedAs() && !SaveTemps &&
4962 !
C.getArgs().hasArg(options::OPT_via_file_asm) &&
4963 !
C.getArgs().hasArg(options::OPT__SLASH_FA) &&
4964 !
C.getArgs().hasArg(options::OPT__SLASH_Fa) &&
4965 !
C.getArgs().hasArg(options::OPT_dxc_Fc);
4969 bool canCollapsePreprocessorAction()
const {
4970 return !
C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
4971 !
C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
4972 !
C.getArgs().hasArg(options::OPT_rewrite_objc);
4977 struct JobActionInfo final {
4979 const JobAction *JA =
nullptr;
4987 static void AppendCollapsedOffloadAction(
ActionList &CollapsedOffloadAction,
4988 ArrayRef<JobActionInfo> &ActionInfo,
4989 unsigned ElementNum) {
4990 assert(ElementNum <= ActionInfo.size() &&
"Invalid number of elements.");
4991 for (
unsigned I = 0; I < ElementNum; ++I)
4992 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
4993 ActionInfo[I].SavedOffloadAction.end());
5006 combineAssembleBackendCompile(ArrayRef<JobActionInfo> ActionInfo,
5009 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
5011 auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA);
5012 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA);
5013 auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[2].JA);
5014 if (!AJ || !BJ || !CJ)
5018 const Tool *
T = TC.SelectTool(*CJ);
5025 if (!
T->hasIntegratedBackend() && !(OutputIsLLVM &&
T->canEmitIR()))
5031 const Tool *BT = TC.SelectTool(*BJ);
5036 if (!
T->hasIntegratedAssembler())
5039 Inputs = CJ->getInputs();
5040 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
5044 const Tool *combineAssembleBackend(ArrayRef<JobActionInfo> ActionInfo,
5047 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
5049 auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA);
5050 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA);
5055 const Tool *
T = TC.SelectTool(*BJ);
5059 if (!
T->hasIntegratedAssembler())
5062 Inputs = BJ->getInputs();
5063 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
5067 const Tool *combineBackendCompile(ArrayRef<JobActionInfo> ActionInfo,
5070 if (ActionInfo.size() < 2)
5072 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[0].JA);
5073 auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[1].JA);
5077 auto HasBitcodeInput = [](
const JobActionInfo &AI) {
5078 for (
auto &Input : AI.JA->getInputs())
5089 bool InputIsBitcode = all_of(ActionInfo, HasBitcodeInput);
5090 if (SaveTemps && !InputIsBitcode)
5094 const Tool *
T = TC.SelectTool(*CJ);
5101 if (!
T->hasIntegratedBackend() && !(OutputIsLLVM &&
T->canEmitIR()))
5107 Inputs = CJ->getInputs();
5108 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
5117 void combineWithPreprocessor(
const Tool *
T,
ActionList &Inputs,
5119 if (!
T || !canCollapsePreprocessorAction() || !
T->hasIntegratedCPP())
5125 for (Action *A : Inputs) {
5126 auto *PJ = getPrevDependentAction({A}, PreprocessJobOffloadActions);
5128 NewInputs.push_back(A);
5134 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
5135 PreprocessJobOffloadActions.end());
5136 NewInputs.append(PJ->input_begin(), PJ->input_end());
5142 ToolSelector(
const JobAction *BaseAction,
const ToolChain &TC,
5144 : TC(TC),
C(
C), BaseAction(BaseAction), SaveTemps(SaveTemps),
5146 assert(BaseAction &&
"Invalid base action.");
5162 SmallVector<JobActionInfo, 5> ActionChain(1);
5163 ActionChain.back().JA = BaseAction;
5164 while (ActionChain.back().JA) {
5165 const Action *CurAction = ActionChain.back().JA;
5168 ActionChain.resize(ActionChain.size() + 1);
5169 JobActionInfo &AI = ActionChain.back();
5173 getPrevDependentAction(CurAction->
getInputs(), AI.SavedOffloadAction);
5177 ActionChain.pop_back();
5185 const Tool *
T = combineAssembleBackendCompile(ActionChain, Inputs,
5186 CollapsedOffloadAction);
5188 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
5190 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
5196 combineWithPreprocessor(
T, Inputs, CollapsedOffloadAction);
5209 std::string TriplePlusArch = TC->
getTriple().normalize();
5211 TriplePlusArch +=
"-";
5214 TriplePlusArch +=
"-";
5216 return TriplePlusArch;
5221 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
5222 std::map<std::pair<const Action *, std::string>,
InputInfoList>
5225 std::pair<const Action *, std::string> ActionTC = {
5227 auto CachedResult = CachedResults.find(ActionTC);
5228 if (CachedResult != CachedResults.end()) {
5229 return CachedResult->second;
5232 C, A, TC, BA, AtTopLevel, MultipleArchs, LinkingOutput, CachedResults,
5233 TargetDeviceOffloadKind);
5234 CachedResults[ActionTC] =
Result;
5239 const JobAction *JA,
const char *BaseInput,
5242 Args.getLastArg(options::OPT_ftime_trace, options::OPT_ftime_trace_EQ);
5253 if (!
Arch.empty()) {
5254 OffloadingPrefix +=
"-";
5255 OffloadingPrefix +=
Arch.ArchName;
5258 C.getDriver().isSaveTempsEnabled()) {
5264 StringRef DefaultExt =
".json";
5265 StringRef DefaultExtNoDot =
"json";
5266 if (
const Arg *CompressArg =
5267 Args.getLastArgNoClaim(options::OPT_ftime_trace_compress_EQ)) {
5268 if (StringRef(CompressArg->getValue()) ==
"zstd") {
5269 DefaultExt =
".json.zst";
5270 DefaultExtNoDot =
"json.zst";
5275 if (A->getOption().matches(options::OPT_ftime_trace_EQ)) {
5276 Path = A->getValue();
5277 if (llvm::sys::fs::is_directory(Path)) {
5279 ? llvm::sys::path::stem(
Result.getFilename())
5280 : llvm::sys::path::stem(BaseInput));
5281 Tmp += OffloadingPrefix;
5283 llvm::sys::path::append(Path, Tmp);
5286 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
5289 Path = DumpDir->getValue();
5290 Path += llvm::sys::path::stem(BaseInput);
5291 Path += OffloadingPrefix;
5293 }
else if (!OffloadingPrefix.empty()) {
5297 TraceName += OffloadingPrefix;
5298 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
5299 Path = llvm::sys::path::parent_path(FinalOutput->getValue());
5300 llvm::sys::path::append(Path, TraceName);
5303 Path =
Result.getFilename();
5304 llvm::sys::path::replace_extension(Path, DefaultExtNoDot);
5307 const char *ResultFile =
C.getArgs().MakeArgString(Path);
5308 C.addTimeTraceFile(ResultFile, JA);
5309 C.addResultFile(ResultFile, JA);
5314 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
5315 std::map<std::pair<const Action *, std::string>,
InputInfoList>
5318 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
5322 BoundArch SavedBoundArch =
C.getCurrentBoundArch();
5323 C.setCurrentBoundArch(BA);
5324 auto RestoreBoundArch =
5325 llvm::scope_exit([&] {
C.setCurrentBoundArch(SavedBoundArch); });
5328 bool BuildingForOffloadDevice = TargetDeviceOffloadKind !=
Action::OFK_None;
5329 if (
const OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
5361 if (OA->hasSingleDeviceDependence() || !OA->hasHostDependence()) {
5363 OA->doOnEachDeviceDependence([&](Action *DepA,
const ToolChain *DepTC,
5364 BoundArch DepBoundArch) {
5366 !DepBoundArch.
empty(),
5367 LinkingOutput, CachedResults,
5377 OA->doOnEachDependence(
5378 BuildingForOffloadDevice,
5379 [&](Action *DepA,
const ToolChain *DepTC, BoundArch DepBoundArch) {
5381 C, DepA, DepTC, DepBoundArch,
false,
5382 !DepBoundArch.
empty(), LinkingOutput,
5386 A = BuildingForOffloadDevice
5387 ? OA->getSingleDeviceDependence(
true)
5388 : OA->getHostDependence();
5392 std::pair<const Action *, std::string> ActionTC = {
5393 OA->getHostDependence(),
5395 auto It = CachedResults.find(ActionTC);
5396 if (It != CachedResults.end()) {
5398 Inputs.append(OffloadDependencesInputInfo);
5403 if (
const InputAction *IA = dyn_cast<InputAction>(A)) {
5406 const Arg &Input = IA->getInputArg();
5408 if (Input.getOption().matches(options::OPT_INPUT)) {
5409 const char *
Name = Input.getValue();
5412 return {InputInfo(A, &Input,
"")};
5415 if (
const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
5416 const ToolChain *TC;
5417 BoundArch ArchName = BAA->
getArch();
5419 if (!ArchName.
empty())
5420 TC = &getToolChain(
C.getArgs(),
5424 TC = &
C.getDefaultToolChain();
5427 MultipleArchs, LinkingOutput, CachedResults,
5428 TargetDeviceOffloadKind);
5441 const Tool *
T = TS.getTool(Inputs, CollapsedOffloadActions);
5444 return {InputInfo()};
5448 for (
const auto *OA : CollapsedOffloadActions)
5450 BuildingForOffloadDevice,
5451 [&](Action *DepA,
const ToolChain *DepTC, BoundArch DepBoundArch) {
5453 C, DepA, DepTC, DepBoundArch,
false,
5454 !DepBoundArch.
empty(), LinkingOutput,
5460 for (
const Action *Input : Inputs) {
5464 bool SubJobAtTopLevel =
5467 C, Input, TC, BA, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
5472 const char *BaseInput = InputInfos[0].getBaseInput();
5473 for (
auto &Info : InputInfos) {
5474 if (Info.isFilename()) {
5475 BaseInput = Info.getBaseInput();
5482 if (JA->
getType() == types::TY_dSYM)
5483 BaseInput = InputInfos[0].getFilename();
5486 if (!OffloadDependencesInputInfo.empty())
5487 InputInfos.append(OffloadDependencesInputInfo.begin(),
5488 OffloadDependencesInputInfo.end());
5491 llvm::Triple EffectiveTriple;
5492 const ToolChain &ToolTC =
T->getToolChain();
5493 const ArgList &Args =
5495 if (InputInfos.size() != 1) {
5500 EffectiveTriple = llvm::Triple(
5503 RegisterEffectiveTriple TripleRAII(ToolTC, EffectiveTriple);
5507 if (JA->
getType() == types::TY_Nothing)
5508 Result = {InputInfo(A, BaseInput)};
5519 MultipleArchs, OffloadingPrefix),
5526 llvm::errs() <<
"# \"" <<
T->getToolChain().getEffectiveTriple().str()
5527 <<
'"' <<
" - \"" <<
T->getName() <<
"\", inputs: [";
5528 for (
unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
5529 llvm::errs() << InputInfos[i].getAsString();
5531 llvm::errs() <<
", ";
5533 llvm::errs() <<
"], output: " <<
Result.getAsString() <<
"\n";
5535 T->ConstructJob(
C, *JA,
Result, InputInfos, Args, LinkingOutput);
5541 llvm::Triple
Target(llvm::Triple::normalize(TargetTriple));
5542 return Target.isOSWindows() ?
"a.exe" :
"a.out";
5554 if (ArgValue.empty()) {
5556 Filename = BaseName;
5557 }
else if (llvm::sys::path::is_separator(Filename.back())) {
5559 llvm::sys::path::append(Filename, BaseName);
5562 if (!llvm::sys::path::has_extension(ArgValue)) {
5567 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
5572 llvm::sys::path::replace_extension(Filename, Extension);
5575 return Args.MakeArgString(Filename.c_str());
5590 StringRef Suffix,
bool MultipleArchs,
5591 StringRef BoundArchStr,
5592 bool NeedUniqueDirectory)
const {
5594 Arg *A =
C.getArgs().getLastArg(options::OPT_fcrash_diagnostics_dir);
5595 std::optional<std::string> CrashDirectory =
5597 ? std::string(A->getValue())
5598 : llvm::sys::Process::GetEnv(
"CLANG_CRASH_DIAGNOSTICS_DIR");
5599 if (CrashDirectory) {
5600 if (!
getVFS().exists(*CrashDirectory))
5601 llvm::sys::fs::create_directories(*CrashDirectory);
5603 llvm::sys::path::append(Path, Prefix);
5604 const char *Middle = !Suffix.empty() ?
"-%%%%%%." :
"-%%%%%%";
5605 if (std::error_code EC =
5606 llvm::sys::fs::createUniqueFile(Path + Middle + Suffix, TmpName)) {
5607 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
5611 if (MultipleArchs && !BoundArchStr.empty()) {
5612 if (NeedUniqueDirectory) {
5614 llvm::sys::path::append(TmpName, Twine(Prefix) +
"-" + BoundArchStr +
5625 return C.addTempFile(
C.getArgs().MakeArgString(TmpName));
5640 const char *BaseInput) {
5642 (
C.getArgs().hasArg(options::OPT_fmodule_output) ||
5643 C.getArgs().hasArg(options::OPT_fmodule_output_EQ)));
5648 return C.addResultFile(
C.getArgs().MakeArgString(OutputPath.c_str()), &JA);
5653 bool AtTopLevel,
bool MultipleArchs,
5654 StringRef OffloadingPrefix)
const {
5657 llvm::PrettyStackTraceString CrashInfo(
"Computing output path");
5659 auto CreateTempOutputPath = [&](StringRef Prefix) {
5660 const char *Suffix =
5665 const llvm::Triple Triple(
C.getDriver().getTargetTriple());
5666 const bool NeedUniqueDirectory =
5669 Triple.isOSDarwin();
5671 NeedUniqueDirectory);
5676 (JA.
getInputs().front()->getType() == types::TY_CXXStdModule ||
5677 JA.
getInputs().front()->getType() == types::TY_PP_CXXStdModule)) {
5678 StringRef Filename = llvm::sys::path::filename(BaseInput);
5679 StringRef Stem = llvm::sys::path::stem(Filename);
5680 return CreateTempOutputPath(Stem);
5685 if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o))
5686 return C.addResultFile(FinalOutput->getValue(), &JA);
5690 if (
C.getArgs().hasArg(options::OPT__SLASH_P)) {
5692 StringRef BaseName = llvm::sys::path::filename(BaseInput);
5694 if (Arg *A =
C.getArgs().getLastArg(options::OPT__SLASH_Fi))
5695 NameArg = A->getValue();
5696 return C.addResultFile(
5706 if (JA.
getType() == types::TY_ModuleFile &&
5707 C.getArgs().getLastArg(options::OPT_module_file_info)) {
5711 if (JA.
getType() == types::TY_PP_Asm &&
5712 C.getArgs().hasArg(options::OPT_dxc_Fc)) {
5713 StringRef FcValue =
C.getArgs().getLastArgValue(options::OPT_dxc_Fc);
5716 return C.addResultFile(
C.getArgs().MakeArgString(FcValue), &JA);
5719 if ((JA.
getType() == types::TY_Object &&
5720 C.getArgs().hasArg(options::OPT_dxc_Fo)) ||
5721 JA.
getType() == types::TY_DX_CONTAINER) {
5722 StringRef FoValue =
C.getArgs().getLastArgValue(options::OPT_dxc_Fo);
5723 assert((
C.getDefaultToolChain().getTriple().isDXIL() ||
5724 C.getDefaultToolChain().getTriple().isSPIRV()) &&
5725 "expected DXIL or SPIR-V triple for HLSL output path");
5730 if (TC.isLastOutputProducingJob(
C.getArgs(), JA.
getKind()) &&
5732 return C.addResultFile(
C.getArgs().MakeArgString(FoValue), &JA);
5733 StringRef
Name = llvm::sys::path::filename(BaseInput);
5734 std::pair<StringRef, StringRef> Split =
Name.split(
'.');
5740 if (JA.
getType() == types::TY_PP_Asm &&
5741 (
C.getArgs().hasArg(options::OPT__SLASH_FA) ||
5742 C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
5744 StringRef BaseName = llvm::sys::path::filename(BaseInput);
5745 StringRef FaValue =
C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
5746 return C.addResultFile(
5751 if (JA.
getType() == types::TY_API_INFO &&
5752 C.getArgs().hasArg(options::OPT_emit_extension_symbol_graphs) &&
5753 C.getArgs().hasArg(options::OPT_o))
5754 Diag(clang::diag::err_drv_unexpected_symbol_graph_output)
5755 <<
C.getArgs().getLastArgValue(options::OPT_o);
5762 bool SpecifiedModuleOutput =
5763 C.getArgs().hasArg(options::OPT_fmodule_output) ||
5764 C.getArgs().hasArg(options::OPT_fmodule_output_EQ);
5765 if (MultipleArchs && SpecifiedModuleOutput)
5766 Diag(clang::diag::err_drv_module_output_with_multiple_arch);
5771 JA.
getType() == types::TY_ModuleFile && SpecifiedModuleOutput) {
5772 assert(
C.getArgs().hasArg(options::OPT_fno_modules_reduced_bmi));
5778 !
C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
5780 StringRef
Name = llvm::sys::path::filename(BaseInput);
5781 return CreateTempOutputPath(
Name.split(
'.').first);
5790 ExternalPath +=
C.getArgs().getLastArg(options::OPT_dsym_dir)->getValue();
5795 llvm::sys::path::append(ExternalPath, llvm::sys::path::Style::posix,
5796 llvm::sys::path::filename(BasePath));
5797 BaseName = ExternalPath;
5799 BaseName = BasePath;
5801 BaseName = llvm::sys::path::filename(BasePath);
5804 const char *NamedOutput;
5806 if ((JA.
getType() == types::TY_Object || JA.
getType() == types::TY_LTO_BC ||
5807 JA.
getType() == types::TY_LLVM_BC ||
5808 JA.
getType() == types::TY_LLVM_IR) &&
5809 C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
5813 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
5817 }
else if (JA.
getType() == types::TY_Image &&
5818 C.getArgs().hasArg(options::OPT__SLASH_Fe,
5819 options::OPT__SLASH_o)) {
5823 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
5827 }
else if (JA.
getType() == types::TY_Image) {
5837 !
C.getArgs().hasFlag(options::OPT_fgpu_rdc,
5838 options::OPT_fno_gpu_rdc,
false);
5840 if (UseOutExtension) {
5842 llvm::sys::path::replace_extension(Output,
"");
5844 Output += OffloadingPrefix;
5845 if (MultipleArchs && !BoundArchStr.empty()) {
5847 Output.append(BoundArchStr);
5849 if (UseOutExtension)
5851 NamedOutput =
C.getArgs().MakeArgString(Output.c_str());
5854 NamedOutput =
C.getArgs().MakeArgString(
GetClPchPath(
C, BaseName));
5855 }
else if ((JA.
getType() == types::TY_Plist || JA.
getType() == types::TY_AST) &&
5856 C.getArgs().hasArg(options::OPT__SLASH_o)) {
5859 .getLastArg(options::OPT__SLASH_o)
5864 const char *Suffix =
5866 assert(Suffix &&
"All types used for output should have a suffix.");
5868 std::string::size_type End = std::string::npos;
5870 End = BaseName.rfind(
'.');
5872 Suffixed += OffloadingPrefix;
5873 if (MultipleArchs && !BoundArchStr.empty()) {
5875 Suffixed.append(BoundArchStr);
5880 auto IsAMDRDCInCompilePhase = [](
const JobAction &JA,
5881 const llvm::opt::DerivedArgList &Args) {
5894 bool IsLinkerWrapper =
5896 bool IsEmitBitcode = JA.
getType() == types::TY_LLVM_BC &&
5897 (
C.getArgs().hasArg(options::OPT_emit_llvm) ||
5898 IsAMDRDCInCompilePhase(JA,
C.getArgs()));
5900 if (!AtTopLevel && (IsLinkerWrapper || IsEmitBitcode))
5904 NamedOutput =
C.getArgs().MakeArgString(Suffixed.c_str());
5908 if (!AtTopLevel &&
isSaveTempsObj() &&
C.getArgs().hasArg(options::OPT_o) &&
5909 JA.
getType() != types::TY_PCH) {
5910 Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o);
5912 llvm::sys::path::remove_filename(TempPath);
5913 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
5914 llvm::sys::path::append(TempPath, OutputFileName);
5915 NamedOutput =
C.getArgs().MakeArgString(TempPath.c_str());
5924 bool SameFile =
false;
5925 llvm::sys::fs::equivalent(BaseInput, NamedOutput, SameFile);
5927 StringRef
Name = llvm::sys::path::filename(BaseInput);
5928 std::pair<StringRef, StringRef> Split =
Name.split(
'.');
5932 return C.addTempFile(
C.getArgs().MakeArgString(TmpName));
5938 llvm::sys::path::remove_filename(BasePath);
5939 if (BasePath.empty())
5940 BasePath = NamedOutput;
5942 llvm::sys::path::append(BasePath, NamedOutput);
5943 return C.addResultFile(
C.getArgs().MakeArgString(BasePath.c_str()), &JA);
5946 return C.addResultFile(NamedOutput, &JA);
5952 -> std::optional<std::string> {
5955 for (
const auto &
Dir : P) {
5959 llvm::sys::path::append(P,
Name);
5960 if (llvm::sys::fs::exists(Twine(P)))
5961 return std::string(P);
5963 return std::nullopt;
5970 llvm::sys::path::append(R,
Name);
5971 if (llvm::sys::fs::exists(Twine(R)))
5972 return std::string(R);
5975 llvm::sys::path::append(P,
Name);
5976 if (llvm::sys::fs::exists(Twine(P)))
5977 return std::string(P);
5981 if (std::optional<std::string> IntrPath =
5984 llvm::sys::path::append(P,
Name);
5985 if (llvm::sys::fs::exists(P))
5986 return std::string(P);
5991 llvm::sys::path::append(D,
"..",
Name);
5992 if (llvm::sys::fs::exists(Twine(D)))
5993 return std::string(D);
6002 llvm::sys::path::append(R2,
"..",
"..",
Name);
6003 if (llvm::sys::fs::exists(Twine(R2)))
6004 return std::string(R2);
6006 return std::string(
Name);
6009void Driver::generatePrefixedToolNames(
6013 Names.emplace_back((TargetTriple +
"-" +
Tool).str());
6014 Names.emplace_back(
Tool);
6018 llvm::sys::path::append(Dir, Name);
6019 if (llvm::sys::fs::can_execute(Twine(Dir)))
6021 llvm::sys::path::remove_filename(Dir);
6027 generatePrefixedToolNames(
Name, TC, TargetSpecificExecutables);
6032 if (llvm::sys::fs::is_directory(PrefixDir)) {
6035 return std::string(P);
6038 if (llvm::sys::fs::can_execute(Twine(P)))
6039 return std::string(P);
6044 for (
const auto &TargetSpecificExecutable : TargetSpecificExecutables) {
6052 for (
const auto &Path : List) {
6055 return std::string(P);
6059 if (llvm::ErrorOr<std::string> P =
6060 llvm::sys::findProgramByName(TargetSpecificExecutable))
6064 return std::string(
Name);
6069 std::string error =
"<NOT PRESENT>";
6071 if (
C.getArgs().hasArg(options::OPT_nostdlib))
6076 auto evaluate = [&](
const char *library) -> std::optional<std::string> {
6093 llvm::sys::path::remove_filename(path);
6094 llvm::sys::path::append(path,
"libc++.modules.json");
6095 if (TC.
getVFS().exists(path))
6096 return static_cast<std::string
>(path);
6101 if (std::optional<std::string> result = evaluate(
"libc++.so"); result)
6104 return evaluate(
"libc++.a").value_or(error);
6108 auto evaluate = [&](
const char *library) -> std::optional<std::string> {
6112 llvm::sys::path::remove_filename(path);
6113 llvm::sys::path::append(path,
"libstdc++.modules.json");
6114 if (TC.
getVFS().exists(path))
6115 return static_cast<std::string
>(path);
6120 if (std::optional<std::string> result = evaluate(
"libstdc++.so"); result)
6123 return evaluate(
"libstdc++.a").value_or(error);
6132 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
6134 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
6138 return std::string(Path);
6143 std::error_code EC = llvm::sys::fs::createUniqueDirectory(Prefix, Path);
6145 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
6149 return std::string(Path);
6154 if (Arg *FpArg =
C.getArgs().getLastArg(options::OPT__SLASH_Fp)) {
6158 Output = FpArg->getValue();
6162 if (!llvm::sys::path::has_extension(Output))
6165 if (Arg *YcArg =
C.getArgs().getLastArg(options::OPT__SLASH_Yc))
6166 Output = YcArg->getValue();
6169 llvm::sys::path::replace_extension(Output,
".pch");
6171 return std::string(Output);
6174const ToolChain &Driver::getOffloadToolChain(
6176 const llvm::Triple &
Target,
const llvm::Triple &AuxTarget)
const {
6177 std::unique_ptr<ToolChain> &TC =
6178 ToolChains[
Target.str() +
"/" + AuxTarget.str()];
6179 std::unique_ptr<ToolChain> &HostTC = ToolChains[AuxTarget.str()];
6181 assert(HostTC &&
"Host toolchain for offloading doesn't exit?");
6184 switch (
Target.getOS()) {
6185 case llvm::Triple::CUDA:
6186 TC = std::make_unique<toolchains::CudaToolChain>(*
this,
Target, *HostTC,
6189 case llvm::Triple::AMDHSA:
6195 TC = std::make_unique<toolchains::AMDGPUToolChain>(*
this,
Target, Args,
6196 HostTC.get(), Kind);
6204 switch (
Target.getArch()) {
6205 case llvm::Triple::amdgpu:
6206 case llvm::Triple::r600:
6207 TC = std::make_unique<toolchains::AMDGPUToolChain>(*
this,
Target, Args,
6208 HostTC.get(), Kind);
6210 case llvm::Triple::spir:
6211 case llvm::Triple::spir64:
6212 case llvm::Triple::spirv:
6213 case llvm::Triple::spirv32:
6214 case llvm::Triple::spirv64:
6217 TC = std::make_unique<toolchains::SYCLToolChain>(*
this,
Target, *HostTC,
6221 TC = std::make_unique<toolchains::HIPSPVToolChain>(*
this,
Target,
6225 TC = std::make_unique<toolchains::SPIRVOpenMPToolChain>(*
this,
Target,
6229 TC = std::make_unique<toolchains::CudaToolChain>(*
this,
Target, *HostTC,
6243 return getToolChain(Args,
Target);
6247const ToolChain &Driver::getToolChain(
const ArgList &Args,
6248 const llvm::Triple &
Target)
const {
6250 auto &TC = ToolChains[
Target.str()];
6252 switch (
Target.getOS()) {
6253 case llvm::Triple::AIX:
6254 TC = std::make_unique<toolchains::AIX>(*
this,
Target, Args);
6256 case llvm::Triple::Haiku:
6257 TC = std::make_unique<toolchains::Haiku>(*
this,
Target, Args);
6259 case llvm::Triple::Darwin:
6260 case llvm::Triple::MacOSX:
6261 case llvm::Triple::IOS:
6262 case llvm::Triple::TvOS:
6263 case llvm::Triple::WatchOS:
6264 case llvm::Triple::XROS:
6265 case llvm::Triple::DriverKit:
6266 TC = std::make_unique<toolchains::DarwinClang>(*
this,
Target, Args);
6268 case llvm::Triple::DragonFly:
6269 TC = std::make_unique<toolchains::DragonFly>(*
this,
Target, Args);
6271 case llvm::Triple::OpenBSD:
6272 TC = std::make_unique<toolchains::OpenBSD>(*
this,
Target, Args);
6274 case llvm::Triple::NetBSD:
6275 TC = std::make_unique<toolchains::NetBSD>(*
this,
Target, Args);
6277 case llvm::Triple::FreeBSD:
6279 TC = std::make_unique<toolchains::PPCFreeBSDToolChain>(*
this,
Target,
6282 TC = std::make_unique<toolchains::FreeBSD>(*
this,
Target, Args);
6284 case llvm::Triple::Linux:
6285 case llvm::Triple::ELFIAMCU:
6286 if (
Target.getArch() == llvm::Triple::hexagon)
6287 TC = std::make_unique<toolchains::HexagonToolChain>(*
this,
Target,
6289 else if ((
Target.getVendor() == llvm::Triple::MipsTechnologies) &&
6290 !
Target.hasEnvironment())
6291 TC = std::make_unique<toolchains::MipsLLVMToolChain>(*
this,
Target,
6294 TC = std::make_unique<toolchains::PPCLinuxToolChain>(*
this,
Target,
6296 else if (
Target.getArch() == llvm::Triple::ve)
6297 TC = std::make_unique<toolchains::VEToolChain>(*
this,
Target, Args);
6298 else if (
Target.isOHOSFamily())
6299 TC = std::make_unique<toolchains::OHOS>(*
this,
Target, Args);
6300 else if (
Target.isWALI())
6301 TC = std::make_unique<toolchains::WebAssembly>(*
this,
Target, Args);
6303 TC = std::make_unique<toolchains::LFILinux>(*
this,
Target, Args);
6305 TC = std::make_unique<toolchains::Linux>(*
this,
Target, Args);
6307 case llvm::Triple::Fuchsia:
6308 TC = std::make_unique<toolchains::Fuchsia>(*
this,
Target, Args);
6310 case llvm::Triple::Managarm:
6311 TC = std::make_unique<toolchains::Managarm>(*
this,
Target, Args);
6313 case llvm::Triple::Serenity:
6314 TC = std::make_unique<toolchains::Serenity>(*
this,
Target, Args);
6316 case llvm::Triple::Solaris:
6317 TC = std::make_unique<toolchains::Solaris>(*
this,
Target, Args);
6319 case llvm::Triple::CUDA:
6320 TC = std::make_unique<toolchains::NVPTXToolChain>(*
this,
Target, Args);
6322 case llvm::Triple::AMDHSA: {
6323 if (
Target.getArch() == llvm::Triple::spirv64) {
6324 TC = std::make_unique<toolchains::SPIRVAMDToolChain>(*
this,
Target,
6330 TC = std::make_unique<toolchains::AMDGPUToolChain>(
6332 ShouldLinkDeviceLibs);
6336 case llvm::Triple::AMDPAL:
6337 case llvm::Triple::Mesa3D:
6338 TC = std::make_unique<toolchains::AMDGPUToolChain>(*
this,
Target, Args);
6340 case llvm::Triple::UEFI:
6341 TC = std::make_unique<toolchains::UEFI>(*
this,
Target, Args);
6343 case llvm::Triple::Win32:
6344 switch (
Target.getEnvironment()) {
6346 if (
Target.isOSBinFormatELF())
6347 TC = std::make_unique<toolchains::Generic_ELF>(*
this,
Target, Args);
6348 else if (
Target.isOSBinFormatMachO())
6349 TC = std::make_unique<toolchains::MachO>(*
this,
Target, Args);
6351 TC = std::make_unique<toolchains::Generic_GCC>(*
this,
Target, Args);
6353 case llvm::Triple::GNU:
6354 TC = std::make_unique<toolchains::MinGW>(*
this,
Target, Args);
6356 case llvm::Triple::Cygnus:
6357 TC = std::make_unique<toolchains::Cygwin>(*
this,
Target, Args);
6359 case llvm::Triple::Itanium:
6360 TC = std::make_unique<toolchains::CrossWindowsToolChain>(*
this,
Target,
6363 case llvm::Triple::MSVC:
6364 case llvm::Triple::UnknownEnvironment:
6365 if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
6366 .starts_with_insensitive(
"bfd"))
6367 TC = std::make_unique<toolchains::CrossWindowsToolChain>(
6371 std::make_unique<toolchains::MSVCToolChain>(*
this,
Target, Args);
6375 case llvm::Triple::PS4:
6376 TC = std::make_unique<toolchains::PS4CPU>(*
this,
Target, Args);
6378 case llvm::Triple::PS5:
6379 TC = std::make_unique<toolchains::PS5CPU>(*
this,
Target, Args);
6381 case llvm::Triple::Hurd:
6382 TC = std::make_unique<toolchains::Hurd>(*
this,
Target, Args);
6384 case llvm::Triple::LiteOS:
6385 TC = std::make_unique<toolchains::OHOS>(*
this,
Target, Args);
6387 case llvm::Triple::ZOS:
6388 TC = std::make_unique<toolchains::ZOS>(*
this,
Target, Args);
6390 case llvm::Triple::Vulkan:
6391 case llvm::Triple::ShaderModel:
6392 if ((
Target.getArch() == llvm::Triple::spirv32 ||
6393 Target.getArch() == llvm::Triple::spirv64) &&
6395 TC = std::make_unique<toolchains::SPIRVToolChain>(*
this,
Target, Args);
6397 TC = std::make_unique<toolchains::HLSLToolChain>(*
this,
Target, Args);
6399 case llvm::Triple::ChipStar:
6400 TC = std::make_unique<toolchains::HIPSPVToolChain>(*
this,
Target, Args);
6405 switch (
Target.getArch()) {
6406 case llvm::Triple::tce:
6407 TC = std::make_unique<toolchains::TCEToolChain>(*
this,
Target, Args);
6409 case llvm::Triple::tcele:
6410 TC = std::make_unique<toolchains::TCELEToolChain>(*
this,
Target, Args);
6412 case llvm::Triple::tcele64:
6414 std::make_unique<toolchains::TCELE64ToolChain>(*
this,
Target, Args);
6416 case llvm::Triple::hexagon:
6417 TC = std::make_unique<toolchains::HexagonToolChain>(*
this,
Target,
6420 case llvm::Triple::lanai:
6421 TC = std::make_unique<toolchains::LanaiToolChain>(*
this,
Target, Args);
6423 case llvm::Triple::xcore:
6424 TC = std::make_unique<toolchains::XCoreToolChain>(*
this,
Target, Args);
6426 case llvm::Triple::wasm32:
6427 case llvm::Triple::wasm64:
6428 TC = std::make_unique<toolchains::WebAssembly>(*
this,
Target, Args);
6430 case llvm::Triple::avr:
6431 TC = std::make_unique<toolchains::AVRToolChain>(*
this,
Target, Args);
6433 case llvm::Triple::msp430:
6434 TC = std::make_unique<toolchains::MSP430ToolChain>(*
this,
Target, Args);
6436 case llvm::Triple::riscv32:
6437 case llvm::Triple::riscv64:
6438 case llvm::Triple::riscv32be:
6439 case llvm::Triple::riscv64be:
6440 TC = std::make_unique<toolchains::BareMetal>(*
this,
Target, Args);
6442 case llvm::Triple::ve:
6443 TC = std::make_unique<toolchains::VEToolChain>(*
this,
Target, Args);
6445 case llvm::Triple::spirv32:
6446 case llvm::Triple::spirv64:
6447 TC = std::make_unique<toolchains::SPIRVToolChain>(*
this,
Target, Args);
6449 case llvm::Triple::csky:
6450 TC = std::make_unique<toolchains::CSKYToolChain>(*
this,
Target, Args);
6452 case llvm::Triple::amdgpu:
6453 case llvm::Triple::r600:
6454 TC = std::make_unique<toolchains::AMDGPUToolChain>(*
this,
Target, Args);
6458 TC = std::make_unique<toolchains::BareMetal>(*
this,
Target, Args);
6459 else if (
Target.isOSBinFormatELF())
6460 TC = std::make_unique<toolchains::Generic_ELF>(*
this,
Target, Args);
6461 else if (
Target.isAppleFirmware())
6462 TC = std::make_unique<toolchains::DarwinClang>(*
this,
Target, Args);
6463 else if (
Target.isAppleMachO())
6464 TC = std::make_unique<toolchains::AppleMachO>(*
this,
Target, Args);
6465 else if (
Target.isOSBinFormatMachO())
6466 TC = std::make_unique<toolchains::MachO>(*
this,
Target, Args);
6468 TC = std::make_unique<toolchains::Generic_GCC>(*
this,
Target, Args);
6478 if (JA.
size() != 1 ||
6493 if (JA.
size() != 1 ||
6507 if (Args.hasArg(options::OPT_emit_static_lib))
6518 unsigned &Micro,
bool &HadExtra) {
6521 Major = Minor = Micro = 0;
6525 if (Str.consumeInteger(10, Major))
6529 if (!Str.consume_front(
"."))
6532 if (Str.consumeInteger(10, Minor))
6536 if (!Str.consume_front(
"."))
6539 if (Str.consumeInteger(10, Micro))
6557 unsigned CurDigit = 0;
6558 while (CurDigit < Digits.size()) {
6560 if (Str.consumeInteger(10, Digit))
6562 Digits[CurDigit] = Digit;
6565 if (!Str.consume_front(
"."))
6574llvm::opt::Visibility
6575Driver::getOptionVisibilityMask(
bool UseDriverMode)
const {
6587const char *Driver::getExecutableForDriverMode(DriverMode Mode) {
6603 llvm_unreachable(
"Unhandled Mode");
6607 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group,
false);
6612 if (Args.hasFlag(options::OPT_fsave_optimization_record,
6613 options::OPT_fno_save_optimization_record,
false))
6617 if (Args.hasFlag(options::OPT_fsave_optimization_record_EQ,
6618 options::OPT_fno_save_optimization_record,
false))
6622 if (Args.hasFlag(options::OPT_foptimization_record_file_EQ,
6623 options::OPT_fno_save_optimization_record,
false))
6627 if (Args.hasFlag(options::OPT_foptimization_record_passes_EQ,
6628 options::OPT_fno_save_optimization_record,
false))
6635 static StringRef OptName =
6637 llvm::StringRef Opt;
6638 for (StringRef Arg : Args) {
6639 if (!Arg.starts_with(OptName))
6645 return Opt.consume_front(OptName) ? Opt :
"";
6652 llvm::BumpPtrAllocator &Alloc,
6653 llvm::vfs::FileSystem *FS) {
6662 for (
const char *F : Args) {
6663 if (strcmp(F,
"--rsp-quoting=posix") == 0)
6665 else if (strcmp(F,
"--rsp-quoting=windows") == 0)
6666 RSPQuoting = Windows;
6672 bool MarkEOLs = ClangCLMode;
6674 llvm::cl::TokenizerCallback Tokenizer;
6675 if (RSPQuoting == Windows || (RSPQuoting ==
Default && ClangCLMode))
6676 Tokenizer = &llvm::cl::TokenizeWindowsCommandLine;
6678 Tokenizer = &llvm::cl::TokenizeGNUCommandLine;
6680 if (MarkEOLs && Args.size() > 1 && StringRef(Args[1]).starts_with(
"-cc1"))
6683 llvm::cl::ExpansionContext ECtx(Alloc, Tokenizer, FS);
6684 ECtx.setMarkEOLs(MarkEOLs);
6686 if (llvm::Error Err = ECtx.expandResponseFiles(Args))
6690 auto FirstArg = llvm::find_if(llvm::drop_begin(Args),
6691 [](
const char *A) {
return A !=
nullptr; });
6692 if (FirstArg != Args.end() && StringRef(*FirstArg).starts_with(
"-cc1")) {
6695 auto newEnd = std::remove(Args.begin(), Args.end(),
nullptr);
6696 Args.resize(newEnd - Args.begin());
6700 return llvm::Error::success();
6704 return SavedStrings.insert(S).first->getKeyData();
6738 llvm::StringSet<> &SavedStrings) {
6741 if (Edit[0] ==
'^') {
6742 const char *Str =
GetStableCStr(SavedStrings, Edit.substr(1));
6743 OS <<
"### Adding argument " << Str <<
" at beginning\n";
6744 Args.insert(Args.begin() + 1, Str);
6745 }
else if (Edit[0] ==
'+') {
6746 const char *Str =
GetStableCStr(SavedStrings, Edit.substr(1));
6747 OS <<
"### Adding argument " << Str <<
" at end\n";
6748 Args.push_back(Str);
6749 }
else if (Edit[0] ==
's' && Edit[1] ==
'/' && Edit.ends_with(
"/") &&
6750 Edit.slice(2, Edit.size() - 1).contains(
'/')) {
6751 StringRef MatchPattern = Edit.substr(2).split(
'/').first;
6752 StringRef ReplPattern = Edit.substr(2).split(
'/').second;
6753 ReplPattern = ReplPattern.slice(0, ReplPattern.size() - 1);
6755 for (
unsigned i = 1, e = Args.size(); i != e; ++i) {
6757 if (Args[i] ==
nullptr)
6759 std::string Repl = llvm::Regex(MatchPattern).sub(ReplPattern, Args[i]);
6761 if (Repl != Args[i]) {
6762 OS <<
"### Replacing '" << Args[i] <<
"' with '" << Repl <<
"'\n";
6766 }
else if (Edit[0] ==
'x' || Edit[0] ==
'X') {
6767 auto Option = Edit.substr(1);
6768 for (
unsigned i = 1; i < Args.size();) {
6769 if (Option == Args[i]) {
6770 OS <<
"### Deleting argument " << Args[i] <<
'\n';
6771 Args.erase(Args.begin() + i);
6772 if (Edit[0] ==
'X') {
6773 if (i < Args.size()) {
6774 OS <<
"### Deleting argument " << Args[i] <<
'\n';
6775 Args.erase(Args.begin() + i);
6777 OS <<
"### Invalid X edit, end of command line!\n";
6782 }
else if (Edit[0] ==
'O') {
6783 for (
unsigned i = 1; i < Args.size();) {
6784 const char *A = Args[i];
6788 if (A[0] ==
'-' && A[1] ==
'O' &&
6789 (A[2] ==
'\0' || (A[3] ==
'\0' && (A[2] ==
's' || A[2] ==
'z' ||
6790 (
'0' <= A[2] && A[2] <=
'9'))))) {
6791 OS <<
"### Deleting argument " << Args[i] <<
'\n';
6792 Args.erase(Args.begin() + i);
6796 OS <<
"### Adding argument " << Edit <<
" at end\n";
6797 Args.push_back(
GetStableCStr(SavedStrings,
'-' + Edit.str()));
6799 OS <<
"### Unrecognized edit: " << Edit <<
"\n";
6804 const char *OverrideStr,
6805 llvm::StringSet<> &SavedStrings,
6806 StringRef EnvVar, raw_ostream *OS) {
6808 OS = &llvm::nulls();
6810 if (OverrideStr[0] ==
'#') {
6812 OS = &llvm::nulls();
6815 *OS <<
"### " << EnvVar <<
": " << OverrideStr <<
"\n";
6819 const char *S = OverrideStr;
6821 const char *End = ::strchr(S,
' ');
6823 End = S + strlen(S);
static Decl::Kind getKind(const Decl *D)
static std::string getOffloadDeviceCC1ParallelJobGroup(const Command &Job)
static llvm::SmallVector< std::string > getSystemOffloadArchs(Compilation &C, Action::OffloadKind Kind)
static void applyOneOverrideOption(raw_ostream &OS, SmallVectorImpl< const char * > &Args, StringRef Edit, llvm::StringSet<> &SavedStrings)
Apply a list of edits to the input argument lists.
static void printCXXStdlibIncludeDirs(const ToolChain &TC, const ArgList &Args)
static bool HasPreprocessOutput(const Action &JA)
std::multiset< llvm::Triple > TripleSet
static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args)
static const char BugReportMsg[]
static std::string GetTriplePlusArchString(const ToolChain *TC, BoundArch BA, Action::OffloadKind OffloadKind)
Return a string that uniquely identifies the result of a job.
static void markOffloadDeviceCC1JobsForParallelExecution(Compilation &C)
static const char * GetModuleOutputPath(Compilation &C, const JobAction &JA, const char *BaseInput)
static const char * MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, StringRef BaseName, types::ID FileType)
Create output filename based on ArgValue, which could either be a full filename, filename without ext...
static bool isIncludeDirArg(StringRef Arg)
static void handleTimeTrace(Compilation &C, const ArgList &Args, const JobAction *JA, const char *BaseInput, const InputInfo &Result)
static unsigned PrintActions1(const Compilation &C, Action *A, std::map< Action *, unsigned > &Ids, Twine Indent={}, int Kind=TopLevelAction)
static bool isPlainSPIRV(const llvm::Triple &Triple)
static StringRef getCanonicalArchString(Compilation &C, const llvm::opt::DerivedArgList &Args, StringRef ArchStr, const llvm::Triple &Triple, Action::OffloadKind Kind)
Returns the canonical name for the offloading architecture ArchStr on Triple, or an empty string afte...
static void PrintDiagnosticCategories(raw_ostream &OS)
PrintDiagnosticCategories - Implement the –print-diagnostic-categories option.
static bool ContainsCompileOrAssembleAction(const Action *A)
Check whether the given input tree contains any compilation or assembly actions.
static std::optional< std::pair< llvm::StringRef, llvm::StringRef > > getConflictOffloadArchCombination(const llvm::DenseSet< StringRef > &Archs, llvm::Triple Triple)
Checks if the set offloading architectures does not conflict.
static llvm::Triple computeTargetTriple(const Driver &D, StringRef TargetTriple, const ArgList &Args, StringRef ArchName="")
Compute target triple from args.
static const char * GetStableCStr(llvm::StringSet<> &SavedStrings, StringRef S)
static bool shouldBundleHIPAsm(const Compilation &C, const llvm::opt::DerivedArgList &Args, const Driver &D)
HIP non-RDC -S for AMDGCN: emit host and device assembly separately and bundle with clang-offload-bun...
static bool isOffloadDeviceCC1JobCandidate(Command &Job)
static bool findTripleConfigFile(llvm::cl::ExpansionContext &ExpCtx, SmallString< 128 > &ConfigFilePath, llvm::Triple Triple, std::string Suffix)
static bool ScanDirForExecutable(SmallString< 128 > &Dir, StringRef Name)
static void claimAndDiagnoseOffloadJobs(const Driver &D, const ArgList &Args)
static llvm::Triple getSYCLDefaultTriple(const llvm::Triple &HostTriple)
static TripleSet inferOffloadToolchains(Compilation &C, Action::OffloadKind Kind)
static bool usesInput(const ArgList &Args, F &&Fn)
static void setZosTargetVersion(const Driver &D, llvm::Triple &Target, StringRef ArgTarget)
static void appendOneArg(InputArgList &Args, const Arg *Opt)
static types::ID CXXHeaderUnitType(ModuleHeaderMode HM)
Result
Implement __builtin_bit_cast and related operations.
llvm::MachO::FileType FileType
llvm::MachO::Target Target
This file defines functionality to support driver managed builds for compilations which use Clang mod...
static bool hasFlag(SVal val, ProgramStateRef state)
This file pulls in all built-in SSAF extractor and format registrations by referencing their anchor s...
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines version macros and version-related utility functions for Clang.
__DEVICE__ int max(int __a, int __b)
RAII class that determines when any errors have occurred between the time the instance was created an...
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
static StringRef getCategoryNameFromID(unsigned CategoryID)
Given a category ID, return the name of the category.
static unsigned getNumberOfCategories()
Return the number of diagnostic categories.
static std::vector< std::string > getDiagnosticFlags()
Get the string of all diagnostic flags.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
A processor an offloading action can target.
static constexpr OffloadArch getUnused()
static constexpr OffloadArch getGeneric()
static OffloadArch CudaDefault()
Default architectures used when the user does not specify one.
static OffloadArch HIPDefault()
static constexpr OffloadArch getUnknown()
Encodes a location in the source.
Exposes information about the current target.
Action - Represent an abstract compilation step to perform.
bool isCollapsingWithNextDependentActionLegal() const
Return true if this function can be collapsed with others.
types::ID getType() const
void setCannotBeCollapsedWithNextDependentAction()
Mark this action as not legal to collapse.
std::string getOffloadingKindPrefix() const
Return a string containing the offload kind of the action.
const ToolChain * getOffloadingToolChain() const
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
BoundArch getOffloadingArch() const
ActionClass getKind() const
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
const char * getClassName() const
OffloadKind getOffloadingDeviceKind() const
input_iterator input_begin()
void propagateDeviceOffloadInfo(OffloadKind OKind, BoundArch OArch, const ToolChain *OToolChain)
Set the device offload info of this action and propagate it to its dependences.
void propagateHostOffloadInfo(unsigned OKinds, BoundArch OArch)
Append the host offload info of this action and propagate it to its dependences.
@ BinaryTranslatorJobClass
unsigned getOffloadingHostActiveKinds() const
Options for specifying CUID used by CUDA/HIP for uniquely identifying compilation units.
std::string getCUID(StringRef InputFile, llvm::opt::DerivedArgList &Args) const
static const char * translateMacroDefinition(const char *Value, const llvm::opt::ArgList &Args)
Normalize MSVC's '#' macro separator, also used by Clang targeting MSVC and by arguments parsed after...
Command - An executable path/name and argument vector to execute.
const Action & getSource() const
getSource - Return the Action which caused the creation of this job.
const std::vector< std::string > & getOutputFilenames() const
const Tool & getCreator() const
getCreator - Return the Tool which caused the creation of this job.
void setBoundArch(BoundArch BA)
const llvm::opt::ArgStringList & getArguments() const
void setResponseFile(const char *FileName)
Set to pass arguments via a response file when launching the command.
std::optional< llvm::sys::ProcessStatistics > getProcessStatistics() const
const char * getExecutable() const
virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const
const ResponseFileSupport & getResponseFileSupport()
Returns the kind of response file supported by the current invocation.
void replaceArguments(llvm::opt::ArgStringList List)
BoundArch getBoundArch() const
Return the bound architecture for this command, if any.
virtual int Execute(ArrayRef< std::optional< StringRef > > Redirects, std::string *ErrMsg, bool *ExecutionFailed) const
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
llvm::SmallVector< BoundArch > getOffloadArchs(Compilation &C, const llvm::opt::DerivedArgList &Args, Action::OffloadKind Kind, const ToolChain &TC) const
Returns the set of bound architectures active for this offload kind.
std::string SysRoot
sysroot, if present
std::string UserConfigDir
User directory for config files.
void BuildUniversalActions(Compilation &C, const ToolChain &TC, const InputList &BAInputs) const
BuildUniversalActions - Construct the list of actions to perform for the given arguments,...
void PrintHelp(bool ShowHidden) const
PrintHelp - Print the help text.
bool offloadDeviceOnly() const
bool isSaveTempsEnabled() const
void BuildJobs(Compilation &C) const
BuildJobs - Bind actions to concrete tools and translate arguments to form the list of jobs to run.
std::string GetFilePath(StringRef Name, const ToolChain &TC) const
GetFilePath - Lookup Name in the list of file search paths.
unsigned CCPrintProcessStats
Set CC_PRINT_PROC_STAT mode, which causes the driver to dump performance report to CC_PRINT_PROC_STAT...
DiagnosticsEngine & getDiags() const
void PrintActions(const Compilation &C) const
PrintActions - Print the list of actions.
llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > > executeProgram(llvm::ArrayRef< llvm::StringRef > Args) const
Action * BuildOffloadingActions(Compilation &C, llvm::opt::DerivedArgList &Args, const InputTy &Input, StringRef CUID, Action *HostAction, ActionList *HIPAsmBundleDeviceOut=nullptr) const
BuildOffloadingActions - Construct the list of actions to perform for the offloading toolchain that w...
Action * ConstructPhaseAction(Compilation &C, const llvm::opt::ArgList &Args, phases::ID Phase, Action *Input, Action::OffloadKind TargetDeviceOffloadKind=Action::OFK_None, LTOKind TargetLTOMode=LTOK_None) const
ConstructAction - Construct the appropriate action to do for Phase on the Input, taking in to account...
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
const char * GetNamedOutputPath(Compilation &C, const JobAction &JA, const char *BaseInput, BoundArch BA, bool AtTopLevel, bool MultipleArchs, StringRef NormalizedTriple) const
GetNamedOutputPath - Return the name to use for the output of the action JA.
std::string GetTemporaryDirectory(StringRef Prefix) const
GetTemporaryDirectory - Return the pathname of a temporary directory to use as part of compilation; t...
bool IsDXCMode() const
Whether the driver should follow dxc.exe like behavior.
const char * getDefaultImageName() const
Returns the default name for linked images (e.g., "a.out").
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
std::string DyldPrefix
Dynamic loader prefix, if present.
bool ShouldEmitStaticLibrary(const llvm::opt::ArgList &Args) const
ShouldEmitStaticLibrary - Should the linker emit a static library.
std::string DriverTitle
Driver title to use with help.
unsigned CCCPrintBindings
Only print tool bindings, don't build any jobs.
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args, InputList &Inputs) const
BuildInputs - Construct the list of inputs and their types from the given arguments.
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
bool HandleImmediateArgs(Compilation &C)
HandleImmediateArgs - Handle any arguments which should be treated before building actions or binding...
int ExecuteCompilation(Compilation &C, SmallVectorImpl< std::pair< int, const Command * > > &FailingCommands)
ExecuteCompilation - Execute the compilation according to the command line arguments and return an ap...
DiagnosticBuilder Diag(unsigned DiagID) const
std::string SystemConfigDir
System directory for config files.
ParsedClangName ClangNameParts
Target and driver mode components extracted from clang executable name.
unsigned CCPrintInternalStats
Set CC_PRINT_INTERNAL_STAT mode, which causes the driver to dump internal performance report to CC_PR...
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
std::string Name
The name the driver was invoked as.
Driver(StringRef DriverExecutable, StringRef TargetTriple, DiagnosticsEngine &Diags, std::string Title="clang LLVM compiler", IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
const llvm::opt::OptTable & getOpts() const
void BuildActions(Compilation &C, llvm::opt::DerivedArgList &Args, const InputList &Inputs, ActionList &Actions) const
BuildActions - Construct the list of actions to perform for the given arguments, which are only done ...
bool offloadHostOnly() const
void generateCompilationDiagnostics(Compilation &C, const Command &FailingCommand, StringRef AdditionalInformation="", CompilationDiagnosticReport *GeneratedReport=nullptr)
generateCompilationDiagnostics - Generate diagnostics information including preprocessed source file(...
bool hasHeaderMode() const
Returns true if the user has indicated a C++20 header unit mode.
InputInfoList BuildJobsForAction(Compilation &C, const Action *A, const ToolChain *TC, BoundArch BA, bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput, std::map< std::pair< const Action *, std::string >, InputInfoList > &CachedResults, Action::OffloadKind TargetDeviceOffloadKind) const
BuildJobsForAction - Construct the jobs to perform for the action A and return an InputInfo for the r...
void PrintVersion(const Compilation &C, raw_ostream &OS) const
PrintVersion - Print the driver version.
bool ShouldUseFlangCompiler(const JobAction &JA) const
ShouldUseFlangCompiler - Should the flang compiler be used to handle this action.
bool DiagnoseInputExistence(StringRef Value, types::ID Ty, bool TypoCorrect) const
Check that the file referenced by Value exists.
void CreateOffloadingDeviceToolChains(Compilation &C, InputList &Inputs)
CreateOffloadingDeviceToolChains - create all the toolchains required to support offloading devices g...
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
bool isSaveTempsObj() const
void HandleAutocompletions(StringRef PassedFlags) const
HandleAutocompletions - Handle –autocomplete by searching and printing possible flags,...
std::string ResourceDir
The path to the compiler resource directory.
llvm::vfs::FileSystem & getVFS() const
unsigned CCPrintOptions
Set CC_PRINT_OPTIONS mode, which is like -v but logs the commands to CCPrintOptionsFilename or to std...
bool ShouldUseClangCompiler(const JobAction &JA) const
ShouldUseClangCompiler - Should the clang compiler be used to handle this action.
std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
std::string Dir
The path the driver executable was in, as invoked from the command line.
const char * CreateTempFile(Compilation &C, StringRef Prefix, StringRef Suffix, bool MultipleArchs=false, StringRef BoundArchStr={}, bool NeedUniqueDirectory=false) const
Creates a temp file.
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
@ OMPRT_Unknown
An unknown OpenMP runtime.
@ OMPRT_GOMP
The GNU OpenMP runtime.
std::string getTargetTriple() const
bool getCheckInputsExist() const
phases::ID getFinalPhase(const llvm::opt::ArgList &Args, llvm::opt::Arg **FinalPhaseArg=nullptr) const
std::string GetStdModuleManifestPath(const Compilation &C, const ToolChain &TC) const
Lookup the path to the Standard library module manifest.
bool IsFlangMode() const
Whether the driver should invoke flang for fortran inputs.
Compilation * BuildCompilation(ArrayRef< const char * > Args)
BuildCompilation - Construct a compilation object for a command line argument vector.
std::string DriverExecutable
The original path to the driver executable.
bool embedBitcodeInObject() const
std::string CCPrintStatReportFilename
The file to log CC_PRINT_PROC_STAT_FILE output to, if enabled.
llvm::opt::InputArgList ParseArgStrings(ArrayRef< const char * > Args, bool UseDriverMode, bool &ContainsError) const
ParseArgStrings - Parse the given list of strings into an ArgList.
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
llvm::StringSet expandFlags(const Multilib::flags_list &) const
Get the given flags plus flags found by matching them against the FlagMatchers and choosing the Flags...
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
std::vector< std::string > flags_list
Type used to communicate device actions.
const ActionList & getActions() const
Get each of the individual arrays.
void add(Action &A, const ToolChain &TC, BoundArch BA, OffloadKind OKind)
Add an action along with the associated toolchain, bound arch, and offload kind.
Type used to communicate host actions.
An offload action combines host or/and device actions according to the programming model implementati...
Set a ToolChain's effective triple.
void buildStdModuleManifestInputs(ArrayRef< StdModuleManifest::Module > ManifestEntries, Compilation &C, InputList &Inputs)
Constructs compilation inputs for each module listed in the provided Standard library module manifest...
void runModulesDriver(Compilation &C, ArrayRef< StdModuleManifest::Module > ManifestEntries)
Scans the compilation inputs for module dependencies and adjusts the compilation to build and supply ...
llvm::Expected< StdModuleManifest > readStdModuleManifest(llvm::StringRef ManifestPath, llvm::vfs::FileSystem &VFS)
Reads the Standard library module manifest at ManifestPath.
void diagnoseModulesDriverArgs(llvm::opt::DerivedArgList &DAL, DiagnosticsEngine &Diags)
Emits diagnostics for arguments incompatible with -fmodules-driver.
const char * getPhaseName(ID Id)
ID
ID - Ordered values for successive stages in the compilation process which interact with user options...
ID lookupTypeForTypeSpecifier(const char *Name)
lookupTypeForTypSpecifier - Lookup the type to use for a user specified type name.
bool isHLSL(ID Id)
isHLSL - Is this an HLSL input.
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed,...
bool isCuda(ID Id)
isCuda - Is this a CUDA input.
bool isLLVMIR(ID Id)
Is this LLVM IR.
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
bool isOpenCL(ID Id)
isOpenCL - Is this an "OpenCL" input.
llvm::SmallVector< phases::ID, phases::MaxNumberOfPhases > getCompilationPhases(ID Id, phases::ID LastPhase=phases::IfsMerge)
getCompilationPhases - Get the list of compilation phases ('Phases') to be done for type 'Id' up unti...
bool isSrcFile(ID Id)
isSrcFile - Is this a source file, i.e.
ID lookupCXXTypeForCType(ID Id)
lookupCXXTypeForCType - Lookup CXX input type that corresponds to given C type (used for clang++ emul...
bool isHIP(ID Id)
isHIP - Is this a HIP input.
bool isAcceptedByClang(ID Id)
isAcceptedByClang - Can clang handle this input type.
bool appendSuffixForType(ID Id)
appendSuffixForType - When generating outputs of this type, should the suffix be appended (instead of...
bool canLipoType(ID Id)
canLipoType - Is this type acceptable as the output of a universal build (currently,...
const char * getTypeTempSuffix(ID Id, bool CLStyle=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type,...
ID lookupHeaderTypeForSourceType(ID Id)
Lookup header file input type that corresponds to given source file type (used for clang-cl emulation...
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
bool isAcceptedByFlang(ID Id)
isAcceptedByFlang - Can flang handle this input type.
void applyOverrideOptions(SmallVectorImpl< const char * > &Args, const char *OverrideOpts, llvm::StringSet<> &SavedStrings, StringRef EnvVar, raw_ostream *OS=nullptr)
Apply a space separated list of edits to the input argument lists.
LTOKind
Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.
ModuleHeaderMode
Whether headers used to construct C++20 module units should be looked up by the path supplied on the ...
llvm::opt::Arg * makeInputArg(llvm::opt::DerivedArgList &Args, const llvm::opt::OptTable &Opts, StringRef Value, bool Claim=true)
Creates and adds a synthesized input argument.
SmallVector< InputInfo, 4 > InputInfoList
std::pair< types::ID, const llvm::opt::Arg * > InputTy
A list of inputs and their types for the given arguments.
SmallVector< Action *, 3 > ActionList
ActionList - Type used for lists of actions.
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
llvm::StringRef getDriverMode(StringRef ProgName, ArrayRef< const char * > Args)
Returns the driver mode option's value, i.e.
llvm::Error expandResponseFiles(SmallVectorImpl< const char * > &Args, bool ClangCLMode, llvm::BumpPtrAllocator &Alloc, llvm::vfs::FileSystem *FS=nullptr)
Expand response files from a clang driver or cc1 invocation.
llvm::SmallVector< InputTy, 16 > InputList
A list of inputs and their types for the given arguments.
bool willEmitRemarks(const llvm::opt::ArgList &Args)
bool IsClangCL(StringRef DriverMode)
Checks whether the value produced by getDriverMode is for CL mode.
void printAvailableFormats(llvm::raw_ostream &OS)
Print the list of available serialization formats.
void printAvailableTUSummaryExtractors(llvm::raw_ostream &OS)
Print the list of available TUSummaryExtractors.
Top level wrappers for InstallAPI frontend operations.
bool isa(CodeGen::Address addr)
llvm::Triple::SubArchType getOffloadArchSubArch(OffloadArch ID)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
OffloadArch getSubArchOffloadArch(llvm::Triple::SubArchType SubArch)
std::string getClangToolFullVersion(llvm::StringRef ToolName)
Like getClangFullVersion(), but with a custom tool name.
std::string sanitizeTargetIDInFileName(llvm::StringRef TargetID)
Sanitize a target ID string for use in a file name.
llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch)
Get processor name from target ID.
std::optional< std::pair< llvm::StringRef, llvm::StringRef > > getConflictTargetIDCombination(const std::set< llvm::StringRef > &TargetIDs)
Get the conflicted pair of target IDs for a compilation or a bundled code object, assuming TargetIDs ...
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
raw_ostream & Indent(raw_ostream &Out, const unsigned int Space, bool IsDot)
@ Default
Set to the current date and time.
@ Result
The result type of a method or function.
const FunctionProtoType * T
std::string GetResourcesPath(StringRef BinaryPath)
Get the directory where the compiler headers reside, relative to the compiler binary path BinaryPath.
OffloadArch StringToOffloadArch(llvm::StringRef S)
const char * OffloadArchToString(OffloadArch A)
const llvm::opt::OptTable & getDriverOptTable()
void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)
llvm::Triple OffloadArchToTriple(const llvm::Triple &DefaultToolchainTriple, OffloadArch ID)
std::string getCanonicalTargetID(llvm::StringRef Processor, const llvm::StringMap< bool > &Features)
Returns canonical target ID, assuming Processor is canonical and all entries in Features are valid.
U cast(CodeGen::Address addr)
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
Diagnostic wrappers for TextAPI types for error reporting.
Represents a bound architecture for offload / multiple architecture compilation.
Contains the files in the compilation diagnostic report generated by generateCompilationDiagnostics.
const char * DriverMode
Corresponding driver mode argument, as '–driver-mode=g++'.
ResponseFileKind ResponseKind
The level of support for response files.
The parsed Standard library module manifest.
std::vector< Module > Modules