57 #include "clang/Config/config.h"
69 #include "llvm/ADT/ArrayRef.h"
70 #include "llvm/ADT/STLExtras.h"
71 #include "llvm/ADT/SmallSet.h"
72 #include "llvm/ADT/StringExtras.h"
73 #include "llvm/ADT/StringRef.h"
74 #include "llvm/ADT/StringSet.h"
75 #include "llvm/ADT/StringSwitch.h"
76 #include "llvm/Config/llvm-config.h"
77 #include "llvm/MC/TargetRegistry.h"
78 #include "llvm/Option/Arg.h"
79 #include "llvm/Option/ArgList.h"
80 #include "llvm/Option/OptSpecifier.h"
81 #include "llvm/Option/OptTable.h"
82 #include "llvm/Option/Option.h"
83 #include "llvm/Support/CommandLine.h"
84 #include "llvm/Support/ErrorHandling.h"
85 #include "llvm/Support/ExitCodes.h"
86 #include "llvm/Support/FileSystem.h"
87 #include "llvm/Support/FormatVariadic.h"
88 #include "llvm/Support/Host.h"
89 #include "llvm/Support/MD5.h"
90 #include "llvm/Support/Path.h"
91 #include "llvm/Support/PrettyStackTrace.h"
92 #include "llvm/Support/Process.h"
93 #include "llvm/Support/Program.h"
94 #include "llvm/Support/StringSaver.h"
95 #include "llvm/Support/VirtualFileSystem.h"
96 #include "llvm/Support/raw_ostream.h"
105 using namespace clang;
110 auto OffloadTargets = Args.getAllArgValues(options::OPT_offload_EQ);
114 switch (OffloadTargets.size()) {
116 D.
Diag(diag::err_drv_only_one_offload_target_supported);
119 D.
Diag(diag::err_drv_invalid_or_unsupported_offload_target) <<
"";
124 return llvm::Triple(OffloadTargets[0]);
129 const llvm::Triple &HostTriple) {
130 if (!Args.hasArg(options::OPT_offload_EQ)) {
131 return llvm::Triple(HostTriple.isArch64Bit() ?
"nvptx64-nvidia-cuda"
132 :
"nvptx-nvidia-cuda");
135 if (TT && (TT->getArch() == llvm::Triple::spirv32 ||
136 TT->getArch() == llvm::Triple::spirv64)) {
137 if (Args.hasArg(options::OPT_emit_llvm))
139 D.
Diag(diag::err_drv_cuda_offload_only_emit_bc);
142 D.
Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();
147 if (!Args.hasArg(options::OPT_offload_EQ)) {
148 return llvm::Triple(
"amdgcn-amd-amdhsa");
153 if (TT->getArch() == llvm::Triple::amdgcn &&
154 TT->getVendor() == llvm::Triple::AMD &&
155 TT->getOS() == llvm::Triple::AMDHSA)
157 if (TT->getArch() == llvm::Triple::spirv64)
159 D.
Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();
165 StringRef CustomResourceDir) {
174 if (CustomResourceDir !=
"") {
175 llvm::sys::path::append(
P, CustomResourceDir);
182 P = llvm::sys::path::parent_path(Dir);
183 llvm::sys::path::append(
P, Twine(
"lib") + CLANG_LIBDIR_SUFFIX,
"clang",
184 CLANG_VERSION_STRING);
193 : Diags(Diags), VFS(
std::move(VFS)), Mode(GCCMode),
194 SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
196 LTOMode(
LTOK_None), ClangExecutable(ClangExecutable),
197 SysRoot(DEFAULT_SYSROOT), DriverTitle(Title), CCCPrintBindings(
false),
199 CCGenDiagnostics(
false), CCPrintProcessStats(
false),
200 TargetTriple(TargetTriple), Saver(Alloc), CheckInputsExist(
true),
201 ProbePrecompiled(
true), GenReproducer(
false),
202 SuppressMissingInputWarning(
false) {
205 this->VFS = llvm::vfs::getRealFileSystem();
211 if ((!
SysRoot.empty()) && llvm::sys::path::is_relative(
SysRoot)) {
214 llvm::sys::path::append(
P,
SysRoot);
218 #if defined(CLANG_CONFIG_FILE_SYSTEM_DIR)
221 #if defined(CLANG_CONFIG_FILE_USER_DIR)
229 void Driver::setDriverMode(StringRef
Value) {
231 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
233 .Case(
"gcc", GCCMode)
234 .Case(
"g++", GXXMode)
235 .Case(
"cpp", CPPMode)
237 .Case(
"flang", FlangMode)
238 .Case(
"dxc", DXCMode)
242 Diag(diag::err_drv_unsupported_option_argument) << OptName <<
Value;
247 bool &ContainsError) {
248 llvm::PrettyStackTraceString CrashInfo(
"Command line argument parsing");
249 ContainsError =
false;
251 unsigned IncludedFlagsBitmask;
252 unsigned ExcludedFlagsBitmask;
253 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
254 getIncludeExcludeOptionFlagMasks(IsClCompatMode);
261 unsigned MissingArgIndex, MissingArgCount;
263 getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount,
264 IncludedFlagsBitmask, ExcludedFlagsBitmask);
267 if (MissingArgCount) {
268 Diag(diag::err_drv_missing_argument)
269 << Args.getArgString(MissingArgIndex) << MissingArgCount;
276 for (
const Arg *A : Args) {
279 auto ArgString = A->getAsString(Args);
282 ArgString, Nearest, IncludedFlagsBitmask,
284 DiagID = diag::err_drv_unsupported_opt;
285 Diag(DiagID) << ArgString;
287 DiagID = diag::err_drv_unsupported_opt_with_suggestion;
288 Diag(DiagID) << ArgString << Nearest;
296 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue(
"")) {
297 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
299 diag::warn_drv_empty_joined_argument,
304 for (
const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {
306 auto ArgString = A->getAsString(Args);
309 ArgString, Nearest, IncludedFlagsBitmask, ExcludedFlagsBitmask) > 1) {
310 DiagID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl
311 : diag::err_drv_unknown_argument;
312 Diags.
Report(DiagID) << ArgString;
315 ? diag::warn_drv_unknown_argument_clang_cl_with_suggestion
316 : diag::err_drv_unknown_argument_with_suggestion;
317 Diags.
Report(DiagID) << ArgString << Nearest;
330 Arg **FinalPhaseArg)
const {
331 Arg *PhaseArg =
nullptr;
335 if (
CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
336 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
337 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
338 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P)) ||
345 }
else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile)) ||
346 (PhaseArg = DAL.getLastArg(options::OPT_extract_api)) ||
347 (PhaseArg = DAL.getLastArg(options::OPT_fmodule_header,
348 options::OPT_fmodule_header_EQ))) {
351 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
352 (PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) ||
353 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
354 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
355 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
356 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
357 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
358 (PhaseArg = DAL.getLastArg(options::OPT__analyze)) ||
359 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
363 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
367 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
370 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_emit_interface_stubs))) {
378 *FinalPhaseArg = PhaseArg;
384 StringRef
Value,
bool Claim =
true) {
385 Arg *A =
new Arg(Opts.getOption(options::OPT_INPUT),
Value,
386 Args.getBaseArgs().MakeIndex(
Value),
Value.data());
387 Args.AddSynthesizedArg(A);
393 DerivedArgList *Driver::TranslateInputArgs(
const InputArgList &Args)
const {
394 const llvm::opt::OptTable &Opts =
getOpts();
395 DerivedArgList *DAL =
new DerivedArgList(Args);
397 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
398 bool HasNostdlibxx = Args.hasArg(options::OPT_nostdlibxx);
399 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
400 bool IgnoreUnused =
false;
401 for (Arg *A : Args) {
405 if (A->getOption().matches(options::OPT_start_no_unused_arguments)) {
409 if (A->getOption().matches(options::OPT_end_no_unused_arguments)) {
410 IgnoreUnused =
false;
420 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
421 A->getOption().matches(options::OPT_Xlinker)) &&
422 A->containsValue(
"--no-demangle")) {
424 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_Xlinker__no_demangle));
427 for (StringRef Val : A->getValues())
428 if (Val !=
"--no-demangle")
429 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_Xlinker), Val);
437 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
438 (A->getValue(0) == StringRef(
"-MD") ||
439 A->getValue(0) == StringRef(
"-MMD"))) {
441 if (A->getValue(0) == StringRef(
"-MD"))
442 DAL->AddFlagArg(A, Opts.getOption(options::OPT_MD));
444 DAL->AddFlagArg(A, Opts.getOption(options::OPT_MMD));
445 if (A->getNumValues() == 2)
446 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(1));
451 if (A->getOption().matches(options::OPT_l)) {
452 StringRef
Value = A->getValue();
455 if (!HasNostdlib && !HasNodefaultlib && !HasNostdlibxx &&
457 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_stdcxx));
462 if (
Value ==
"cc_kext") {
463 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_cckext));
469 if (A->getOption().matches(options::OPT__DASH_DASH)) {
471 for (StringRef Val : A->getValues())
480 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false))
481 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_static));
485 #if defined(HOST_LINK_VERSION)
486 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
487 strlen(HOST_LINK_VERSION) > 0) {
488 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mlinker_version_EQ),
490 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
502 StringRef TargetTriple,
504 StringRef DarwinArchName =
"") {
506 if (
const Arg *A = Args.getLastArg(options::OPT_target))
507 TargetTriple = A->getValue();
514 if (TargetTriple.contains(
"-unknown-gnu") || TargetTriple.contains(
"-pc-gnu"))
518 if (
Target.isOSBinFormatMachO()) {
520 if (!DarwinArchName.empty()) {
526 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
527 StringRef ArchName = A->getValue();
534 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
535 options::OPT_mbig_endian)) {
536 if (A->getOption().matches(options::OPT_mlittle_endian)) {
537 llvm::Triple
LE =
Target.getLittleEndianArchVariant();
538 if (
LE.getArch() != llvm::Triple::UnknownArch)
541 llvm::Triple BE =
Target.getBigEndianArchVariant();
542 if (BE.getArch() != llvm::Triple::UnknownArch)
548 if (
Target.getArch() == llvm::Triple::tce ||
549 Target.getOS() == llvm::Triple::Minix)
555 llvm::sys::Process::GetEnv(
"OBJECT_MODE")) {
556 StringRef ObjectMode = *ObjectModeValue;
557 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
559 if (ObjectMode.equals(
"64")) {
560 AT =
Target.get64BitArchVariant().getArch();
561 }
else if (ObjectMode.equals(
"32")) {
562 AT =
Target.get32BitArchVariant().getArch();
564 D.
Diag(diag::err_drv_invalid_object_mode) << ObjectMode;
567 if (AT != llvm::Triple::UnknownArch && AT !=
Target.getArch())
573 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
574 options::OPT_m32, options::OPT_m16);
576 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
578 if (A->getOption().matches(options::OPT_m64)) {
579 AT =
Target.get64BitArchVariant().getArch();
580 if (
Target.getEnvironment() == llvm::Triple::GNUX32)
581 Target.setEnvironment(llvm::Triple::GNU);
582 else if (
Target.getEnvironment() == llvm::Triple::MuslX32)
583 Target.setEnvironment(llvm::Triple::Musl);
584 }
else if (A->getOption().matches(options::OPT_mx32) &&
585 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
586 AT = llvm::Triple::x86_64;
587 if (
Target.getEnvironment() == llvm::Triple::Musl)
588 Target.setEnvironment(llvm::Triple::MuslX32);
590 Target.setEnvironment(llvm::Triple::GNUX32);
591 }
else if (A->getOption().matches(options::OPT_m32)) {
592 AT =
Target.get32BitArchVariant().getArch();
593 if (
Target.getEnvironment() == llvm::Triple::GNUX32)
594 Target.setEnvironment(llvm::Triple::GNU);
595 else if (
Target.getEnvironment() == llvm::Triple::MuslX32)
596 Target.setEnvironment(llvm::Triple::Musl);
597 }
else if (A->getOption().matches(options::OPT_m16) &&
598 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
599 AT = llvm::Triple::x86;
600 Target.setEnvironment(llvm::Triple::CODE16);
603 if (AT != llvm::Triple::UnknownArch && AT !=
Target.getArch()) {
605 if (
Target.isWindowsGNUEnvironment())
611 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
612 if (
Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
613 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-miamcu"
616 if (A && !A->getOption().matches(options::OPT_m32))
617 D.
Diag(diag::err_drv_argument_not_allowed_with)
618 <<
"-miamcu" << A->getBaseArg().getAsString(Args);
620 Target.setArch(llvm::Triple::x86);
621 Target.setArchName(
"i586");
622 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
623 Target.setEnvironmentName(
"");
624 Target.setOS(llvm::Triple::ELFIAMCU);
625 Target.setVendor(llvm::Triple::UnknownVendor);
626 Target.setVendorName(
"intel");
631 A = Args.getLastArg(options::OPT_mabi_EQ);
632 if (A &&
Target.isMIPS()) {
633 StringRef ABIName = A->getValue();
634 if (ABIName ==
"32") {
636 if (
Target.getEnvironment() == llvm::Triple::GNUABI64 ||
637 Target.getEnvironment() == llvm::Triple::GNUABIN32)
638 Target.setEnvironment(llvm::Triple::GNU);
639 }
else if (ABIName ==
"n32") {
641 if (
Target.getEnvironment() == llvm::Triple::GNU ||
642 Target.getEnvironment() == llvm::Triple::GNUABI64)
643 Target.setEnvironment(llvm::Triple::GNUABIN32);
644 }
else if (ABIName ==
"64") {
646 if (
Target.getEnvironment() == llvm::Triple::GNU ||
647 Target.getEnvironment() == llvm::Triple::GNUABIN32)
648 Target.setEnvironment(llvm::Triple::GNUABI64);
654 A = Args.getLastArg(options::OPT_march_EQ);
655 if (A &&
Target.isRISCV()) {
656 StringRef ArchName = A->getValue();
657 if (ArchName.startswith_insensitive(
"rv32"))
658 Target.setArch(llvm::Triple::riscv32);
659 else if (ArchName.startswith_insensitive(
"rv64"))
660 Target.setArch(llvm::Triple::riscv64);
670 OptSpecifier OptEq, OptSpecifier OptNeg) {
671 if (!Args.hasFlag(OptEq, OptNeg,
false))
674 const Arg *A = Args.getLastArg(OptEq);
675 StringRef LTOName = A->getValue();
683 D.
Diag(diag::err_drv_unsupported_option_argument)
684 << A->getOption().getName() << A->getValue();
691 void Driver::setLTOMode(
const llvm::opt::ArgList &Args) {
693 parseLTOMode(*
this, Args, options::OPT_flto_EQ, options::OPT_fno_lto);
695 OffloadLTOMode =
parseLTOMode(*
this, Args, options::OPT_foffload_lto_EQ,
696 options::OPT_fno_offload_lto);
701 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
703 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
705 RuntimeName = A->getValue();
707 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
715 Diag(diag::err_drv_unsupported_option_argument)
716 << A->getOption().getName() << A->getValue();
719 Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
734 llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
739 [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
742 C.getInputArgs().hasArg(options::OPT_hip_link);
743 if (IsCuda && IsHIP) {
744 Diag(clang::diag::err_drv_mix_cuda_hip);
749 const llvm::Triple &HostTriple = HostTC->
getTriple();
757 auto &CudaTC = ToolChains[CudaTriple->str() +
"/" + HostTriple.str()];
759 CudaTC = std::make_unique<toolchains::CudaToolChain>(
760 *
this, *CudaTriple, *HostTC, C.getInputArgs(), OFK);
762 C.addOffloadDeviceToolChain(CudaTC.get(), OFK);
764 if (
auto *OMPTargetArg =
765 C.getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
766 Diag(clang::diag::err_drv_unsupported_opt_for_language_mode)
767 << OMPTargetArg->getSpelling() <<
"HIP";
775 auto *HIPTC = &getOffloadingDeviceToolChain(C.getInputArgs(), *HIPTriple,
777 assert(HIPTC &&
"Could not create offloading device tool chain.");
778 C.addOffloadDeviceToolChain(HIPTC, OFK);
786 bool IsOpenMPOffloading =
787 C.getInputArgs().hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
788 options::OPT_fno_openmp,
false) &&
789 (C.getInputArgs().hasArg(options::OPT_fopenmp_targets_EQ) ||
790 C.getInputArgs().hasArg(options::OPT_offload_arch_EQ));
791 if (IsOpenMPOffloading) {
797 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
801 llvm::StringMap<llvm::DenseSet<StringRef>> DerivedArchs;
802 llvm::StringMap<StringRef> FoundNormalizedTriples;
808 if (Arg *OpenMPTargets =
809 C.getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
810 if (OpenMPTargets && !OpenMPTargets->getNumValues()) {
811 Diag(clang::diag::warn_drv_empty_joined_argument)
812 << OpenMPTargets->getAsString(C.getInputArgs());
815 llvm::copy(OpenMPTargets->getValues(), std::back_inserter(OpenMPTriples));
816 }
else if (C.getInputArgs().hasArg(options::OPT_offload_arch_EQ) &&
827 for (StringRef Arch : Archs) {
830 DerivedArchs[NVPTXTriple->getTriple()].insert(Arch);
831 }
else if (AMDTriple &&
834 DerivedArchs[AMDTriple->getTriple()].insert(Arch);
836 Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch) << Arch;
841 for (
const auto &TripleAndArchs : DerivedArchs)
842 OpenMPTriples.push_back(TripleAndArchs.first());
845 for (StringRef Val : OpenMPTriples) {
850 auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
851 if (Duplicate != FoundNormalizedTriples.end()) {
852 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
853 << Val << Duplicate->second;
859 FoundNormalizedTriples[NormalizedName] = Val;
862 if (TT.getArch() == llvm::Triple::UnknownArch)
863 Diag(clang::diag::err_drv_invalid_omp_target) << Val;
868 if (TT.isNVPTX() || TT.isAMDGCN()) {
871 assert(HostTC &&
"Host toolchain should be always defined.");
873 ToolChains[TT.str() +
"/" + HostTC->
getTriple().normalize()];
876 DeviceTC = std::make_unique<toolchains::CudaToolChain>(
878 else if (TT.isAMDGCN())
879 DeviceTC = std::make_unique<toolchains::AMDGPUOpenMPToolChain>(
880 *
this, TT, *HostTC, C.getInputArgs());
882 assert(DeviceTC &&
"Device toolchain not defined.");
887 TC = &getToolChain(C.getInputArgs(), TT);
889 if (DerivedArchs.find(TT.getTriple()) != DerivedArchs.end())
890 KnownArchs[TC] = DerivedArchs[TT.getTriple()];
893 }
else if (C.getInputArgs().hasArg(options::OPT_fopenmp_targets_EQ)) {
894 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
916 for (
const StringRef &Dir : Dirs) {
920 llvm::sys::path::append(WPath, Dir, FileName);
921 llvm::sys::path::native(WPath);
922 if (llvm::sys::fs::is_regular_file(WPath)) {
923 FilePath = std::move(WPath);
930 bool Driver::readConfigFile(StringRef FileName) {
933 if (!llvm::cl::readConfigFile(FileName, Saver, NewCfgArgs)) {
934 Diag(diag::err_drv_cannot_read_config_file) << FileName;
940 llvm::sys::path::native(CfgFileName);
943 CfgOptions = std::make_unique<InputArgList>(
950 if (CfgOptions->hasArg(options::OPT_config)) {
952 Diag(diag::err_drv_nested_config_file);
958 for (Arg *A : *CfgOptions)
963 bool Driver::loadConfigFile() {
965 bool FileSpecifiedExplicitly =
false;
969 if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
972 CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
973 if (!CfgDir.empty()) {
974 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
980 if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
983 CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ));
984 if (!CfgDir.empty()) {
985 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
995 std::vector<std::string> ConfigFiles =
996 CLOptions->getAllArgValues(options::OPT_config);
997 if (ConfigFiles.size() > 1) {
998 if (!llvm::all_of(ConfigFiles, [ConfigFiles](
const std::string &
s) {
999 return s == ConfigFiles[0];
1001 Diag(diag::err_drv_duplicate_config);
1006 if (!ConfigFiles.empty()) {
1007 CfgFileName = ConfigFiles.front();
1008 assert(!CfgFileName.empty());
1012 if (llvm::sys::path::has_parent_path(CfgFileName)) {
1014 if (llvm::sys::path::is_relative(CfgFileName))
1015 llvm::sys::fs::current_path(CfgFilePath);
1016 llvm::sys::path::append(CfgFilePath, CfgFileName);
1017 if (!llvm::sys::fs::is_regular_file(CfgFilePath)) {
1018 Diag(diag::err_drv_config_file_not_exist) << CfgFilePath;
1021 return readConfigFile(CfgFilePath);
1024 FileSpecifiedExplicitly =
true;
1034 if (CfgFileName.empty())
1038 StringRef CfgFileArch = CfgFileName;
1039 size_t ArchPrefixLen = CfgFileArch.find(
'-');
1040 if (ArchPrefixLen == StringRef::npos)
1041 ArchPrefixLen = CfgFileArch.size();
1042 llvm::Triple CfgTriple;
1043 CfgFileArch = CfgFileArch.take_front(ArchPrefixLen);
1045 if (CfgTriple.getArch() == llvm::Triple::ArchType::UnknownArch)
1048 if (!StringRef(CfgFileName).endswith(
".cfg"))
1049 CfgFileName +=
".cfg";
1055 size_t FixedArchPrefixLen = 0;
1056 if (ArchPrefixLen) {
1061 CfgTriple.getTriple(), *CLOptions);
1062 if (CfgTriple.getArch() != EffectiveTriple.getArch()) {
1063 FixedConfigFile = EffectiveTriple.getArchName();
1064 FixedArchPrefixLen = FixedConfigFile.size();
1067 if (ArchPrefixLen < CfgFileName.size())
1068 FixedConfigFile += CfgFileName.substr(ArchPrefixLen);
1077 if (!FixedConfigFile.empty()) {
1078 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
1079 return readConfigFile(CfgFilePath);
1081 FixedConfigFile.resize(FixedArchPrefixLen);
1082 FixedConfigFile.append(
".cfg");
1083 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
1084 return readConfigFile(CfgFilePath);
1088 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
1089 return readConfigFile(CfgFilePath);
1095 CfgFileName.append(
".cfg");
1096 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
1097 return readConfigFile(CfgFilePath);
1102 if (FileSpecifiedExplicitly) {
1103 Diag(diag::err_drv_config_file_not_found) << CfgFileName;
1104 for (
const StringRef &SearchDir : CfgFileSearchDirs)
1105 if (!SearchDir.empty())
1106 Diag(diag::note_drv_config_file_searched_in) << SearchDir;
1114 llvm::PrettyStackTraceString CrashInfo(
"Compilation construction");
1123 if (!DriverMode.empty())
1124 setDriverMode(DriverMode);
1130 CLOptions = std::make_unique<InputArgList>(
1135 ContainsError = loadConfigFile();
1136 bool HasConfigFile = !ContainsError && (CfgOptions.get() !=
nullptr);
1139 InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
1140 : std::move(*CLOptions));
1145 auto appendOneArg = [&Args](
const Arg *Opt,
const Arg *BaseArg) {
1146 unsigned Index = Args.MakeIndex(Opt->getSpelling());
1147 Arg *Copy =
new llvm::opt::Arg(Opt->getOption(), Args.getArgString(Index),
1149 Copy->getValues() = Opt->getValues();
1150 if (Opt->isClaimed())
1152 Copy->setOwnsValues(Opt->getOwnsValues());
1153 Opt->setOwnsValues(
false);
1158 for (
auto *Opt : *CLOptions) {
1159 if (Opt->getOption().matches(options::OPT_config))
1161 const Arg *BaseArg = &Opt->getBaseArg();
1164 appendOneArg(Opt, BaseArg);
1168 if (
IsCLMode() && !ContainsError) {
1170 for (
const auto *A : Args.filtered(options::OPT__SLASH_clang)) {
1172 CLModePassThroughArgList.push_back(A->getValue());
1175 if (!CLModePassThroughArgList.empty()) {
1178 auto CLModePassThroughOptions = std::make_unique<InputArgList>(
1182 for (
auto *Opt : *CLModePassThroughOptions) {
1183 appendOneArg(Opt,
nullptr);
1189 if (Arg *WD = Args.getLastArg(options::OPT_working_directory))
1190 if (VFS->setCurrentWorkingDirectory(WD->getValue()))
1191 Diag(diag::err_drv_unable_to_set_working_directory) << WD->getValue();
1194 bool CCCPrintPhases;
1200 Args.ClaimAllArgs(options::OPT_canonical_prefixes);
1201 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
1204 Args.ClaimAllArgs(options::OPT_fintegrated_cc1);
1205 Args.ClaimAllArgs(options::OPT_fno_integrated_cc1);
1208 Args.ClaimAllArgs(options::OPT_pipe);
1216 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
1218 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
1219 CCCGenericGCCName = A->getValue();
1221 options::OPT_fno_crash_diagnostics,
1222 !!::getenv(
"FORCE_CLANG_DIAGNOSTICS_CRASH"));
1225 if (
const Arg *A = Args.getLastArg(options::OPT_fproc_stat_report_EQ)) {
1229 if (Args.hasArg(options::OPT_fproc_stat_report))
1236 llvm::Triple T(TargetTriple);
1237 T.setOS(llvm::Triple::Win32);
1238 T.setVendor(llvm::Triple::PC);
1239 T.setEnvironment(llvm::Triple::MSVC);
1240 T.setObjectFormat(llvm::Triple::COFF);
1241 TargetTriple = T.str();
1245 llvm::Triple T(TargetTriple);
1246 T.setOS(llvm::Triple::ShaderModel);
1247 TargetTriple = T.str();
1250 if (
const Arg *A = Args.getLastArg(options::OPT_target))
1251 TargetTriple = A->getValue();
1252 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
1254 for (
const Arg *A : Args.filtered(options::OPT_B)) {
1259 llvm::sys::Process::GetEnv(
"COMPILER_PATH")) {
1260 StringRef CompilerPath = *CompilerPathValue;
1261 while (!CompilerPath.empty()) {
1262 std::pair<StringRef, StringRef>
Split =
1263 CompilerPath.split(llvm::sys::EnvPathSeparator);
1265 CompilerPath =
Split.second;
1268 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1270 if (
const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
1273 if (
const Arg *A = Args.getLastArg(options::OPT_resource_dir))
1276 if (
const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
1277 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
1278 .Case(
"cwd", SaveTempsCwd)
1279 .Case(
"obj", SaveTempsObj)
1280 .Default(SaveTempsCwd);
1286 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
1287 StringRef
Name = A->getValue();
1288 unsigned Model = llvm::StringSwitch<unsigned>(
Name)
1289 .Case(
"off", EmbedNone)
1290 .Case(
"all", EmbedBitcode)
1291 .Case(
"bitcode", EmbedBitcode)
1292 .Case(
"marker", EmbedMarker)
1295 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1298 BitcodeEmbed =
static_cast<BitcodeEmbedMode
>(Model);
1305 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ);
1307 !Args.hasArg(options::OPT_fmodules) &&
Std &&
1308 (
Std->containsValue(
"c++20") ||
Std->containsValue(
"c++2b") ||
1309 Std->containsValue(
"c++2a") ||
Std->containsValue(
"c++latest"));
1312 if (Arg *A = Args.getLastArg(options::OPT_fmodule_header_EQ,
1313 options::OPT_fmodule_header)) {
1315 ModulesModeCXX20 =
true;
1316 if (A->getOption().matches(options::OPT_fmodule_header))
1319 StringRef ArgName = A->getValue();
1320 unsigned Kind = llvm::StringSwitch<unsigned>(ArgName)
1325 Diags.
Report(diag::err_drv_invalid_value)
1326 << A->getAsString(Args) << ArgName;
1332 std::unique_ptr<llvm::opt::InputArgList> UArgs =
1333 std::make_unique<InputArgList>(std::move(Args));
1336 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
1351 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
1358 if (TC.
getTriple().isOSBinFormatMachO())
1361 BuildActions(*C, C->getArgs(), Inputs, C->getActions());
1363 if (CCCPrintPhases) {
1373 static void printArgList(raw_ostream &OS,
const llvm::opt::ArgList &Args) {
1374 llvm::opt::ArgStringList ASL;
1375 for (
const auto *A : Args) {
1379 while (A->getAlias())
1381 A->render(Args, ASL);
1384 for (
auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
1385 if (I != ASL.begin())
1387 llvm::sys::printArg(OS, *I,
true);
1392 bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename,
1394 using namespace llvm::sys;
1395 assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&
1396 "Only knows about .crash files on Darwin");
1401 path::home_directory(CrashDiagDir);
1402 if (CrashDiagDir.startswith(
"/var/root"))
1404 path::append(CrashDiagDir,
"Library/Logs/DiagnosticReports");
1412 fs::file_status FileStatus;
1413 TimePoint<> LastAccessTime;
1417 for (fs::directory_iterator
File(CrashDiagDir, EC), FileEnd;
1418 File != FileEnd && !EC;
File.increment(EC)) {
1419 StringRef FileName = path::filename(
File->path());
1420 if (!FileName.startswith(
Name))
1422 if (fs::status(
File->path(), FileStatus))
1424 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
1425 llvm::MemoryBuffer::getFile(
File->path());
1430 StringRef Data = CrashFile.get()->getBuffer();
1431 if (!Data.startswith(
"Process:"))
1434 size_t ParentProcPos = Data.find(
"Parent Process:");
1435 if (ParentProcPos == StringRef::npos)
1437 size_t LineEnd = Data.find_first_of(
"\n", ParentProcPos);
1438 if (LineEnd == StringRef::npos)
1440 StringRef ParentProcess = Data.slice(ParentProcPos+15, LineEnd).trim();
1441 int OpenBracket = -1, CloseBracket = -1;
1442 for (
size_t i = 0, e = ParentProcess.size(); i < e; ++i) {
1443 if (ParentProcess[i] ==
'[')
1445 if (ParentProcess[i] ==
']')
1451 if (OpenBracket < 0 || CloseBracket < 0 ||
1452 ParentProcess.slice(OpenBracket + 1, CloseBracket)
1453 .getAsInteger(10, CrashPID) || CrashPID != PID) {
1463 const auto FileAccessTime = FileStatus.getLastModificationTime();
1464 if (FileAccessTime > LastAccessTime) {
1465 CrashFilePath.assign(
File->path());
1466 LastAccessTime = FileAccessTime;
1471 if (!CrashFilePath.empty()) {
1472 EC = fs::copy_file(CrashFilePath, ReproCrashFilename);
1487 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
1509 C.initCompilationForDiagnostics();
1513 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
1515 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
1516 bool IgnoreInput =
false;
1522 }
else if (!strcmp(it->second->getValue(),
"-")) {
1523 Diag(clang::diag::note_drv_command_failed_diag_msg)
1524 <<
"Error generating preprocessed source(s) - "
1525 "ignoring input from stdin.";
1530 it = Inputs.erase(it);
1537 if (Inputs.empty()) {
1538 Diag(clang::diag::note_drv_command_failed_diag_msg)
1539 <<
"Error generating preprocessed source(s) - "
1540 "no preprocessable inputs.";
1546 llvm::StringSet<> ArchNames;
1547 for (
const Arg *A : C.getArgs()) {
1548 if (A->getOption().matches(options::OPT_arch)) {
1549 StringRef ArchName = A->getValue();
1550 ArchNames.insert(ArchName);
1553 if (ArchNames.size() > 1) {
1554 Diag(clang::diag::note_drv_command_failed_diag_msg)
1555 <<
"Error generating preprocessed source(s) - cannot generate "
1556 "preprocessed source with multiple -arch options.";
1562 const ToolChain &TC = C.getDefaultToolChain();
1563 if (TC.
getTriple().isOSBinFormatMachO())
1572 Diag(clang::diag::note_drv_command_failed_diag_msg)
1573 <<
"Error generating preprocessed source(s).";
1579 C.ExecuteJobs(C.getJobs(), FailingCommands);
1582 if (!FailingCommands.empty()) {
1583 Diag(clang::diag::note_drv_command_failed_diag_msg)
1584 <<
"Error generating preprocessed source(s).";
1588 const ArgStringList &TempFiles = C.getTempFiles();
1589 if (TempFiles.empty()) {
1590 Diag(clang::diag::note_drv_command_failed_diag_msg)
1591 <<
"Error generating preprocessed source(s).";
1595 Diag(clang::diag::note_drv_command_failed_diag_msg)
1596 <<
"\n********************\n\n"
1597 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
1598 "Preprocessed source(s) and associated run script(s) are located at:";
1602 for (
const char *TempFile : TempFiles) {
1603 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
1606 if (ReproCrashFilename.empty()) {
1607 ReproCrashFilename = TempFile;
1608 llvm::sys::path::replace_extension(ReproCrashFilename,
".crash");
1610 if (StringRef(TempFile).endswith(
".cache")) {
1613 VFS = llvm::sys::path::filename(TempFile);
1614 llvm::sys::path::append(VFS,
"vfs",
"vfs.yaml");
1622 llvm::sys::path::replace_extension(Script,
"sh");
1624 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::CD_CreateNew,
1625 llvm::sys::fs::FA_Write,
1626 llvm::sys::fs::OF_Text);
1628 Diag(clang::diag::note_drv_command_failed_diag_msg)
1629 <<
"Error generating run script: " << Script <<
" " << EC.message();
1632 <<
"# Driver args: ";
1634 ScriptOS <<
"# Original command: ";
1635 Cmd.Print(ScriptOS,
"\n",
true);
1636 Cmd.Print(ScriptOS,
"\n",
true, &CrashInfo);
1637 if (!AdditionalInformation.empty())
1638 ScriptOS <<
"\n# Additional information: " << AdditionalInformation
1642 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
1646 if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) {
1648 if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) {
1649 Diag(clang::diag::note_drv_command_failed_diag_msg)
1650 << ReproCrashFilename.str();
1652 llvm::sys::path::append(CrashDiagDir,
Name);
1653 CrashDiagDir +=
"_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
1654 Diag(clang::diag::note_drv_command_failed_diag_msg)
1655 <<
"Crash backtrace is located in";
1656 Diag(clang::diag::note_drv_command_failed_diag_msg)
1657 << CrashDiagDir.str();
1658 Diag(clang::diag::note_drv_command_failed_diag_msg)
1659 <<
"(choose the .crash file that corresponds to your crash)";
1663 for (
const auto &A : C.getArgs().filtered(options::OPT_frewrite_map_file_EQ))
1664 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
1666 Diag(clang::diag::note_drv_command_failed_diag_msg)
1667 <<
"\n\n********************";
1675 if (
Cmd.getResponseFileSupport().ResponseKind ==
1677 llvm::sys::commandLineFitsWithinSystemLimits(
Cmd.getExecutable(),
1678 Cmd.getArguments()))
1682 Cmd.setResponseFile(C.addTempFile(C.getArgs().MakeArgString(TmpName)));
1689 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1690 C.getJobs().Print(llvm::errs(),
"\n",
true);
1699 for (
auto &Job : C.getJobs())
1700 setUpResponseFiles(C, Job);
1702 C.ExecuteJobs(C.getJobs(), FailingCommands);
1705 if (FailingCommands.empty())
1711 for (
const auto &CmdPair : FailingCommands) {
1712 int CommandRes = CmdPair.first;
1713 const Command *FailingCommand = CmdPair.second;
1718 C.CleanupFileMap(C.getResultFiles(), JA,
true);
1722 C.CleanupFileMap(C.getFailureResultFiles(), JA,
true);
1728 if (CommandRes == EX_IOERR) {
1746 Diag(clang::diag::err_drv_command_signalled)
1749 Diag(clang::diag::err_drv_command_failed)
1757 unsigned IncludedFlagsBitmask;
1758 unsigned ExcludedFlagsBitmask;
1759 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
1760 getIncludeExcludeOptionFlagMasks(
IsCLMode());
1764 ExcludedFlagsBitmask |= HelpHidden;
1771 std::string Usage = llvm::formatv(
"{0} [options] file...",
Name).str();
1773 IncludedFlagsBitmask, ExcludedFlagsBitmask,
1785 const ToolChain &TC = C.getDefaultToolChain();
1789 if (Arg *A = C.getArgs().getLastArg(options::OPT_mthread_model)) {
1792 OS <<
"Thread model: " << A->getValue();
1801 if (!ConfigFile.empty())
1802 OS <<
"Configuration file: " << ConfigFile <<
'\n';
1815 if (PassedFlags ==
"")
1819 std::vector<std::string> SuggestedCompletions;
1820 std::vector<std::string> Flags;
1822 unsigned int DisableFlags =
1833 const bool HasSpace = PassedFlags.endswith(
",");
1837 StringRef TargetFlags = PassedFlags;
1838 while (TargetFlags !=
"") {
1840 std::tie(CurFlag, TargetFlags) = TargetFlags.split(
",");
1846 if (llvm::is_contained(Flags,
"-Xclang") || llvm::is_contained(Flags,
"-cc1"))
1849 const llvm::opt::OptTable &Opts =
getOpts();
1851 Cur = Flags.at(Flags.size() - 1);
1853 if (Flags.size() >= 2) {
1854 Prev = Flags.at(Flags.size() - 2);
1855 SuggestedCompletions = Opts.suggestValueCompletions(Prev, Cur);
1858 if (SuggestedCompletions.empty())
1859 SuggestedCompletions = Opts.suggestValueCompletions(Cur,
"");
1866 if (SuggestedCompletions.empty() && HasSpace && !Flags.empty()) {
1867 llvm::outs() <<
'\n';
1873 if (SuggestedCompletions.empty() && !Cur.endswith(
"=")) {
1877 SuggestedCompletions = Opts.findByPrefix(Cur, DisableFlags);
1883 if (S.startswith(Cur))
1891 llvm::sort(SuggestedCompletions, [](StringRef A, StringRef B) {
1892 if (
int X = A.compare_insensitive(B))
1894 return A.compare(B) > 0;
1897 llvm::outs() << llvm::join(SuggestedCompletions,
"\n") <<
'\n';
1904 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
1905 llvm::outs() << C.getDefaultToolChain().getTripleString() <<
'\n';
1909 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
1912 llvm::outs() << CLANG_VERSION_STRING <<
"\n";
1916 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
1921 if (C.getArgs().hasArg(options::OPT_help) ||
1922 C.getArgs().hasArg(options::OPT__help_hidden)) {
1923 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
1927 if (C.getArgs().hasArg(options::OPT__version)) {
1933 if (C.getArgs().hasArg(options::OPT_v) ||
1934 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
1935 C.getArgs().hasArg(options::OPT_print_supported_cpus)) {
1937 SuppressMissingInputWarning =
true;
1940 if (C.getArgs().hasArg(options::OPT_v)) {
1942 llvm::errs() <<
"System configuration file directory: "
1945 llvm::errs() <<
"User configuration file directory: "
1949 const ToolChain &TC = C.getDefaultToolChain();
1951 if (C.getArgs().hasArg(options::OPT_v))
1954 if (C.getArgs().hasArg(options::OPT_print_resource_dir)) {
1959 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
1960 llvm::outs() <<
"programs: =";
1961 bool separator =
false;
1965 llvm::outs() << llvm::sys::EnvPathSeparator;
1966 llvm::outs() << Path;
1971 llvm::outs() << llvm::sys::EnvPathSeparator;
1972 llvm::outs() << Path;
1975 llvm::outs() <<
"\n";
1978 StringRef sysroot = C.getSysRoot();
1982 llvm::outs() << llvm::sys::EnvPathSeparator;
1985 llvm::outs() << sysroot << Path.substr(1);
1987 llvm::outs() << Path;
1989 llvm::outs() <<
"\n";
1993 if (C.getArgs().hasArg(options::OPT_print_runtime_dir)) {
1997 if (
getVFS().exists(Path)) {
2002 if (!RuntimePath.empty())
2003 llvm::outs() << RuntimePath <<
'\n';
2011 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
2012 llvm::outs() <<
GetFilePath(A->getValue(), TC) <<
"\n";
2016 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
2017 StringRef ProgName = A->getValue();
2020 if (! ProgName.empty())
2023 llvm::outs() <<
"\n";
2027 if (Arg *A = C.getArgs().getLastArg(options::OPT_autocomplete)) {
2028 StringRef PassedFlags = A->getValue();
2033 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
2039 llvm::outs() << TC.
getCompilerRT(C.getArgs(),
"builtins") <<
"\n";
2042 llvm::outs() <<
GetFilePath(
"libgcc.a", TC) <<
"\n";
2048 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
2054 if (C.getArgs().hasArg(options::OPT_print_multi_directory)) {
2057 llvm::outs() <<
".\n";
2060 assert(Suffix.front() ==
'/');
2061 llvm::outs() << Suffix.substr(1) <<
"\n";
2066 if (C.getArgs().hasArg(options::OPT_print_target_triple)) {
2071 if (C.getArgs().hasArg(options::OPT_print_effective_triple)) {
2073 llvm::outs() << Triple.getTriple() <<
"\n";
2077 if (C.getArgs().hasArg(options::OPT_print_multiarch)) {
2083 if (C.getArgs().hasArg(options::OPT_print_targets)) {
2084 llvm::TargetRegistry::printRegisteredTargetsForVersion(llvm::outs());
2101 std::map<Action *, unsigned> &Ids,
2107 llvm::raw_string_ostream os(str);
2109 auto getSibIndent = [](
int K) -> Twine {
2113 Twine SibIndent =
Indent + getSibIndent(
Kind);
2117 os <<
"\"" << IA->getInputArg().getValue() <<
"\"";
2119 os <<
'"' << BIA->getArchName() <<
'"' <<
", {"
2120 <<
PrintActions1(C, *BIA->input_begin(), Ids, SibIndent, SibKind) <<
"}";
2121 }
else if (
OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
2122 bool IsFirst =
true;
2123 OA->doOnEachDependence(
2125 assert(TC &&
"Unknown host toolchain");
2137 os <<
":" << BoundArch;
2140 os <<
" {" <<
PrintActions1(C, A, Ids, SibIndent, SibKind) <<
"}";
2148 const char *Prefix =
"{";
2149 for (
Action *PreRequisite : *AL) {
2150 os << Prefix <<
PrintActions1(C, PreRequisite, Ids, SibIndent, SibKind);
2162 llvm::raw_string_ostream offload_os(offload_str);
2163 if (!isa<OffloadAction>(A)) {
2166 offload_os <<
", (" << S;
2173 auto getSelfIndent = [](
int K) -> Twine {
2177 unsigned Id = Ids.size();
2179 llvm::errs() <<
Indent + getSelfIndent(
Kind) <<
Id <<
": " << os.str() <<
", "
2188 std::map<Action *, unsigned> Ids;
2189 for (
Action *A : C.getActions())
2196 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
2197 isa<AssembleJobAction>(A))
2205 DerivedArgList &Args = C.getArgs();
2207 llvm::PrettyStackTraceString CrashInfo(
"Building universal build actions");
2210 llvm::StringSet<> ArchNames;
2212 for (Arg *A : Args) {
2213 if (A->getOption().matches(options::OPT_arch)) {
2216 llvm::Triple::ArchType Arch =
2218 if (Arch == llvm::Triple::UnknownArch) {
2219 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
2224 if (ArchNames.insert(A->getValue()).second)
2225 Archs.push_back(A->getValue());
2239 for (
Action* Act : SingleActions) {
2247 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
2251 for (
unsigned i = 0, e = Archs.size(); i != e; ++i)
2256 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
2257 Actions.append(Inputs.begin(), Inputs.end());
2259 Actions.push_back(C.MakeAction<
LipoJobAction>(Inputs, Act->getType()));
2262 Arg *A = Args.getLastArg(options::OPT_g_Group);
2263 bool enablesDebugInfo = A && !A->getOption().matches(options::OPT_g0) &&
2264 !A->getOption().matches(options::OPT_gstabs);
2272 if (Act->getType() == types::TY_Image) {
2274 Inputs.push_back(Actions.back());
2281 if (Args.hasArg(options::OPT_verify_debug_info)) {
2282 Action* LastAction = Actions.back();
2285 LastAction, types::TY_Nothing));
2304 if (Ty == types::TY_CXXSHeader || Ty == types::TY_CXXUHeader ||
2305 (ModulesModeCXX20 && Ty == types::TY_CXXHeader))
2317 unsigned IncludedFlagsBitmask;
2318 unsigned ExcludedFlagsBitmask;
2319 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
2320 getIncludeExcludeOptionFlagMasks(
IsCLMode());
2322 if (
getOpts().findNearest(
Value, Nearest, IncludedFlagsBitmask,
2323 ExcludedFlagsBitmask) <= 1) {
2324 Diag(clang::diag::err_drv_no_such_file_with_suggestion)
2325 <<
Value << Nearest;
2364 if (
IsCLMode() && Ty == types::TY_Object && !
Value.startswith(
"/"))
2367 Diag(clang::diag::err_drv_no_such_file) <<
Value;
2375 return types::TY_CXXUHeader;
2377 return types::TY_CXXSHeader;
2381 llvm_unreachable(
"should not be called in this case");
2383 return types::TY_CXXHUHeader;
2389 const llvm::opt::OptTable &Opts =
getOpts();
2393 types::ID InputType = types::TY_Nothing;
2394 Arg *InputTypeArg =
nullptr;
2397 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
2398 options::OPT__SLASH_TP)) {
2399 InputTypeArg = TCTP;
2400 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
2405 bool ShowNote =
false;
2407 Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) {
2409 Diag(clang::diag::warn_drv_overriding_flag_option)
2410 <<
Previous->getSpelling() << A->getSpelling();
2416 Diag(clang::diag::note_drv_t_option_is_global);
2419 assert(!Args.hasArg(options::OPT_x) &&
"-x and /TC or /TP is not allowed");
2424 Arg *LastXArg = Args.getLastArgNoClaim(options::OPT_x);
2425 Arg *LastInputArg = Args.getLastArgNoClaim(options::OPT_INPUT);
2426 if (LastXArg && LastInputArg && LastInputArg->getIndex() < LastXArg->getIndex())
2427 Diag(clang::diag::warn_drv_unused_x) << LastXArg->getValue();
2430 for (Arg *A : Args) {
2431 if (A->getOption().
getKind() == Option::InputClass) {
2432 const char *
Value = A->getValue();
2436 if (InputType == types::TY_Nothing) {
2439 InputTypeArg->claim();
2442 if (memcmp(
Value,
"-", 2) == 0) {
2444 Ty = types::TY_Fortran;
2453 if (!Args.hasArgNoClaim(options::OPT_E) && !
CCCIsCPP())
2454 Diag(
IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
2455 : clang::diag::err_drv_unknown_stdin_type);
2464 if (
const char *Ext = strrchr(
Value,
'.'))
2473 Ty = types::TY_Object;
2484 if (Ty != OldTy && !(OldTy == types::TY_CHeader &&
hasHeaderMode()))
2485 Diag(clang::diag::warn_drv_treating_input_as_cxx)
2491 if (Args.hasArgNoClaim(options::OPT_fthinlto_index_EQ) &&
2492 Ty == types::TY_Object)
2493 Ty = types::TY_LLVM_BC;
2501 if (Ty != types::TY_Object) {
2502 if (Args.hasArg(options::OPT_ObjC))
2503 Ty = types::TY_ObjC;
2504 else if (Args.hasArg(options::OPT_ObjCXX))
2505 Ty = types::TY_ObjCXX;
2512 if ((Ty == types::TY_CXXHeader || Ty == types::TY_CHeader) &&
2516 assert(InputTypeArg &&
"InputType set w/o InputTypeArg");
2517 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
2520 const char *Ext = strrchr(
Value,
'.');
2522 Ty = types::TY_Object;
2526 InputTypeArg->claim();
2531 Inputs.push_back(std::make_pair(Ty, A));
2533 }
else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
2534 StringRef
Value = A->getValue();
2537 Arg *InputArg =
MakeInputArg(Args, Opts, A->getValue());
2538 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
2541 }
else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
2542 StringRef
Value = A->getValue();
2545 Arg *InputArg =
MakeInputArg(Args, Opts, A->getValue());
2546 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
2552 Inputs.push_back(std::make_pair(types::TY_Object, A));
2554 }
else if (A->getOption().matches(options::OPT_x)) {
2563 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
2564 InputType = types::TY_Object;
2571 }
else if (A->getOption().getID() == options::OPT_U) {
2572 assert(A->getNumValues() == 1 &&
"The /U option has one value.");
2573 StringRef Val = A->getValue(0);
2574 if (Val.find_first_of(
"/\\") != StringRef::npos) {
2576 Diag(diag::warn_slash_u_filename) << Val;
2577 Diag(diag::note_use_dashdash);
2581 if (
CCCIsCPP() && Inputs.empty()) {
2585 Inputs.push_back(std::make_pair(types::TY_C, A));
2592 class OffloadingActionBuilder final {
2594 bool IsValid =
false;
2600 std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
2603 std::map<Action *, const Arg *> HostActionToInputArgMap;
2606 class DeviceActionBuilder {
2610 enum ActionBuilderReturnCode {
2629 DerivedArgList &Args;
2638 DeviceActionBuilder(
Compilation &C, DerivedArgList &Args,
2641 : C(C), Args(Args), Inputs(Inputs),
2642 AssociatedOffloadKind(AssociatedOffloadKind) {}
2643 virtual ~DeviceActionBuilder() {}
2648 virtual ActionBuilderReturnCode
2652 return ABRT_Inactive;
2657 virtual ActionBuilderReturnCode addDeviceDepences(
Action *HostAction) {
2658 return ABRT_Inactive;
2662 virtual void appendTopLevelActions(
ActionList &AL) {}
2665 virtual void appendLinkDeviceActions(
ActionList &AL) {}
2678 virtual bool canUseBundlerUnbundler()
const {
return false; }
2682 bool isValid() {
return !ToolChains.empty(); }
2686 return AssociatedOffloadKind;
2692 class CudaActionBuilderBase :
public DeviceActionBuilder {
2696 bool CompileHostOnly =
false;
2697 bool CompileDeviceOnly =
false;
2699 bool EmitAsm =
false;
2709 TargetID(
const char *
ID) :
ID(
ID) {}
2710 operator const char *() {
return ID; }
2711 operator StringRef() {
return StringRef(
ID); }
2720 Action *CudaFatBinary =
nullptr;
2723 bool IsActive =
false;
2726 bool Relocatable =
false;
2733 enum UseCUIDKind { CUID_Hash, CUID_Random, CUID_None, CUID_Invalid };
2734 UseCUIDKind UseCUID = CUID_Hash;
2737 StringRef FixedCUID;
2740 CudaActionBuilderBase(
Compilation &C, DerivedArgList &Args,
2743 : DeviceActionBuilder(
C, Args, Inputs, OFKind) {}
2745 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2752 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2753 assert(!GpuArchList.empty() &&
2754 "We should have at least one GPU architecture.");
2758 if (!(IA->getType() == types::TY_CUDA ||
2759 IA->getType() == types::TY_HIP ||
2760 IA->getType() == types::TY_PP_HIP)) {
2763 return ABRT_Inactive;
2769 if (CompileHostOnly)
2770 return ABRT_Success;
2773 auto Ty = IA->getType() == types::TY_HIP ? types::TY_HIP_DEVICE
2774 : types::TY_CUDA_DEVICE;
2777 if (UseCUID == CUID_Random)
2778 CUID = llvm::utohexstr(llvm::sys::Process::GetRandomNumber(),
2780 else if (UseCUID == CUID_Hash) {
2782 llvm::MD5::MD5Result Hash;
2784 llvm::sys::fs::real_path(IA->getInputArg().getValue(), RealPath,
2786 Hasher.update(RealPath);
2787 for (
auto *A : Args) {
2788 if (A->getOption().matches(options::OPT_INPUT))
2790 Hasher.update(A->getAsString(Args));
2793 CUID = llvm::utohexstr(Hash.low(),
true);
2798 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2799 CudaDeviceActions.push_back(
2800 C.MakeAction<
InputAction>(IA->getInputArg(), Ty, IA->getId()));
2803 return ABRT_Success;
2807 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2811 if (UA->getType() == types::TY_Object && !Relocatable)
2812 return ABRT_Inactive;
2814 CudaDeviceActions.clear();
2815 auto *IA = cast<InputAction>(UA->getInputs().back());
2816 std::string FileName = IA->getInputArg().getAsString(Args);
2820 if (IA->getType() == types::TY_Object &&
2821 (!llvm::sys::path::has_extension(FileName) ||
2823 llvm::sys::path::extension(FileName).drop_front()) !=
2825 return ABRT_Inactive;
2827 for (
auto Arch : GpuArchList) {
2828 CudaDeviceActions.push_back(UA);
2829 UA->registerDependentActionInfo(ToolChains[0], Arch,
2830 AssociatedOffloadKind);
2833 return ABRT_Success;
2836 return IsActive ? ABRT_Success : ABRT_Inactive;
2839 void appendTopLevelActions(
ActionList &AL)
override {
2841 auto AddTopLevel = [&](
Action *A, TargetID TargetID) {
2843 Dep.
add(*A, *ToolChains.front(), TargetID, AssociatedOffloadKind);
2848 if (CudaFatBinary) {
2850 CudaDeviceActions.clear();
2851 CudaFatBinary =
nullptr;
2855 if (CudaDeviceActions.empty())
2861 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2862 "Expecting one action per GPU architecture.");
2863 assert(ToolChains.size() == 1 &&
2864 "Expecting to have a single CUDA toolchain.");
2865 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
2866 AddTopLevel(CudaDeviceActions[I], GpuArchList[I]);
2868 CudaDeviceActions.clear();
2873 virtual StringRef getCanonicalOffloadArch(StringRef Arch) = 0;
2892 Relocatable = Args.hasFlag(options::OPT_fgpu_rdc,
2893 options::OPT_fno_gpu_rdc,
false);
2896 assert(HostTC &&
"No toolchain for host compilation.");
2898 HostTC->
getTriple().getArch() == llvm::Triple::amdgcn) {
2902 C.getDriver().Diag(diag::err_drv_cuda_host_arch)
2907 ToolChains.push_back(
2912 Arg *PartialCompilationArg = Args.getLastArg(
2913 options::OPT_offload_host_only, options::OPT_offload_device_only,
2914 options::OPT_offload_host_device);
2916 PartialCompilationArg && PartialCompilationArg->getOption().matches(
2917 options::OPT_offload_host_only);
2919 PartialCompilationArg && PartialCompilationArg->getOption().matches(
2920 options::OPT_offload_device_only);
2921 EmitLLVM = Args.getLastArg(options::OPT_emit_llvm);
2922 EmitAsm = Args.getLastArg(options::OPT_S);
2923 FixedCUID = Args.getLastArgValue(options::OPT_cuid_EQ);
2924 if (Arg *A = Args.getLastArg(options::OPT_fuse_cuid_EQ)) {
2925 StringRef UseCUIDStr = A->getValue();
2926 UseCUID = llvm::StringSwitch<UseCUIDKind>(UseCUIDStr)
2927 .Case(
"hash", CUID_Hash)
2928 .Case(
"random", CUID_Random)
2929 .Case(
"none", CUID_None)
2930 .Default(CUID_Invalid);
2931 if (UseCUID == CUID_Invalid) {
2932 C.getDriver().Diag(diag::err_drv_invalid_value)
2933 << A->getAsString(Args) << UseCUIDStr;
2934 C.setContainsError();
2940 if (Args.hasArgNoClaim(options::OPT_offload_EQ) &&
2941 Args.hasArgNoClaim(options::OPT_offload_arch_EQ,
2942 options::OPT_no_offload_arch_EQ)) {
2943 C.getDriver().Diag(diag::err_opt_not_valid_with_opt) <<
"--offload-arch"
2948 std::set<StringRef> GpuArchs;
2950 for (Arg *A : Args) {
2951 if (!(A->getOption().matches(options::OPT_offload_arch_EQ) ||
2952 A->getOption().matches(options::OPT_no_offload_arch_EQ)))
2956 StringRef ArchStr = A->getValue();
2957 if (A->getOption().matches(options::OPT_no_offload_arch_EQ) &&
2962 ArchStr = getCanonicalOffloadArch(ArchStr);
2963 if (ArchStr.empty()) {
2965 }
else if (A->getOption().matches(options::OPT_offload_arch_EQ))
2966 GpuArchs.insert(ArchStr);
2967 else if (A->getOption().matches(options::OPT_no_offload_arch_EQ))
2968 GpuArchs.erase(ArchStr);
2970 llvm_unreachable(
"Unexpected option.");
2974 if (ConflictingArchs) {
2975 C.getDriver().Diag(clang::diag::err_drv_bad_offload_arch_combo)
2976 << ConflictingArchs.getValue().first
2977 << ConflictingArchs.getValue().second;
2978 C.setContainsError();
2983 for (
auto Arch : GpuArchs)
2984 GpuArchList.push_back(Arch.data());
2989 if (GpuArchList.empty()) {
2990 if (ToolChains.front()->getTriple().isSPIRV())
2993 GpuArchList.push_back(DefaultCudaArch);
3002 class CudaActionBuilder final :
public CudaActionBuilderBase {
3004 CudaActionBuilder(
Compilation &C, DerivedArgList &Args,
3006 : CudaActionBuilderBase(
C, Args, Inputs,
Action::OFK_Cuda) {
3010 StringRef getCanonicalOffloadArch(StringRef ArchStr)
override {
3013 C.getDriver().Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
3021 const std::set<StringRef> &GpuArchs)
override {
3025 ActionBuilderReturnCode
3028 PhasesTy &Phases)
override {
3030 return ABRT_Inactive;
3034 if (CudaDeviceActions.empty())
3035 return ABRT_Success;
3037 assert(CudaDeviceActions.size() == GpuArchList.size() &&
3038 "Expecting one action per GPU architecture.");
3039 assert(!CompileHostOnly &&
3040 "Not expecting CUDA actions in host-only compilation.");
3050 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
3053 for (
auto Ph : Phases) {
3058 if (Ph > FinalPhase)
3061 CudaDeviceActions[I] =
C.getDriver().ConstructPhaseAction(
3071 if (!isa<AssembleJobAction>(CudaDeviceActions[I]) ||
3075 Action *AssembleAction = CudaDeviceActions[I];
3076 assert(AssembleAction->
getType() == types::TY_Object);
3077 assert(AssembleAction->
getInputs().size() == 1);
3085 DeviceActions.push_back(
3091 if (!DeviceActions.empty()) {
3093 C.MakeAction<
LinkJobAction>(DeviceActions, types::TY_CUDA_FATBIN);
3095 if (!CompileDeviceOnly) {
3096 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
3100 CudaFatBinary =
nullptr;
3105 CudaDeviceActions.clear();
3109 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
3114 return ABRT_Success;
3118 "instructions should only occur "
3119 "before the backend phase!");
3122 for (
Action *&A : CudaDeviceActions)
3123 A =
C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A);
3125 return ABRT_Success;
3130 class HIPActionBuilder final :
public CudaActionBuilderBase {
3141 HIPActionBuilder(
Compilation &C, DerivedArgList &Args,
3143 : CudaActionBuilderBase(
C, Args, Inputs,
Action::OFK_HIP) {
3145 if (Args.hasArg(options::OPT_gpu_bundle_output,
3146 options::OPT_no_gpu_bundle_output))
3147 BundleOutput = Args.hasFlag(options::OPT_gpu_bundle_output,
3148 options::OPT_no_gpu_bundle_output,
true);
3151 bool canUseBundlerUnbundler()
const override {
return true; }
3153 StringRef getCanonicalOffloadArch(StringRef IdStr)
override {
3154 llvm::StringMap<bool> Features;
3161 C.getDriver().Diag(clang::diag::err_drv_bad_target_id) << IdStr;
3162 C.setContainsError();
3166 return Args.MakeArgStringRef(CanId);
3171 const std::set<StringRef> &GpuArchs)
override {
3175 ActionBuilderReturnCode
3178 PhasesTy &Phases)
override {
3180 return ABRT_Inactive;
3186 if (CudaDeviceActions.empty())
3187 return ABRT_Success;
3190 CudaDeviceActions.size() == GpuArchList.size()) &&
3191 "Expecting one action per GPU architecture.");
3192 assert(!CompileHostOnly &&
3193 "Not expecting HIP actions in host-only compilation.");
3202 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
3203 if (
C.getDriver().isUsingLTO(
true)) {
3207 AL.push_back(CudaDeviceActions[I]);
3210 CudaDeviceActions[I] =
3217 if (ToolChains.front()->getTriple().isSPIRV()) {
3220 types::ID Output = Args.hasArg(options::OPT_S)
3222 : types::TY_LLVM_BC;
3228 AssociatedOffloadKind);
3229 auto AssembleAction =
C.getDriver().ConstructPhaseAction(
3231 AssociatedOffloadKind);
3232 AL.push_back(AssembleAction);
3235 CudaDeviceActions[I] =
3246 DDep.
add(*CudaDeviceActions[I], *ToolChains.front(), GpuArchList[I],
3247 AssociatedOffloadKind);
3249 DDep, CudaDeviceActions[I]->getType());
3252 if (!CompileDeviceOnly || !BundleOutput.hasValue() ||
3253 BundleOutput.getValue()) {
3256 types::TY_HIP_FATBIN);
3258 if (!CompileDeviceOnly) {
3259 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
3260 AssociatedOffloadKind);
3263 CudaFatBinary =
nullptr;
3268 CudaDeviceActions.clear();
3271 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
3278 DeviceLinkerInputs.resize(CudaDeviceActions.
size());
3279 auto LI = DeviceLinkerInputs.begin();
3280 for (
auto *A : CudaDeviceActions) {
3287 CudaDeviceActions.clear();
3288 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
3292 for (
Action *&A : CudaDeviceActions)
3293 A =
C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A,
3294 AssociatedOffloadKind);
3296 if (CompileDeviceOnly && CurPhase == FinalPhase &&
3297 BundleOutput.hasValue() && BundleOutput.getValue()) {
3298 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
3300 DDep.
add(*CudaDeviceActions[I], *ToolChains.front(), GpuArchList[I],
3301 AssociatedOffloadKind);
3303 DDep, CudaDeviceActions[I]->getType());
3307 CudaDeviceActions.clear();
3310 return (CompileDeviceOnly && CurPhase == FinalPhase) ? ABRT_Ignore_Host
3314 void appendLinkDeviceActions(
ActionList &AL)
override {
3315 if (DeviceLinkerInputs.size() == 0)
3318 assert(DeviceLinkerInputs.size() == GpuArchList.size() &&
3319 "Linker inputs and GPU arch list sizes do not match.");
3325 for (
auto &LI : DeviceLinkerInputs) {
3327 types::ID Output = Args.hasArg(options::OPT_emit_llvm)
3331 auto *DeviceLinkAction =
C.MakeAction<
LinkJobAction>(LI, Output);
3335 DeviceLinkDeps.
add(*DeviceLinkAction, *ToolChains[0],
3336 GpuArchList[I], AssociatedOffloadKind);
3338 DeviceLinkDeps, DeviceLinkAction->getType()));
3341 DeviceLinkerInputs.clear();
3344 if (Args.hasArg(options::OPT_emit_llvm)) {
3353 if (!CompileDeviceOnly || !BundleOutput.hasValue() ||
3354 BundleOutput.getValue()) {
3357 CompileDeviceOnly ? types::TY_HIP_FATBIN : types::TY_Object);
3358 DDeps.
add(*TopDeviceLinkAction, *ToolChains[0],
nullptr,
3359 AssociatedOffloadKind);
3362 C.MakeAction<
OffloadAction>(DDeps, TopDeviceLinkAction->getType()));
3368 Action* appendLinkHostActions(
ActionList &AL)
override {
return AL.back(); }
3375 class OpenMPActionBuilder final :
public DeviceActionBuilder {
3383 OpenMPActionBuilder(
Compilation &C, DerivedArgList &Args,
3385 : DeviceActionBuilder(
C, Args, Inputs,
Action::OFK_OpenMP) {}
3387 ActionBuilderReturnCode
3390 PhasesTy &Phases)
override {
3391 if (OpenMPDeviceActions.empty())
3392 return ABRT_Inactive;
3395 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
3396 "Number of OpenMP actions and toolchains do not match.");
3401 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
3402 "Toolchains and linker inputs sizes do not match.");
3403 auto LI = DeviceLinkerInputs.begin();
3404 for (
auto *A : OpenMPDeviceActions) {
3411 OpenMPDeviceActions.clear();
3412 return ABRT_Success;
3416 for (
Action *&A : OpenMPDeviceActions)
3417 A =
C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A);
3419 return ABRT_Success;
3422 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
3425 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
3426 OpenMPDeviceActions.clear();
3427 for (
unsigned I = 0; I < ToolChains.size(); ++I)
3428 OpenMPDeviceActions.push_back(
3429 C.MakeAction<
InputAction>(IA->getInputArg(), IA->getType()));
3430 return ABRT_Success;
3434 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
3435 OpenMPDeviceActions.clear();
3436 auto *IA = cast<InputAction>(UA->getInputs().back());
3437 std::string FileName = IA->getInputArg().getAsString(Args);
3441 if (IA->getType() == types::TY_Object &&
3442 (!llvm::sys::path::has_extension(FileName) ||
3444 llvm::sys::path::extension(FileName).drop_front()) !=
3446 return ABRT_Inactive;
3447 for (
unsigned I = 0; I < ToolChains.size(); ++I) {
3448 OpenMPDeviceActions.push_back(UA);
3449 UA->registerDependentActionInfo(
3452 return ABRT_Success;
3459 if (isa<CompileJobAction>(HostAction)) {
3461 assert(ToolChains.size() == OpenMPDeviceActions.size() &&
3462 "Toolchains and device action sizes do not match.");
3466 auto TC = ToolChains.begin();
3467 for (
Action *&A : OpenMPDeviceActions) {
3468 assert(isa<CompileJobAction>(A));
3475 return ABRT_Success;
3478 void appendTopLevelActions(
ActionList &AL)
override {
3479 if (OpenMPDeviceActions.empty())
3483 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
3484 "Number of OpenMP actions and toolchains do not match.");
3487 auto TI = ToolChains.begin();
3488 for (
auto *A : OpenMPDeviceActions) {
3495 OpenMPDeviceActions.clear();
3498 void appendLinkDeviceActions(
ActionList &AL)
override {
3499 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
3500 "Toolchains and linker inputs sizes do not match.");
3503 auto TC = ToolChains.begin();
3504 for (
auto &LI : DeviceLinkerInputs) {
3505 auto *DeviceLinkAction =
3508 DeviceLinkDeps.
add(*DeviceLinkAction, **TC,
nullptr,
3511 DeviceLinkAction->getType()));
3514 DeviceLinkerInputs.clear();
3531 for (
auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE;
3533 ToolChains.push_back(TI->second);
3535 DeviceLinkerInputs.resize(ToolChains.size());
3539 bool canUseBundlerUnbundler()
const override {
3556 OffloadingActionBuilder(
Compilation &C, DerivedArgList &Args,
3564 SpecializedBuilders.push_back(
new CudaActionBuilder(C, Args, Inputs));
3567 SpecializedBuilders.push_back(
new HIPActionBuilder(C, Args, Inputs));
3570 SpecializedBuilders.push_back(
new OpenMPActionBuilder(C, Args, Inputs));
3578 unsigned ValidBuilders = 0u;
3579 unsigned ValidBuildersSupportingBundling = 0u;
3580 for (
auto *SB : SpecializedBuilders) {
3581 IsValid = IsValid && !SB->initialize();
3584 if (SB->isValid()) {
3586 if (SB->canUseBundlerUnbundler())
3587 ++ValidBuildersSupportingBundling;
3591 ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling;
3594 ~OffloadingActionBuilder() {
3595 for (
auto *SB : SpecializedBuilders)
3600 void recordHostAction(
Action *HostAction,
const Arg *InputArg) {
3601 assert(HostAction &&
"Invalid host action");
3602 assert(InputArg &&
"Invalid input argument");
3603 auto Loc = HostActionToInputArgMap.find(HostAction);
3604 if (Loc == HostActionToInputArgMap.end())
3605 HostActionToInputArgMap[HostAction] = InputArg;
3606 assert(HostActionToInputArgMap[HostAction] == InputArg &&
3607 "host action mapped to multiple input arguments");
3615 addDeviceDependencesToHostAction(
Action *HostAction,
const Arg *InputArg,
3617 DeviceActionBuilder::PhasesTy &Phases) {
3621 if (SpecializedBuilders.empty())
3624 assert(HostAction &&
"Invalid host action!");
3625 recordHostAction(HostAction, InputArg);
3630 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
3631 unsigned InactiveBuilders = 0u;
3632 unsigned IgnoringBuilders = 0u;
3633 for (
auto *SB : SpecializedBuilders) {
3634 if (!SB->isValid()) {
3640 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
3645 if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host)
3650 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
3651 OffloadKind |= SB->getAssociatedOffloadKind();
3656 if (IgnoringBuilders &&
3657 SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders))
3674 bool addHostDependenceToDeviceActions(
Action *&HostAction,
3675 const Arg *InputArg) {
3679 recordHostAction(HostAction, InputArg);
3687 if (CanUseBundler && isa<InputAction>(HostAction) &&
3688 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
3690 HostAction->
getType() == types::TY_PP_HIP)) {
3691 auto UnbundlingHostAction =
3696 HostAction = UnbundlingHostAction;
3697 recordHostAction(HostAction, InputArg);
3700 assert(HostAction &&
"Invalid host action!");
3703 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
3704 for (
auto *SB : SpecializedBuilders) {
3708 auto RetCode = SB->addDeviceDepences(HostAction);
3712 assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&
3713 "Host dependence not expected to be ignored.!");
3717 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
3718 OffloadKind |= SB->getAssociatedOffloadKind();
3723 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction))
3733 const Arg *InputArg) {
3735 recordHostAction(HostAction, InputArg);
3739 for (
auto *SB : SpecializedBuilders) {
3742 SB->appendTopLevelActions(OffloadAL);
3749 if (CanUseBundler && HostAction &&
3750 HostAction->
getType() != types::TY_Nothing && !OffloadAL.empty()) {
3752 OffloadAL.push_back(HostAction);
3756 assert(HostAction == AL.back() &&
"Host action not in the list??");
3758 recordHostAction(HostAction, InputArg);
3759 AL.back() = HostAction;
3761 AL.append(OffloadAL.begin(), OffloadAL.end());
3771 void appendDeviceLinkActions(
ActionList &AL) {
3772 for (DeviceActionBuilder *SB : SpecializedBuilders) {
3775 SB->appendLinkDeviceActions(AL);
3779 Action *makeHostLinkAction() {
3782 appendDeviceLinkActions(DeviceAL);
3783 if (DeviceAL.empty())
3788 for (DeviceActionBuilder *SB : SpecializedBuilders) {
3791 HA = SB->appendLinkHostActions(DeviceAL);
3808 for (
auto *SB : SpecializedBuilders) {
3812 SB->appendLinkDependences(DDeps);
3816 unsigned ActiveOffloadKinds = 0u;
3817 for (
auto &I : InputArgToOffloadKindMap)
3818 ActiveOffloadKinds |= I.second;
3830 for (
auto A : HostAction->
inputs()) {
3831 auto ArgLoc = HostActionToInputArgMap.find(A);
3832 if (ArgLoc == HostActionToInputArgMap.end())
3834 auto OFKLoc = InputArgToOffloadKindMap.find(ArgLoc->second);
3835 if (OFKLoc == InputArgToOffloadKindMap.end())
3847 nullptr, ActiveOffloadKinds);
3853 void Driver::handleArguments(
Compilation &C, DerivedArgList &Args,
3858 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
3859 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
3860 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
3861 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
3862 Args.eraseArg(options::OPT__SLASH_Yc);
3863 Args.eraseArg(options::OPT__SLASH_Yu);
3864 YcArg = YuArg =
nullptr;
3866 if (YcArg && Inputs.size() > 1) {
3867 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
3868 Args.eraseArg(options::OPT__SLASH_Yc);
3877 if (Args.hasArg(options::OPT_emit_llvm) && !Args.hasArg(options::OPT_hip_link))
3878 Diag(clang::diag::err_drv_emit_llvm_link);
3880 !Args.getLastArgValue(options::OPT_fuse_ld_EQ)
3881 .equals_insensitive(
"lld"))
3882 Diag(clang::diag::err_drv_lto_without_lld);
3889 Args.eraseArg(options::OPT__SLASH_Fp);
3890 Args.eraseArg(options::OPT__SLASH_Yc);
3891 Args.eraseArg(options::OPT__SLASH_Yu);
3892 YcArg = YuArg =
nullptr;
3895 unsigned LastPLSize = 0;
3896 for (
auto &I : Inputs) {
3898 const Arg *InputArg = I.second;
3901 LastPLSize = PL.size();
3906 if (InitialPhase > FinalPhase) {
3907 if (InputArg->isClaimed())
3914 if (Args.hasArg(options::OPT_Qunused_arguments))
3920 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
3921 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase);
3925 (Args.getLastArg(options::OPT__SLASH_EP,
3926 options::OPT__SLASH_P) ||
3927 Args.getLastArg(options::OPT_E) ||
3928 Args.getLastArg(options::OPT_M, options::OPT_MM)) &&
3930 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
3931 << InputArg->getAsString(Args) << !!FinalPhaseArg
3932 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
3934 Diag(clang::diag::warn_drv_input_file_unused)
3935 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase)
3937 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
3950 Actions.push_back(ClangClPch);
3964 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
3965 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
3971 llvm::PrettyStackTraceString CrashInfo(
"Building compilation actions");
3973 if (!SuppressMissingInputWarning && Inputs.empty()) {
3974 Diag(clang::diag::err_drv_no_input_files);
3980 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
3981 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
3984 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
3985 StringRef
V = A->getValue();
3986 if (Inputs.size() > 1 && !
V.empty() &&
3987 !llvm::sys::path::is_separator(
V.back())) {
3989 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
3990 << A->getSpelling() <<
V;
3991 Args.eraseArg(options::OPT__SLASH_Fo);
3996 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
3997 StringRef
V = A->getValue();
3998 if (Inputs.size() > 1 && !
V.empty() &&
3999 !llvm::sys::path::is_separator(
V.back())) {
4001 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
4002 << A->getSpelling() <<
V;
4003 Args.eraseArg(options::OPT__SLASH_Fa);
4008 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
4009 if (A->getValue()[0] ==
'\0') {
4011 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
4012 Args.eraseArg(options::OPT__SLASH_o);
4016 handleArguments(C, Args, Inputs, Actions);
4019 OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
4021 bool UseNewOffloadingDriver =
4023 Args.hasFlag(options::OPT_fopenmp_new_driver,
4024 options::OPT_no_offload_new_driver,
true)) ||
4025 Args.hasFlag(options::OPT_offload_new_driver,
4026 options::OPT_no_offload_new_driver,
false);
4034 for (
auto &I : Inputs) {
4036 const Arg *InputArg = I.second;
4049 if (!UseNewOffloadingDriver)
4050 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
4056 if (!UseNewOffloadingDriver)
4057 Current = OffloadBuilder.addDeviceDependencesToHostAction(
4058 Current, InputArg, Phase, PL.back(), FullPL);
4064 assert(Phase == PL.back() &&
"linking must be final compilation step.");
4066 if (!(C.getInputArgs().hasArg(options::OPT_hip_link) &&
4067 (C.getInputArgs().hasArg(options::OPT_emit_llvm))))
4068 LinkerInputs.push_back(Current);
4078 assert(Phase == PL.back() &&
"merging must be final compilation step.");
4079 MergerInputs.push_back(Current);
4107 if (NewCurrent == Current)
4110 if (
auto *HMA = dyn_cast<HeaderModulePrecompileJobAction>(NewCurrent))
4111 HeaderModuleAction = HMA;
4112 else if (
auto *EAA = dyn_cast<ExtractAPIJobAction>(NewCurrent))
4115 Current = NewCurrent;
4119 if (!UseNewOffloadingDriver)
4120 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
4125 if (UseNewOffloadingDriver)
4128 if (Current->getType() == types::TY_Nothing)
4134 Actions.push_back(Current);
4137 if (!UseNewOffloadingDriver)
4138 OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg);
4140 Current->propagateHostOffloadInfo(C.getActiveOffloadKinds(),
4146 if (LinkerInputs.empty()) {
4149 if (!UseNewOffloadingDriver)
4150 OffloadBuilder.appendDeviceLinkActions(Actions);
4153 if (!LinkerInputs.empty()) {
4154 if (!UseNewOffloadingDriver)
4155 if (
Action *Wrapper = OffloadBuilder.makeHostLinkAction())
4156 LinkerInputs.push_back(Wrapper);
4161 }
else if (UseNewOffloadingDriver) {
4166 LA = C.MakeAction<
LinkJobAction>(LinkerInputs, types::TY_Image);
4168 if (!UseNewOffloadingDriver)
4169 LA = OffloadBuilder.processHostLinkAction(LA);
4170 Actions.push_back(LA);
4174 if (!MergerInputs.empty())
4178 if (Args.hasArg(options::OPT_emit_interface_stubs)) {
4185 for (
auto &I : Inputs) {
4187 const Arg *InputArg = I.second;
4192 if (InputType == types::TY_IFS || InputType == types::TY_PP_Asm ||
4193 InputType == types::TY_Asm)
4198 for (
auto Phase : PhaseList) {
4202 "IFS Pipeline can only consist of Compile followed by IfsMerge.");
4207 if (InputType == types::TY_Object)
4214 assert(Phase == PhaseList.back() &&
4215 "merging must be final compilation step.");
4216 MergerInputs.push_back(Current);
4225 Actions.push_back(Current);
4229 if (!MergerInputs.empty())
4236 if (Arg *A = Args.getLastArg(options::OPT_print_supported_cpus)) {
4242 for (
auto &I : Inputs)
4247 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
4251 Args.ClaimAllArgs(options::OPT_offload_host_only);
4252 Args.ClaimAllArgs(options::OPT_offload_host_device);
4258 const llvm::opt::DerivedArgList &Args,
4260 const llvm::Triple &Triple) {
4264 if (Triple.isNVPTX() &&
4266 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
4267 <<
"CUDA" << ArchStr;
4269 }
else if (Triple.isAMDGPU() &&
4271 C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
4272 <<
"HIP" << ArchStr;
4280 llvm::StringMap<bool> Features;
4286 C.getDriver().Diag(clang::diag::err_drv_bad_target_id) << ArchStr;
4287 C.setContainsError();
4290 return Args.MakeArgStringRef(
4306 std::set<StringRef> ArchSet;
4307 llvm::copy(Archs, std::inserter(ArchSet, ArchSet.begin()));
4315 TC = &C.getDefaultToolChain();
4318 if (Args.hasArgNoClaim(options::OPT_offload_EQ) &&
4319 Args.hasArgNoClaim(options::OPT_offload_arch_EQ,
4320 options::OPT_no_offload_arch_EQ)) {
4321 C.getDriver().Diag(diag::err_opt_not_valid_with_opt)
4323 << (Args.hasArgNoClaim(options::OPT_offload_arch_EQ)
4325 :
"--no-offload-arch");
4328 if (KnownArchs.find(TC) != KnownArchs.end())
4329 return KnownArchs.lookup(TC);
4332 for (
auto &Arg : Args) {
4333 if (Arg->getOption().matches(options::OPT_offload_arch_EQ)) {
4336 }
else if (Arg->getOption().matches(options::OPT_no_offload_arch_EQ)) {
4337 if (Arg->getValue() == StringRef(
"all"))
4346 C.getDriver().Diag(clang::diag::err_drv_bad_offload_arch_combo)
4347 << ConflictingArchs.getValue().first
4348 << ConflictingArchs.getValue().second;
4349 C.setContainsError();
4352 if (Archs.empty()) {
4358 Archs.insert(StringRef());
4360 Args.ClaimAllArgs(options::OPT_offload_arch_EQ);
4361 Args.ClaimAllArgs(options::OPT_no_offload_arch_EQ);
4368 llvm::opt::DerivedArgList &Args,
4370 Action *HostAction)
const {
4371 const Arg *Mode = Args.getLastArg(options::OPT_offload_host_only,
4372 options::OPT_offload_device_only,
4373 options::OPT_offload_host_device);
4374 const bool HostOnly =
4375 Mode && Mode->getOption().matches(options::OPT_offload_host_only);
4376 const bool DeviceOnly =
4377 Mode && Mode->getOption().matches(options::OPT_offload_device_only);
4383 !(isa<CompileJobAction>(HostAction) ||
4397 auto TCRange = C.getOffloadToolChains(
Kind);
4398 for (
auto TI = TCRange.first, TE = TCRange.second; TI != TE; ++TI)
4399 ToolChains.push_back(TI->second);
4401 if (ToolChains.empty())
4405 const Arg *InputArg = Input.second;
4411 C, C.getArgsForToolChain(TC,
"generic",
Kind),
Kind, TC))
4412 TCAndArchs.push_back(std::make_pair(TC, Arch));
4414 for (
unsigned I = 0, E = TCAndArchs.size(); I != E; ++I)
4415 DeviceActions.push_back(C.MakeAction<
InputAction>(*InputArg, InputType));
4417 if (DeviceActions.empty())
4424 assert(Phase == PL.back() &&
"linking must be final compilation step.");
4428 auto TCAndArch = TCAndArchs.begin();
4429 for (
Action *&A : DeviceActions) {
4432 if (isa<CompileJobAction>(A) && isa<CompileJobAction>(HostAction) &&
4440 TCAndArch->second.data(),
Kind);
4442 DDep.
add(*A, *TCAndArch->first, TCAndArch->second.data(),
Kind);
4450 DDep.
add(*A, *TCAndArch->first, TCAndArch->second.data(),
Kind);
4451 FatbinActions.emplace_back(
4454 A = C.MakeAction<
LinkJobAction>(FatbinActions, types::TY_CUDA_FATBIN);
4460 auto TCAndArch = TCAndArchs.begin();
4461 for (
Action *A : DeviceActions) {
4462 DDeps.
add(*A, *TCAndArch->first, TCAndArch->second.data(),
Kind);
4464 DDep.
add(*A, *TCAndArch->first, TCAndArch->second.data(),
Kind);
4471 return C.MakeAction<
OffloadAction>(DDeps, types::TY_Nothing);
4473 Action *OffloadPackager =
4476 DDep.add(*OffloadPackager, *C.getSingleOffloadToolChain<
Action::OFK_Host>(),
4480 nullptr, isa<CompileJobAction>(HostAction) ? DDep : DDeps);
4482 HDep, isa<CompileJobAction>(HostAction) ? DDep : DDeps);
4488 llvm::PrettyStackTraceString CrashInfo(
"Constructing phase actions");
4499 llvm_unreachable(
"link action invalid here.");
4501 llvm_unreachable(
"ifsmerge action invalid here.");
4506 if (Args.hasArg(options::OPT_M, options::OPT_MM) &&
4507 !Args.hasArg(options::OPT_MD, options::OPT_MMD)) {
4508 OutputTy = types::TY_Dependencies;
4513 if (!Args.hasFlag(options::OPT_frewrite_includes,
4514 options::OPT_fno_rewrite_includes,
false) &&
4515 !Args.hasFlag(options::OPT_frewrite_imports,
4516 options::OPT_fno_rewrite_imports,
false) &&
4517 !Args.hasFlag(options::OPT_fdirectives_only,
4518 options::OPT_fno_directives_only,
false) &&
4522 "Cannot preprocess this input type!");
4528 if (Args.hasArg(options::OPT_extract_api))
4533 "Cannot precompile this input type!");
4537 const char *ModName =
nullptr;
4538 if (OutputTy == types::TY_PCH) {
4539 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name_EQ))
4540 ModName = A->getValue();
4542 OutputTy = types::TY_ModuleFile;
4545 if (Args.hasArg(options::OPT_fsyntax_only)) {
4547 OutputTy = types::TY_Nothing;
4556 if (Args.hasArg(options::OPT_fsyntax_only))
4558 if (Args.hasArg(options::OPT_rewrite_objc))
4560 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
4562 types::TY_RewrittenLegacyObjC);
4563 if (Args.hasArg(options::OPT__analyze))
4565 if (Args.hasArg(options::OPT__migrate))
4567 if (Args.hasArg(options::OPT_emit_ast))
4569 if (Args.hasArg(options::OPT_module_file_info))
4571 if (Args.hasArg(options::OPT_verify_pch))
4573 if (Args.hasArg(options::OPT_extract_api))
4580 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
4586 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
4589 if (Args.hasArg(options::OPT_emit_llvm) ||
4591 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
4594 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
4603 llvm_unreachable(
"invalid phase in ConstructPhaseAction");
4607 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
4609 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
4625 unsigned NumOutputs = 0;
4626 unsigned NumIfsOutputs = 0;
4627 for (
const Action *A : C.getActions())
4628 if (A->
getType() != types::TY_Nothing &&
4630 (A->
getType() == clang::driver::types::TY_IFS_CPP &&
4632 0 == NumIfsOutputs++) ||
4637 if (NumOutputs > 1) {
4638 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
4639 FinalOutput =
nullptr;
4643 const llvm::Triple &RawTriple = C.getDefaultToolChain().getTriple();
4644 if (RawTriple.isOSAIX()) {
4645 if (Arg *A = C.getArgs().getLastArg(options::OPT_G))
4646 Diag(diag::err_drv_unsupported_opt_for_target)
4647 << A->getSpelling() << RawTriple.str();
4649 Diag(diag::err_drv_clang_unsupported) <<
"thinLTO on AIX";
4653 llvm::StringSet<> ArchNames;
4654 if (RawTriple.isOSBinFormatMachO())
4655 for (
const Arg *A : C.getArgs())
4656 if (A->getOption().matches(options::OPT_arch))
4657 ArchNames.insert(A->getValue());
4660 std::map<std::pair<const Action *, std::string>,
InputInfoList> CachedResults;
4661 for (
Action *A : C.getActions()) {
4668 const char *LinkingOutput =
nullptr;
4669 if (isa<LipoJobAction>(A)) {
4671 LinkingOutput = FinalOutput->getValue();
4679 ArchNames.size() > 1,
4680 LinkingOutput, CachedResults,
4687 for (
auto &J : C.getJobs())
4688 J.InProcess =
false;
4691 C.setPostCallback([=](
const Command &
Cmd,
int Res) {
4693 Cmd.getProcessStatistics();
4697 const char *LinkingOutput =
nullptr;
4699 LinkingOutput = FinalOutput->getValue();
4700 else if (!
Cmd.getOutputFilenames().empty())
4701 LinkingOutput =
Cmd.getOutputFilenames().front().c_str();
4706 using namespace llvm;
4708 outs() << sys::path::filename(Cmd.getExecutable()) <<
": "
4709 <<
"output=" << LinkingOutput;
4710 outs() <<
", total="
4711 << format(
"%.3f", ProcStat->TotalTime.count() / 1000.) <<
" ms"
4713 << format(
"%.3f", ProcStat->UserTime.count() / 1000.) <<
" ms"
4714 <<
", mem=" << ProcStat->PeakMemory <<
" Kb\n";
4718 llvm::raw_string_ostream Out(Buffer);
4719 llvm::sys::printArg(Out, llvm::sys::path::filename(Cmd.getExecutable()),
4722 llvm::sys::printArg(Out, LinkingOutput, true);
4723 Out <<
',' << ProcStat->TotalTime.count() <<
','
4724 << ProcStat->UserTime.count() <<
',' << ProcStat->PeakMemory
4728 llvm::raw_fd_ostream OS(CCPrintStatReportFilename, EC,
4729 llvm::sys::fs::OF_Append |
4730 llvm::sys::fs::OF_Text);
4735 llvm::errs() <<
"ERROR: Cannot lock file "
4736 << CCPrintStatReportFilename <<
": "
4737 << toString(L.takeError()) <<
"\n";
4749 C.getArgs().hasArg(options::OPT_Qunused_arguments))
4753 (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
4756 (void)C.getArgs().hasArg(options::OPT_driver_mode);
4757 (void)C.getArgs().hasArg(options::OPT_rsp_quoting);
4759 for (Arg *A : C.getArgs()) {
4763 if (!A->isClaimed()) {
4769 const Option &Opt = A->getOption();
4770 if (Opt.getKind() == Option::FlagClass) {
4771 bool DuplicateClaimed =
false;
4773 for (
const Arg *AA : C.getArgs().filtered(&Opt)) {
4774 if (AA->isClaimed()) {
4775 DuplicateClaimed =
true;
4780 if (DuplicateClaimed)
4786 if (!
IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
4787 Diag(clang::diag::warn_drv_unused_argument)
4788 << A->getAsString(
C.getArgs());
4796 class ToolSelector final {
4807 bool IsHostSelector;
4818 bool CanBeCollapsed =
true) {
4820 if (Inputs.size() != 1)
4823 Action *CurAction = *Inputs.begin();
4824 if (CanBeCollapsed &&
4830 if (
auto *OA = dyn_cast<OffloadAction>(CurAction)) {
4834 if (!IsHostSelector) {
4835 if (OA->hasSingleDeviceDependence(
true)) {
4837 OA->getSingleDeviceDependence(
true);
4838 if (CanBeCollapsed &&
4841 SavedOffloadAction.push_back(OA);
4842 return dyn_cast<JobAction>(CurAction);
4844 }
else if (OA->hasHostDependence()) {
4845 CurAction = OA->getHostDependence();
4846 if (CanBeCollapsed &&
4849 SavedOffloadAction.push_back(OA);
4850 return dyn_cast<JobAction>(CurAction);
4855 return dyn_cast<JobAction>(CurAction);
4859 bool canCollapseAssembleAction()
const {
4860 return TC.useIntegratedAs() && !SaveTemps &&
4861 !
C.getArgs().hasArg(options::OPT_via_file_asm) &&
4862 !
C.getArgs().hasArg(options::OPT__SLASH_FA) &&
4863 !
C.getArgs().hasArg(options::OPT__SLASH_Fa);
4867 bool canCollapsePreprocessorAction()
const {
4868 return !
C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
4869 !
C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
4870 !
C.getArgs().hasArg(options::OPT_rewrite_objc);
4875 struct JobActionInfo final {
4885 static void AppendCollapsedOffloadAction(
ActionList &CollapsedOffloadAction,
4887 unsigned ElementNum) {
4888 assert(ElementNum <= ActionInfo.size() &&
"Invalid number of elements.");
4889 for (
unsigned I = 0; I < ElementNum; ++I)
4890 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
4891 ActionInfo[I].SavedOffloadAction.end());
4907 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
4909 auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA);
4910 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA);
4911 auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[2].JA);
4912 if (!AJ || !BJ || !CJ)
4916 const Tool *T = TC.SelectTool(*CJ);
4929 const Tool *BT = TC.SelectTool(*BJ);
4937 Inputs = CJ->getInputs();
4938 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
4945 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
4947 auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA);
4948 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA);
4953 const Tool *T = TC.SelectTool(*BJ);
4960 Inputs = BJ->getInputs();
4961 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
4968 if (ActionInfo.size() < 2)
4970 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[0].JA);
4971 auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[1].JA);
4980 bool InputIsBitcode =
true;
4981 for (
size_t i = 1; i < ActionInfo.size(); i++)
4982 if (ActionInfo[i].JA->getType() != types::TY_LLVM_BC &&
4983 ActionInfo[i].JA->getType() != types::TY_LTO_BC) {
4984 InputIsBitcode =
false;
4987 if (!InputIsBitcode && !canCollapsePreprocessorAction())
4991 const Tool *T = TC.SelectTool(*CJ);
5004 Inputs = CJ->getInputs();
5005 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
5022 for (
Action *A : Inputs) {
5023 auto *PJ = getPrevDependentAction({A}, PreprocessJobOffloadActions);
5024 if (!PJ || !isa<PreprocessJobAction>(PJ)) {
5025 NewInputs.push_back(A);
5031 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
5032 PreprocessJobOffloadActions.end());
5033 NewInputs.append(PJ->input_begin(), PJ->input_end());
5041 : TC(TC),
C(
C), BaseAction(BaseAction), SaveTemps(SaveTemps),
5043 assert(BaseAction &&
"Invalid base action.");
5060 ActionChain.back().JA = BaseAction;
5061 while (ActionChain.back().JA) {
5062 const Action *CurAction = ActionChain.back().JA;
5065 ActionChain.resize(ActionChain.size() + 1);
5066 JobActionInfo &AI = ActionChain.back();
5070 getPrevDependentAction(CurAction->
getInputs(), AI.SavedOffloadAction);
5074 ActionChain.pop_back();
5082 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
5083 CollapsedOffloadAction);
5085 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
5087 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
5093 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
5105 StringRef BoundArch,
5108 if (!BoundArch.empty()) {
5109 TriplePlusArch +=
"-";
5110 TriplePlusArch += BoundArch;
5112 TriplePlusArch +=
"-";
5114 return TriplePlusArch;
5119 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
5120 std::map<std::pair<const Action *, std::string>,
InputInfoList>
5123 std::pair<const Action *, std::string> ActionTC = {
5125 auto CachedResult = CachedResults.find(ActionTC);
5126 if (CachedResult != CachedResults.end()) {
5127 return CachedResult->second;
5130 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
5131 CachedResults, TargetDeviceOffloadKind);
5132 CachedResults[ActionTC] = Result;
5138 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
5139 std::map<std::pair<const Action *, std::string>,
InputInfoList>
5142 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
5145 bool BuildingForOffloadDevice = TargetDeviceOffloadKind !=
Action::OFK_None;
5177 if (OA->hasSingleDeviceDependence()) {
5179 OA->doOnEachDeviceDependence([&](
Action *DepA,
const ToolChain *DepTC,
5180 const char *DepBoundArch) {
5183 !!DepBoundArch, LinkingOutput,
5193 OA->doOnEachDependence(
5194 BuildingForOffloadDevice,
5197 C, DepA, DepTC, DepBoundArch,
false,
5198 !!DepBoundArch, LinkingOutput, CachedResults,
5202 A = BuildingForOffloadDevice
5203 ? OA->getSingleDeviceDependence(
true)
5204 : OA->getHostDependence();
5208 std::pair<const Action *, std::string> ActionTC = {
5209 OA->getHostDependence(),
5211 if (CachedResults.find(ActionTC) != CachedResults.end()) {
5213 Inputs.append(OffloadDependencesInputInfo);
5218 if (
const InputAction *IA = dyn_cast<InputAction>(A)) {
5221 const Arg &Input = IA->getInputArg();
5223 if (Input.getOption().matches(options::OPT_INPUT)) {
5224 const char *
Name = Input.getValue();
5234 if (!ArchName.empty())
5235 TC = &getToolChain(
C.getArgs(),
5237 C.getArgs(), ArchName));
5239 TC = &
C.getDefaultToolChain();
5242 MultipleArchs, LinkingOutput, CachedResults,
5243 TargetDeviceOffloadKind);
5249 const JobAction *JA = cast<JobAction>(A);
5254 const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions);
5259 if (BuildingForOffloadDevice &&
5266 AtTopLevel, MultipleArchs, LinkingOutput,
5267 CachedResults, TargetDeviceOffloadKind);
5272 AtTopLevel, MultipleArchs, LinkingOutput,
5273 CachedResults, TargetDeviceOffloadKind);
5280 for (
const auto *OA : CollapsedOffloadActions)
5281 cast<OffloadAction>(OA)->doOnEachDependence(
5282 BuildingForOffloadDevice,
5285 C, DepA, DepTC, DepBoundArch,
false,
5286 !!DepBoundArch, LinkingOutput, CachedResults,
5292 for (
const Action *Input : Inputs) {
5296 bool SubJobAtTopLevel =
5297 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
5299 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
5304 const char *BaseInput = InputInfos[0].getBaseInput();
5305 for (
auto &Info : InputInfos) {
5306 if (Info.isFilename()) {
5307 BaseInput = Info.getBaseInput();
5314 if (JA->
getType() == types::TY_dSYM)
5315 BaseInput = InputInfos[0].getFilename();
5318 if (
auto *ModuleJA = dyn_cast<HeaderModulePrecompileJobAction>(JA))
5319 BaseInput = ModuleJA->getModuleName();
5322 if (!OffloadDependencesInputInfo.empty())
5323 InputInfos.append(OffloadDependencesInputInfo.begin(),
5324 OffloadDependencesInputInfo.end());
5327 llvm::Triple EffectiveTriple;
5329 const ArgList &Args =
5331 if (InputInfos.size() != 1) {
5335 EffectiveTriple = llvm::Triple(
5343 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) {
5347 for (
auto &UI : UA->getDependentActionsInfo()) {
5349 "Unbundling with no offloading??");
5356 UI.DependentOffloadKind,
5357 UI.DependentToolChain->getTriple().normalize(),
5368 UnbundlingResults.push_back(CurI);
5377 Arch = UI.DependentBoundArch;
5382 UI.DependentOffloadKind)}] = {
5388 std::pair<const Action *, std::string> ActionTC = {
5390 assert(CachedResults.find(ActionTC) != CachedResults.end() &&
5391 "Result does not exist??");
5392 Result = CachedResults[ActionTC].front();
5393 }
else if (JA->
getType() == types::TY_Nothing)
5402 if (isa<OffloadWrapperJobAction>(JA)) {
5403 if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o))
5404 BaseInput = FinalOutput->getValue();
5408 C.getArgs().MakeArgString(
std::string(BaseInput) +
"-wrapper");
5411 AtTopLevel, MultipleArchs,
5418 <<
" - \"" << T->
getName() <<
"\", inputs: [";
5419 for (
unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
5420 llvm::errs() << InputInfos[i].getAsString();
5422 llvm::errs() <<
", ";
5424 if (UnbundlingResults.empty())
5425 llvm::errs() <<
"], output: " << Result.getAsString() <<
"\n";
5427 llvm::errs() <<
"], outputs: [";
5428 for (
unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) {
5429 llvm::errs() << UnbundlingResults[i].getAsString();
5431 llvm::errs() <<
", ";
5433 llvm::errs() <<
"] \n";
5436 if (UnbundlingResults.empty())
5438 C, *JA, Result, InputInfos,
5443 C, *JA, UnbundlingResults, InputInfos,
5452 return Target.isOSWindows() ?
"a.exe" :
"a.out";
5464 if (ArgValue.empty()) {
5467 }
else if (llvm::sys::path::is_separator(
Filename.back())) {
5469 llvm::sys::path::append(
Filename, BaseName);
5472 if (!llvm::sys::path::has_extension(ArgValue)) {
5476 if (FileType == types::TY_Image &&
5477 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
5482 llvm::sys::path::replace_extension(
Filename, Extension);
5485 return Args.MakeArgString(
Filename.c_str());
5489 if (isa<PreprocessJobAction>(JA))
5491 if (isa<OffloadAction>(JA) && isa<PreprocessJobAction>(JA.
getInputs()[0]))
5493 if (isa<OffloadBundlingJobAction>(JA) &&
5500 const char *BaseInput,
5501 StringRef OrigBoundArch,
bool AtTopLevel,
5503 StringRef OffloadingPrefix)
const {
5505 if (is_style_windows(llvm::sys::path::Style::native)) {
5508 std::replace(BoundArch.begin(), BoundArch.end(),
':',
'@');
5511 llvm::PrettyStackTraceString CrashInfo(
"Computing output path");
5513 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
5514 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
5515 return C.addResultFile(FinalOutput->getValue(), &JA);
5519 if (C.getArgs().hasArg(options::OPT__SLASH_P)) {
5520 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
5521 StringRef BaseName = llvm::sys::path::filename(BaseInput);
5523 if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi))
5524 NameArg = A->getValue();
5525 return C.addResultFile(
5535 if (JA.
getType() == types::TY_ModuleFile &&
5536 C.getArgs().getLastArg(options::OPT_module_file_info)) {
5541 if (JA.
getType() == types::TY_PP_Asm &&
5542 (C.getArgs().hasArg(options::OPT__SLASH_FA) ||
5543 C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
5545 StringRef BaseName = llvm::sys::path::filename(BaseInput);
5546 StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
5547 return C.addResultFile(
5554 !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
5556 StringRef
Name = llvm::sys::path::filename(BaseInput);
5557 std::pair<StringRef, StringRef>
Split =
Name.split(
'.');
5560 Arg *A = C.getArgs().getLastArg(options::OPT_fcrash_diagnostics_dir);
5563 if (!
getVFS().exists(CrashDirectory))
5564 llvm::sys::fs::create_directories(CrashDirectory);
5565 llvm::sys::path::append(CrashDirectory,
Split.first);
5566 const char *Middle = Suffix ?
"-%%%%%%." :
"-%%%%%%";
5567 std::error_code EC = llvm::sys::fs::createUniqueFile(
5568 CrashDirectory + Middle + Suffix, TmpName);
5570 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
5574 if (MultipleArchs && !BoundArch.empty()) {
5576 llvm::sys::path::append(TmpName,
5577 Split.first +
"-" + BoundArch +
"." + Suffix);
5582 return C.addTempFile(C.getArgs().MakeArgString(TmpName));
5590 if (isa<DsymutilJobAction>(JA) && C.getArgs().hasArg(options::OPT_dsym_dir)) {
5591 ExternalPath += C.getArgs().getLastArg(options::OPT_dsym_dir)->getValue();
5596 llvm::sys::path::append(ExternalPath, llvm::sys::path::Style::posix,
5597 llvm::sys::path::filename(BasePath));
5598 BaseName = ExternalPath;
5599 }
else if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
5600 BaseName = BasePath;
5602 BaseName = llvm::sys::path::filename(BasePath);
5605 const char *NamedOutput;
5607 if ((JA.
getType() == types::TY_Object || JA.
getType() == types::TY_LTO_BC) &&
5608 C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
5612 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
5616 }
else if (JA.
getType() == types::TY_Image &&
5617 C.getArgs().hasArg(options::OPT__SLASH_Fe,
5618 options::OPT__SLASH_o)) {
5622 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
5626 }
else if (JA.
getType() == types::TY_Image) {
5636 !C.getArgs().hasFlag(options::OPT_fgpu_rdc,
5637 options::OPT_fno_gpu_rdc,
false);
5640 llvm::sys::path::replace_extension(Output,
"");
5642 Output += OffloadingPrefix;
5643 if (MultipleArchs && !BoundArch.empty()) {
5645 Output.append(BoundArch);
5649 NamedOutput = C.getArgs().MakeArgString(Output.c_str());
5652 NamedOutput = C.getArgs().MakeArgString(
GetClPchPath(C, BaseName));
5655 assert(Suffix &&
"All types used for output should have a suffix.");
5657 std::string::size_type
End = std::string::npos;
5659 End = BaseName.rfind(
'.');
5661 Suffixed += OffloadingPrefix;
5662 if (MultipleArchs && !BoundArch.empty()) {
5664 Suffixed.append(BoundArch);
5669 auto IsHIPRDCInCompilePhase = [](
const JobAction &JA,
5670 const llvm::opt::DerivedArgList &Args) {
5674 return isa<CompileJobAction>(JA) &&
5676 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
5679 if (!AtTopLevel && JA.
getType() == types::TY_LLVM_BC &&
5680 (C.getArgs().hasArg(options::OPT_emit_llvm) ||
5681 IsHIPRDCInCompilePhase(JA, C.getArgs())))
5685 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
5689 if (!AtTopLevel &&
isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) &&
5690 JA.
getType() != types::TY_PCH) {
5691 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
5693 llvm::sys::path::remove_filename(TempPath);
5694 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
5695 llvm::sys::path::append(TempPath, OutputFileName);
5696 NamedOutput = C.getArgs().MakeArgString(TempPath.c_str());
5702 bool SameFile =
false;
5704 llvm::sys::fs::current_path(Result);
5705 llvm::sys::path::append(Result, BaseName);
5706 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
5709 StringRef
Name = llvm::sys::path::filename(BaseInput);
5710 std::pair<StringRef, StringRef>
Split =
Name.split(
'.');
5713 return C.addTempFile(C.getArgs().MakeArgString(TmpName));
5719 llvm::sys::path::remove_filename(BasePath);
5720 if (BasePath.empty())
5721 BasePath = NamedOutput;
5723 llvm::sys::path::append(BasePath, NamedOutput);
5724 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
5726 return C.addResultFile(NamedOutput, &JA);
5736 for (
const auto &
Dir :
P) {
5740 llvm::sys::path::append(
P,
Name);
5741 if (llvm::sys::fs::exists(Twine(
P)))
5751 llvm::sys::path::append(R,
Name);
5752 if (llvm::sys::fs::exists(Twine(R)))
5756 llvm::sys::path::append(
P,
Name);
5757 if (llvm::sys::fs::exists(Twine(
P)))
5761 llvm::sys::path::append(D,
"..",
Name);
5762 if (llvm::sys::fs::exists(Twine(D)))
5774 void Driver::generatePrefixedToolNames(
5778 Names.emplace_back((TargetTriple +
"-" +
Tool).str());
5779 Names.emplace_back(
Tool);
5783 llvm::sys::path::append(Dir, Name);
5784 if (llvm::sys::fs::can_execute(Twine(Dir)))
5786 llvm::sys::path::remove_filename(Dir);
5792 generatePrefixedToolNames(
Name, TC, TargetSpecificExecutables);
5797 if (llvm::sys::fs::is_directory(PrefixDir)) {
5803 if (llvm::sys::fs::can_execute(Twine(
P)))
5809 for (
const auto &TargetSpecificExecutable : TargetSpecificExecutables) {
5817 for (
const auto &Path : List) {
5824 if (llvm::ErrorOr<std::string>
P =
5825 llvm::sys::findProgramByName(TargetSpecificExecutable))
5834 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
5836 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
5845 std::error_code EC = llvm::sys::fs::createUniqueDirectory(Prefix, Path);
5847 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
5856 if (Arg *FpArg = C.getArgs().getLastArg(options::OPT__SLASH_Fp)) {
5860 Output = FpArg->getValue();
5864 if (!llvm::sys::path::has_extension(Output))
5867 if (Arg *YcArg = C.getArgs().getLastArg(options::OPT__SLASH_Yc))
5868 Output = YcArg->getValue();
5871 llvm::sys::path::replace_extension(Output,
".pch");
5876 const ToolChain &Driver::getToolChain(
const ArgList &Args,
5877 const llvm::Triple &Target)
const {
5879 auto &TC = ToolChains[
Target.str()];
5881 switch (
Target.getOS()) {
5883 TC = std::make_unique<toolchains::AIX>(*
this, Target, Args);
5885 case llvm::Triple::Haiku:
5886 TC = std::make_unique<toolchains::Haiku>(*
this, Target, Args);
5888 case llvm::Triple::Ananas:
5889 TC = std::make_unique<toolchains::Ananas>(*
this, Target, Args);
5891 case llvm::Triple::CloudABI:
5892 TC = std::make_unique<toolchains::CloudABI>(*
this, Target, Args);
5894 case llvm::Triple::Darwin:
5895 case llvm::Triple::MacOSX:
5896 case llvm::Triple::IOS:
5897 case llvm::Triple::TvOS:
5898 case llvm::Triple::WatchOS:
5899 case llvm::Triple::DriverKit:
5900 TC = std::make_unique<toolchains::DarwinClang>(*
this, Target, Args);
5902 case llvm::Triple::DragonFly:
5903 TC = std::make_unique<toolchains::DragonFly>(*
this, Target, Args);
5905 case llvm::Triple::OpenBSD:
5906 TC = std::make_unique<toolchains::OpenBSD>(*
this, Target, Args);
5908 case llvm::Triple::NetBSD:
5909 TC = std::make_unique<toolchains::NetBSD>(*
this, Target, Args);
5911 case llvm::Triple::FreeBSD:
5913 TC = std::make_unique<toolchains::PPCFreeBSDToolChain>(*
this, Target,
5916 TC = std::make_unique<toolchains::FreeBSD>(*
this, Target, Args);
5918 case llvm::Triple::Minix:
5919 TC = std::make_unique<toolchains::Minix>(*
this, Target, Args);
5921 case llvm::Triple::Linux:
5922 case llvm::Triple::ELFIAMCU:
5923 if (
Target.getArch() == llvm::Triple::hexagon)
5924 TC = std::make_unique<toolchains::HexagonToolChain>(*
this, Target,
5926 else if ((
Target.getVendor() == llvm::Triple::MipsTechnologies) &&
5927 !
Target.hasEnvironment())
5928 TC = std::make_unique<toolchains::MipsLLVMToolChain>(*
this, Target,
5931 TC = std::make_unique<toolchains::PPCLinuxToolChain>(*
this, Target,
5933 else if (
Target.getArch() == llvm::Triple::ve)
5934 TC = std::make_unique<toolchains::VEToolChain>(*
this, Target, Args);
5937 TC = std::make_unique<toolchains::Linux>(*
this, Target, Args);
5939 case llvm::Triple::NaCl:
5940 TC = std::make_unique<toolchains::NaClToolChain>(*
this, Target, Args);
5942 case llvm::Triple::Fuchsia:
5943 TC = std::make_unique<toolchains::Fuchsia>(*
this, Target, Args);
5945 case llvm::Triple::Solaris:
5946 TC = std::make_unique<toolchains::Solaris>(*
this, Target, Args);
5948 case llvm::Triple::AMDHSA:
5949 TC = std::make_unique<toolchains::ROCMToolChain>(*
this, Target, Args);
5951 case llvm::Triple::AMDPAL:
5952 case llvm::Triple::Mesa3D:
5953 TC = std::make_unique<toolchains::AMDGPUToolChain>(*
this, Target, Args);
5955 case llvm::Triple::Win32:
5956 switch (
Target.getEnvironment()) {
5958 if (
Target.isOSBinFormatELF())
5959 TC = std::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
5960 else if (
Target.isOSBinFormatMachO())
5961 TC = std::make_unique<toolchains::MachO>(*
this, Target, Args);
5963 TC = std::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
5965 case llvm::Triple::GNU:
5966 TC = std::make_unique<toolchains::MinGW>(*
this, Target, Args);
5968 case llvm::Triple::Itanium:
5969 TC = std::make_unique<toolchains::CrossWindowsToolChain>(*
this, Target,
5972 case llvm::Triple::MSVC:
5973 case llvm::Triple::UnknownEnvironment:
5974 if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
5975 .startswith_insensitive(
"bfd"))