47 #include "clang/Config/config.h" 56 #include "llvm/ADT/ArrayRef.h" 57 #include "llvm/ADT/STLExtras.h" 58 #include "llvm/ADT/SmallSet.h" 59 #include "llvm/ADT/StringExtras.h" 60 #include "llvm/ADT/StringSet.h" 61 #include "llvm/ADT/StringSwitch.h" 62 #include "llvm/Config/llvm-config.h" 63 #include "llvm/Option/Arg.h" 64 #include "llvm/Option/ArgList.h" 65 #include "llvm/Option/OptSpecifier.h" 66 #include "llvm/Option/OptTable.h" 67 #include "llvm/Option/Option.h" 68 #include "llvm/Support/CommandLine.h" 69 #include "llvm/Support/ErrorHandling.h" 70 #include "llvm/Support/FileSystem.h" 71 #include "llvm/Support/Path.h" 72 #include "llvm/Support/PrettyStackTrace.h" 73 #include "llvm/Support/Process.h" 74 #include "llvm/Support/Program.h" 75 #include "llvm/Support/StringSaver.h" 76 #include "llvm/Support/TargetRegistry.h" 77 #include "llvm/Support/raw_ostream.h" 86 using namespace clang;
93 Mode(GCCMode), SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
94 LTOMode(
LTOK_None), ClangExecutable(ClangExecutable),
95 SysRoot(DEFAULT_SYSROOT), DriverTitle(
"clang LLVM compiler"),
96 CCPrintOptionsFilename(nullptr), CCPrintHeadersFilename(nullptr),
97 CCLogDiagnosticsFilename(nullptr), CCCPrintBindings(
false),
99 CCGenDiagnostics(
false), TargetTriple(TargetTriple),
100 CCCGenericGCCName(
""), Saver(Alloc), CheckInputsExist(
true),
102 SuppressMissingInputWarning(
false) {
108 Name = llvm::sys::path::filename(ClangExecutable);
109 Dir = llvm::sys::path::parent_path(ClangExecutable);
112 #if defined(CLANG_CONFIG_FILE_SYSTEM_DIR) 115 #if defined(CLANG_CONFIG_FILE_USER_DIR) 120 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
122 if (ClangResourceDir !=
"") {
123 llvm::sys::path::append(P, ClangResourceDir);
125 StringRef ClangLibdirSuffix(CLANG_LIBDIR_SUFFIX);
126 P = llvm::sys::path::parent_path(
Dir);
127 llvm::sys::path::append(P, Twine(
"lib") + ClangLibdirSuffix,
"clang",
128 CLANG_VERSION_STRING);
139 for (
const char *ArgPtr : Args) {
141 if (ArgPtr ==
nullptr)
143 const StringRef Arg = ArgPtr;
144 setDriverModeFromOption(Arg);
148 void Driver::setDriverModeFromOption(StringRef Opt) {
149 const std::string OptName =
150 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
151 if (!Opt.startswith(OptName))
153 StringRef
Value = Opt.drop_front(OptName.size());
156 .Case(
"gcc", GCCMode)
157 .Case(
"g++", GXXMode)
158 .Case(
"cpp", CPPMode)
163 Diag(diag::err_drv_unsupported_option_argument) << OptName <<
Value;
167 bool &ContainsError) {
168 llvm::PrettyStackTraceString CrashInfo(
"Command line argument parsing");
169 ContainsError =
false;
171 unsigned IncludedFlagsBitmask;
172 unsigned ExcludedFlagsBitmask;
173 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
174 getIncludeExcludeOptionFlagMasks();
176 unsigned MissingArgIndex, MissingArgCount;
178 getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount,
179 IncludedFlagsBitmask, ExcludedFlagsBitmask);
182 if (MissingArgCount) {
183 Diag(diag::err_drv_missing_argument)
184 << Args.getArgString(MissingArgIndex) << MissingArgCount;
191 for (
const Arg *A : Args) {
194 auto ArgString = A->getAsString(Args);
197 ArgString, Nearest, IncludedFlagsBitmask,
199 DiagID = diag::err_drv_unsupported_opt;
200 Diag(DiagID) << ArgString;
202 DiagID = diag::err_drv_unsupported_opt_with_suggestion;
203 Diag(DiagID) << ArgString << Nearest;
211 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue(
"")) {
212 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
214 diag::warn_drv_empty_joined_argument,
219 for (
const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {
221 auto ArgString = A->getAsString(Args);
224 ArgString, Nearest, IncludedFlagsBitmask, ExcludedFlagsBitmask) > 1) {
225 DiagID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl
226 : diag::err_drv_unknown_argument;
227 Diags.
Report(DiagID) << ArgString;
229 DiagID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl_with_suggestion
230 : diag::err_drv_unknown_argument_with_suggestion;
231 Diags.
Report(DiagID) << ArgString << Nearest;
243 phases::ID Driver::getFinalPhase(
const DerivedArgList &DAL,
244 Arg **FinalPhaseArg)
const {
245 Arg *PhaseArg =
nullptr;
249 if (
CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
250 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
251 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
252 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
256 }
else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
260 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
261 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
262 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
263 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
264 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
265 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
266 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
267 options::OPT__analyze_auto)) ||
268 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
272 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
276 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
284 *FinalPhaseArg = PhaseArg;
290 StringRef
Value,
bool Claim =
true) {
291 Arg *A =
new Arg(Opts.getOption(options::OPT_INPUT),
Value,
292 Args.getBaseArgs().MakeIndex(Value), Value.data());
293 Args.AddSynthesizedArg(A);
299 DerivedArgList *Driver::TranslateInputArgs(
const InputArgList &Args)
const {
300 DerivedArgList *DAL =
new DerivedArgList(Args);
302 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
303 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
304 for (Arg *A : Args) {
311 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
312 A->getOption().matches(options::OPT_Xlinker)) &&
313 A->containsValue(
"--no-demangle")) {
315 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
318 for (StringRef Val : A->getValues())
319 if (Val !=
"--no-demangle")
320 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val);
328 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
329 (A->getValue(0) == StringRef(
"-MD") ||
330 A->getValue(0) == StringRef(
"-MMD"))) {
332 if (A->getValue(0) == StringRef(
"-MD"))
333 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
335 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
336 if (A->getNumValues() == 2)
337 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
343 if (A->getOption().matches(options::OPT_l)) {
344 StringRef
Value = A->getValue();
347 if (!HasNostdlib && !HasNodefaultlib && Value ==
"stdc++") {
348 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx));
353 if (Value ==
"cc_kext") {
354 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext));
360 if (A->getOption().matches(options::OPT__DASH_DASH)) {
362 for (StringRef Val : A->getValues())
371 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false))
372 DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
376 #if defined(HOST_LINK_VERSION) 377 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
378 strlen(HOST_LINK_VERSION) > 0) {
379 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
381 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
393 StringRef TargetTriple,
395 StringRef DarwinArchName =
"") {
397 if (
const Arg *A = Args.getLastArg(options::OPT_target))
398 TargetTriple = A->getValue();
403 if (Target.isOSBinFormatMachO()) {
405 if (!DarwinArchName.empty()) {
411 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
412 StringRef ArchName = A->getValue();
419 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
420 options::OPT_mbig_endian)) {
421 if (A->getOption().matches(options::OPT_mlittle_endian)) {
422 llvm::Triple LE = Target.getLittleEndianArchVariant();
423 if (LE.getArch() != llvm::Triple::UnknownArch)
424 Target = std::move(LE);
426 llvm::Triple BE = Target.getBigEndianArchVariant();
427 if (BE.getArch() != llvm::Triple::UnknownArch)
428 Target = std::move(BE);
433 if (Target.getArch() == llvm::Triple::tce ||
434 Target.getOS() == llvm::Triple::Minix)
438 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
439 options::OPT_m32, options::OPT_m16);
441 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
443 if (A->getOption().matches(options::OPT_m64)) {
444 AT = Target.get64BitArchVariant().getArch();
445 if (Target.getEnvironment() == llvm::Triple::GNUX32)
446 Target.setEnvironment(llvm::Triple::GNU);
447 }
else if (A->getOption().matches(options::OPT_mx32) &&
448 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
449 AT = llvm::Triple::x86_64;
450 Target.setEnvironment(llvm::Triple::GNUX32);
451 }
else if (A->getOption().matches(options::OPT_m32)) {
452 AT = Target.get32BitArchVariant().getArch();
453 if (Target.getEnvironment() == llvm::Triple::GNUX32)
454 Target.setEnvironment(llvm::Triple::GNU);
455 }
else if (A->getOption().matches(options::OPT_m16) &&
456 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
457 AT = llvm::Triple::x86;
458 Target.setEnvironment(llvm::Triple::CODE16);
461 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
466 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
467 if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
468 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-miamcu" 471 if (A && !A->getOption().matches(options::OPT_m32))
472 D.
Diag(diag::err_drv_argument_not_allowed_with)
473 <<
"-miamcu" << A->getBaseArg().getAsString(Args);
475 Target.setArch(llvm::Triple::x86);
476 Target.setArchName(
"i586");
477 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
478 Target.setEnvironmentName(
"");
479 Target.setOS(llvm::Triple::ELFIAMCU);
480 Target.setVendor(llvm::Triple::UnknownVendor);
481 Target.setVendorName(
"intel");
489 void Driver::setLTOMode(
const llvm::opt::ArgList &Args) {
491 if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ,
492 options::OPT_fno_lto,
false))
495 StringRef LTOName(
"full");
497 const Arg *A = Args.getLastArg(options::OPT_flto_EQ);
499 LTOName = A->getValue();
501 LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
508 Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
515 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
517 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
519 RuntimeName = A->getValue();
521 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
529 Diag(diag::err_drv_unsupported_option_argument)
530 << A->getOption().getName() << A->getValue();
533 Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
548 llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
553 [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
557 if (IsCuda && IsHIP) {
558 Diag(clang::diag::err_drv_mix_cuda_hip);
563 const llvm::Triple &HostTriple = HostTC->
getTriple();
564 StringRef DeviceTripleStr;
567 HostTriple.isArch64Bit() ?
"nvptx64-nvidia-cuda" :
"nvptx-nvidia-cuda";
568 llvm::Triple CudaTriple(DeviceTripleStr);
571 auto &CudaTC = ToolChains[CudaTriple.str() +
"/" + HostTriple.str()];
573 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
579 const llvm::Triple &HostTriple = HostTC->
getTriple();
580 StringRef DeviceTripleStr;
582 DeviceTripleStr =
"amdgcn-amd-amdhsa";
583 llvm::Triple HIPTriple(DeviceTripleStr);
586 auto &HIPTC = ToolChains[HIPTriple.str() +
"/" + HostTriple.str()];
588 HIPTC = llvm::make_unique<toolchains::HIPToolChain>(
599 if (Arg *OpenMPTargets =
600 C.
getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
601 if (OpenMPTargets->getNumValues()) {
606 options::OPT_fopenmp, options::OPT_fopenmp_EQ,
607 options::OPT_fno_openmp,
false);
608 if (HasValidOpenMPRuntime) {
610 HasValidOpenMPRuntime =
614 if (HasValidOpenMPRuntime) {
615 llvm::StringMap<const char *> FoundNormalizedTriples;
616 for (
const char *Val : OpenMPTargets->getValues()) {
617 llvm::Triple TT(Val);
618 std::string NormalizedName = TT.normalize();
621 auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
622 if (Duplicate != FoundNormalizedTriples.end()) {
623 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
624 << Val << Duplicate->second;
630 FoundNormalizedTriples[NormalizedName] = Val;
633 if (TT.getArch() == llvm::Triple::UnknownArch)
634 Diag(clang::diag::err_drv_invalid_omp_target) << Val;
642 assert(HostTC &&
"Host toolchain should be always defined.");
644 ToolChains[TT.str() +
"/" + HostTC->
getTriple().normalize()];
646 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
655 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
657 Diag(clang::diag::warn_drv_empty_joined_argument)
678 StringRef FileName) {
680 for (
const StringRef &
Dir : Dirs) {
684 llvm::sys::path::append(WPath,
Dir, FileName);
685 llvm::sys::path::native(WPath);
686 if (llvm::sys::fs::is_regular_file(WPath)) {
687 FilePath = std::move(WPath);
694 bool Driver::readConfigFile(StringRef FileName) {
697 if (!llvm::cl::readConfigFile(FileName, Saver, NewCfgArgs)) {
698 Diag(diag::err_drv_cannot_read_config_file) << FileName;
704 llvm::sys::path::native(CfgFileName);
705 ConfigFile = CfgFileName.str();
707 CfgOptions = llvm::make_unique<InputArgList>(
714 if (CfgOptions->hasArg(options::OPT_config)) {
716 Diag(diag::err_drv_nested_config_file);
722 for (Arg *A : *CfgOptions)
727 bool Driver::loadConfigFile() {
728 std::string CfgFileName;
729 bool FileSpecifiedExplicitly =
false;
733 if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
736 CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
737 if (!CfgDir.empty()) {
738 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
744 if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
747 CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ));
748 if (!CfgDir.empty()) {
749 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
759 std::vector<std::string> ConfigFiles =
760 CLOptions->getAllArgValues(options::OPT_config);
761 if (ConfigFiles.size() > 1) {
762 Diag(diag::err_drv_duplicate_config);
766 if (!ConfigFiles.empty()) {
767 CfgFileName = ConfigFiles.front();
768 assert(!CfgFileName.empty());
772 if (llvm::sys::path::has_parent_path(CfgFileName)) {
774 if (llvm::sys::path::is_relative(CfgFileName))
775 llvm::sys::fs::current_path(CfgFilePath);
776 llvm::sys::path::append(CfgFilePath, CfgFileName);
777 if (!llvm::sys::fs::is_regular_file(CfgFilePath)) {
778 Diag(diag::err_drv_config_file_not_exist) << CfgFilePath;
781 return readConfigFile(CfgFilePath);
784 FileSpecifiedExplicitly =
true;
794 if (CfgFileName.empty())
798 StringRef CfgFileArch = CfgFileName;
799 size_t ArchPrefixLen = CfgFileArch.find(
'-');
800 if (ArchPrefixLen == StringRef::npos)
801 ArchPrefixLen = CfgFileArch.size();
802 llvm::Triple CfgTriple;
803 CfgFileArch = CfgFileArch.take_front(ArchPrefixLen);
805 if (CfgTriple.getArch() == llvm::Triple::ArchType::UnknownArch)
808 if (!StringRef(CfgFileName).endswith(
".cfg"))
809 CfgFileName +=
".cfg";
815 size_t FixedArchPrefixLen = 0;
821 CfgTriple.getTriple(), *CLOptions);
822 if (CfgTriple.getArch() != EffectiveTriple.getArch()) {
823 FixedConfigFile = EffectiveTriple.getArchName();
824 FixedArchPrefixLen = FixedConfigFile.size();
827 if (ArchPrefixLen < CfgFileName.size())
828 FixedConfigFile += CfgFileName.substr(ArchPrefixLen);
836 CfgFileSearchDirs.push_back(
Dir);
840 if (!FixedConfigFile.empty()) {
841 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
842 return readConfigFile(CfgFilePath);
844 FixedConfigFile.resize(FixedArchPrefixLen);
845 FixedConfigFile.append(
".cfg");
846 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
847 return readConfigFile(CfgFilePath);
851 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
852 return readConfigFile(CfgFilePath);
858 CfgFileName.append(
".cfg");
859 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
860 return readConfigFile(CfgFilePath);
865 if (FileSpecifiedExplicitly) {
866 Diag(diag::err_drv_config_file_not_found) << CfgFileName;
867 for (
const std::string &SearchDir : CfgFileSearchDirs)
868 if (!SearchDir.empty())
869 Diag(diag::note_drv_config_file_searched_in) << SearchDir;
877 llvm::PrettyStackTraceString CrashInfo(
"Compilation construction");
883 llvm::sys::Process::GetEnv(
"COMPILER_PATH")) {
884 StringRef CompilerPath = *CompilerPathValue;
885 while (!CompilerPath.empty()) {
886 std::pair<StringRef, StringRef> Split =
887 CompilerPath.split(llvm::sys::EnvPathSeparator);
889 CompilerPath = Split.second;
901 CLOptions = llvm::make_unique<InputArgList>(
906 ContainsError = loadConfigFile();
907 bool HasConfigFile = !ContainsError && (CfgOptions.get() !=
nullptr);
910 InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
911 : std::move(*CLOptions));
913 for (
auto *Opt : *CLOptions) {
914 if (Opt->getOption().matches(options::OPT_config))
916 unsigned Index = Args.MakeIndex(Opt->getSpelling());
917 const Arg *BaseArg = &Opt->getBaseArg();
920 Arg *Copy =
new llvm::opt::Arg(Opt->getOption(), Opt->getSpelling(),
922 Copy->getValues() = Opt->getValues();
923 if (Opt->isClaimed())
935 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
938 Args.ClaimAllArgs(options::OPT_pipe);
946 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
948 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
949 CCCGenericGCCName = A->getValue();
951 Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth);
953 options::OPT_fno_crash_diagnostics,
954 !!::getenv(
"FORCE_CLANG_DIAGNOSTICS_CRASH"));
959 llvm::Triple T(TargetTriple);
960 T.setOS(llvm::Triple::Win32);
961 T.setVendor(llvm::Triple::PC);
962 T.setEnvironment(llvm::Triple::MSVC);
963 T.setObjectFormat(llvm::Triple::COFF);
964 TargetTriple = T.str();
966 if (
const Arg *A = Args.getLastArg(options::OPT_target))
967 TargetTriple = A->getValue();
968 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
970 for (
const Arg *A : Args.filtered(options::OPT_B)) {
974 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
976 if (
const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
979 if (
const Arg *A = Args.getLastArg(options::OPT_resource_dir))
982 if (
const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
983 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
984 .Case(
"cwd", SaveTempsCwd)
985 .Case(
"obj", SaveTempsObj)
986 .Default(SaveTempsCwd);
992 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
993 StringRef
Name = A->getValue();
994 unsigned Model = llvm::StringSwitch<unsigned>(
Name)
995 .Case(
"off", EmbedNone)
996 .Case(
"all", EmbedBitcode)
997 .Case(
"bitcode", EmbedBitcode)
998 .Case(
"marker", EmbedMarker)
1001 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1004 BitcodeEmbed =
static_cast<BitcodeEmbedMode
>(Model);
1007 std::unique_ptr<llvm::opt::InputArgList> UArgs =
1008 llvm::make_unique<InputArgList>(std::move(Args));
1011 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
1033 if (TC.
getTriple().isOSBinFormatMachO())
1038 if (CCCPrintPhases) {
1048 static void printArgList(raw_ostream &OS,
const llvm::opt::ArgList &Args) {
1049 llvm::opt::ArgStringList ASL;
1050 for (
const auto *A : Args)
1051 A->render(Args, ASL);
1053 for (
auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
1054 if (I != ASL.begin())
1061 bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename,
1064 assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&
1065 "Only knows about .crash files on Darwin");
1070 path::home_directory(CrashDiagDir);
1071 if (CrashDiagDir.startswith(
"/var/root"))
1073 path::append(CrashDiagDir,
"Library/Logs/DiagnosticReports");
1081 fs::file_status FileStatus;
1082 TimePoint<> LastAccessTime;
1086 for (fs::directory_iterator File(CrashDiagDir, EC), FileEnd;
1087 File != FileEnd && !EC; File.increment(EC)) {
1088 StringRef FileName = path::filename(File->path());
1089 if (!FileName.startswith(
Name))
1091 if (fs::status(File->path(), FileStatus))
1093 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
1094 llvm::MemoryBuffer::getFile(File->path());
1099 StringRef Data = CrashFile.get()->getBuffer();
1100 if (!Data.startswith(
"Process:"))
1103 size_t ParentProcPos = Data.find(
"Parent Process:");
1104 if (ParentProcPos == StringRef::npos)
1106 size_t LineEnd = Data.find_first_of(
"\n", ParentProcPos);
1107 if (LineEnd == StringRef::npos)
1109 StringRef ParentProcess = Data.slice(ParentProcPos+15, LineEnd).trim();
1110 int OpenBracket = -1, CloseBracket = -1;
1111 for (
size_t i = 0, e = ParentProcess.size(); i < e; ++i) {
1112 if (ParentProcess[i] ==
'[')
1114 if (ParentProcess[i] ==
']')
1120 if (OpenBracket < 0 || CloseBracket < 0 ||
1121 ParentProcess.slice(OpenBracket + 1, CloseBracket)
1122 .getAsInteger(10, CrashPID) || CrashPID != PID) {
1132 const auto FileAccessTime = FileStatus.getLastModificationTime();
1133 if (FileAccessTime > LastAccessTime) {
1134 CrashFilePath.assign(File->path());
1135 LastAccessTime = FileAccessTime;
1140 if (!CrashFilePath.empty()) {
1141 EC = fs::copy_file(CrashFilePath, ReproCrashFilename);
1156 if (C.
getArgs().hasArg(options::OPT_fno_crash_diagnostics))
1167 Diag(clang::diag::note_drv_command_failed_diag_msg)
1168 <<
"PLEASE submit a bug report to " BUG_REPORT_URL
" and include the " 1169 "crash backtrace, preprocessed source, and associated run script.";
1189 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
1190 bool IgnoreInput =
false;
1196 }
else if (!strcmp(it->second->getValue(),
"-")) {
1197 Diag(clang::diag::note_drv_command_failed_diag_msg)
1198 <<
"Error generating preprocessed source(s) - " 1199 "ignoring input from stdin.";
1204 it = Inputs.erase(it);
1211 if (Inputs.empty()) {
1212 Diag(clang::diag::note_drv_command_failed_diag_msg)
1213 <<
"Error generating preprocessed source(s) - " 1214 "no preprocessable inputs.";
1220 llvm::StringSet<> ArchNames;
1221 for (
const Arg *A : C.
getArgs()) {
1222 if (A->getOption().matches(options::OPT_arch)) {
1223 StringRef ArchName = A->getValue();
1224 ArchNames.insert(ArchName);
1227 if (ArchNames.size() > 1) {
1228 Diag(clang::diag::note_drv_command_failed_diag_msg)
1229 <<
"Error generating preprocessed source(s) - cannot generate " 1230 "preprocessed source with multiple -arch options.";
1237 if (TC.
getTriple().isOSBinFormatMachO())
1246 Diag(clang::diag::note_drv_command_failed_diag_msg)
1247 <<
"Error generating preprocessed source(s).";
1256 if (!FailingCommands.empty()) {
1257 Diag(clang::diag::note_drv_command_failed_diag_msg)
1258 <<
"Error generating preprocessed source(s).";
1263 if (TempFiles.empty()) {
1264 Diag(clang::diag::note_drv_command_failed_diag_msg)
1265 <<
"Error generating preprocessed source(s).";
1269 Diag(clang::diag::note_drv_command_failed_diag_msg)
1270 <<
"\n********************\n\n" 1271 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" 1272 "Preprocessed source(s) and associated run script(s) are located at:";
1276 for (
const char *TempFile : TempFiles) {
1277 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
1280 if (ReproCrashFilename.empty()) {
1281 ReproCrashFilename = TempFile;
1282 llvm::sys::path::replace_extension(ReproCrashFilename,
".crash");
1284 if (StringRef(TempFile).endswith(
".cache")) {
1287 VFS = llvm::sys::path::filename(TempFile);
1288 llvm::sys::path::append(VFS,
"vfs",
"vfs.yaml");
1296 llvm::sys::path::replace_extension(Script,
"sh");
1298 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::CD_CreateNew);
1300 Diag(clang::diag::note_drv_command_failed_diag_msg)
1301 <<
"Error generating run script: " << Script <<
" " << EC.message();
1304 <<
"# Driver args: ";
1306 ScriptOS <<
"# Original command: ";
1307 Cmd.
Print(ScriptOS,
"\n",
true);
1308 Cmd.
Print(ScriptOS,
"\n",
true, &CrashInfo);
1309 if (!AdditionalInformation.empty())
1310 ScriptOS <<
"\n# Additional information: " << AdditionalInformation
1314 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
1318 if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) {
1320 if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) {
1321 Diag(clang::diag::note_drv_command_failed_diag_msg)
1322 << ReproCrashFilename.str();
1324 llvm::sys::path::append(CrashDiagDir,
Name);
1325 CrashDiagDir +=
"_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
1326 Diag(clang::diag::note_drv_command_failed_diag_msg)
1327 <<
"Crash backtrace is located in";
1328 Diag(clang::diag::note_drv_command_failed_diag_msg)
1329 << CrashDiagDir.str();
1330 Diag(clang::diag::note_drv_command_failed_diag_msg)
1331 <<
"(choose the .crash file that corresponds to your crash)";
1335 for (
const auto &A : C.
getArgs().filtered(options::OPT_frewrite_map_file,
1336 options::OPT_frewrite_map_file_EQ))
1337 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
1339 Diag(clang::diag::note_drv_command_failed_diag_msg)
1340 <<
"\n\n********************";
1359 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1365 if (Diags.hasErrorOccurred())
1370 setUpResponseFiles(C, Job);
1375 if (FailingCommands.empty())
1380 for (
const auto &CmdPair : FailingCommands) {
1381 int Res = CmdPair.first;
1382 const Command *FailingCommand = CmdPair.second;
1406 Diag(clang::diag::err_drv_command_signalled)
1417 unsigned IncludedFlagsBitmask;
1418 unsigned ExcludedFlagsBitmask;
1419 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
1420 getIncludeExcludeOptionFlagMasks();
1424 ExcludedFlagsBitmask |= HelpHidden;
1427 IncludedFlagsBitmask, ExcludedFlagsBitmask,
1439 if (Arg *A = C.
getArgs().getLastArg(options::OPT_mthread_model)) {
1442 OS <<
"Thread model: " << A->getValue();
1451 if (!ConfigFile.empty())
1452 OS <<
"Configuration file: " << ConfigFile <<
'\n';
1465 if (PassedFlags ==
"")
1469 std::vector<std::string> SuggestedCompletions;
1470 std::vector<std::string> Flags;
1472 unsigned short DisableFlags =
1477 StringRef TargetFlags = PassedFlags;
1478 while (TargetFlags !=
"") {
1480 std::tie(CurFlag, TargetFlags) = TargetFlags.split(
",");
1481 Flags.push_back(std::string(CurFlag));
1486 if (std::find(Flags.begin(), Flags.end(),
"-Xclang") != Flags.end() ||
1487 std::find(Flags.begin(), Flags.end(),
"-cc1") != Flags.end())
1491 Cur = Flags.at(Flags.size() - 1);
1493 if (Flags.size() >= 2) {
1494 Prev = Flags.at(Flags.size() - 2);
1495 SuggestedCompletions = Opts->suggestValueCompletions(Prev, Cur);
1498 if (SuggestedCompletions.empty())
1499 SuggestedCompletions = Opts->suggestValueCompletions(Cur,
"");
1501 if (SuggestedCompletions.empty()) {
1505 SuggestedCompletions = Opts->findByPrefix(Cur, DisableFlags);
1511 if (S.startswith(Cur))
1512 SuggestedCompletions.push_back(S);
1519 llvm::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(),
1520 [](StringRef A, StringRef B) {
1521 if (
int X = A.compare_lower(B))
1523 return A.compare(B) > 0;
1526 llvm::outs() << llvm::join(SuggestedCompletions,
"\n") <<
'\n';
1533 if (C.
getArgs().hasArg(options::OPT_dumpmachine)) {
1538 if (C.
getArgs().hasArg(options::OPT_dumpversion)) {
1545 llvm::outs() <<
"4.2.1\n";
1549 if (C.
getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
1554 if (C.
getArgs().hasArg(options::OPT_help) ||
1555 C.
getArgs().hasArg(options::OPT__help_hidden)) {
1560 if (C.
getArgs().hasArg(options::OPT__version)) {
1566 if (C.
getArgs().hasArg(options::OPT_v) ||
1567 C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1569 SuppressMissingInputWarning =
true;
1572 if (C.
getArgs().hasArg(options::OPT_v)) {
1574 llvm::errs() <<
"System configuration file directory: " 1577 llvm::errs() <<
"User configuration file directory: " 1583 if (C.
getArgs().hasArg(options::OPT_v))
1586 if (C.
getArgs().hasArg(options::OPT_print_resource_dir)) {
1591 if (C.
getArgs().hasArg(options::OPT_print_search_dirs)) {
1592 llvm::outs() <<
"programs: =";
1593 bool separator =
false;
1596 llvm::outs() <<
':';
1597 llvm::outs() << Path;
1600 llvm::outs() <<
"\n";
1607 llvm::outs() <<
':';
1610 llvm::outs() << sysroot << Path.substr(1);
1612 llvm::outs() << Path;
1614 llvm::outs() <<
"\n";
1620 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
1621 llvm::outs() <<
GetFilePath(A->getValue(), TC) <<
"\n";
1625 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
1626 StringRef ProgName = A->getValue();
1629 if (! ProgName.empty())
1632 llvm::outs() <<
"\n";
1636 if (Arg *A = C.
getArgs().getLastArg(options::OPT_autocomplete)) {
1637 StringRef PassedFlags = A->getValue();
1642 if (C.
getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
1651 llvm::outs() <<
GetFilePath(
"libgcc.a", TC) <<
"\n";
1657 if (C.
getArgs().hasArg(options::OPT_print_multi_lib)) {
1663 if (C.
getArgs().hasArg(options::OPT_print_multi_directory)) {
1666 llvm::outs() <<
".\n";
1669 assert(Suffix.front() ==
'/');
1670 llvm::outs() << Suffix.substr(1) <<
"\n";
1682 std::map<Action *, unsigned> &Ids) {
1687 llvm::raw_string_ostream os(str);
1691 os <<
"\"" << IA->getInputArg().getValue() <<
"\"";
1693 os <<
'"' << BIA->getArchName() <<
'"' <<
", {" 1695 }
else if (
OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1696 bool IsFirst =
true;
1697 OA->doOnEachDependence(
1714 os <<
":" << BoundArch;
1724 const char *Prefix =
"{";
1725 for (
Action *PreRequisite : *AL) {
1736 std::string offload_str;
1737 llvm::raw_string_ostream offload_os(offload_str);
1738 if (!isa<OffloadAction>(A)) {
1741 offload_os <<
", (" << S;
1748 unsigned Id = Ids.size();
1750 llvm::errs() << Id <<
": " << os.str() <<
", " 1759 std::map<Action *, unsigned> Ids;
1767 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
1768 isa<AssembleJobAction>(A))
1780 DerivedArgList &Args = C.
getArgs();
1782 llvm::PrettyStackTraceString CrashInfo(
"Building universal build actions");
1785 llvm::StringSet<> ArchNames;
1787 for (Arg *A : Args) {
1788 if (A->getOption().matches(options::OPT_arch)) {
1791 llvm::Triple::ArchType Arch =
1793 if (Arch == llvm::Triple::UnknownArch) {
1794 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
1799 if (ArchNames.insert(A->getValue()).second)
1800 Archs.push_back(A->getValue());
1814 for (
Action* Act : SingleActions) {
1822 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
1826 for (
unsigned i = 0, e = Archs.size(); i != e; ++i)
1831 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1832 Actions.append(Inputs.begin(), Inputs.end());
1837 Arg *A = Args.getLastArg(options::OPT_g_Group);
1838 if (A && !A->getOption().matches(options::OPT_g0) &&
1839 !A->getOption().matches(options::OPT_gstabs) &&
1846 if (Act->getType() == types::TY_Image) {
1848 Inputs.push_back(Actions.back());
1855 if (Args.hasArg(options::OPT_verify_debug_info)) {
1856 Action* LastAction = Actions.back();
1859 LastAction, types::TY_Nothing));
1877 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
1878 if (!llvm::sys::path::is_absolute(Path)) {
1880 llvm::sys::path::append(Directory, Value);
1881 Path.assign(Directory);
1885 if (llvm::sys::fs::exists(Twine(Path)))
1889 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1890 llvm::sys::Process::FindInEnvPath(
"LIB", Value))
1893 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1901 D.
Diag(clang::diag::err_drv_no_such_file) << Path;
1911 types::ID InputType = types::TY_Nothing;
1912 Arg *InputTypeArg =
nullptr;
1915 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1916 options::OPT__SLASH_TP)) {
1917 InputTypeArg = TCTP;
1918 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
1923 bool ShowNote =
false;
1924 for (Arg *A : Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) {
1926 Diag(clang::diag::warn_drv_overriding_flag_option)
1927 << Previous->getSpelling() << A->getSpelling();
1933 Diag(clang::diag::note_drv_t_option_is_global);
1936 assert(!Args.hasArg(options::OPT_x) &&
"-x and /TC or /TP is not allowed");
1939 for (Arg *A : Args) {
1940 if (A->getOption().getKind() == Option::InputClass) {
1941 const char *
Value = A->getValue();
1945 if (InputType == types::TY_Nothing) {
1948 InputTypeArg->claim();
1951 if (memcmp(Value,
"-", 2) == 0) {
1957 if (!Args.hasArgNoClaim(options::OPT_E) && !
CCCIsCPP())
1958 Diag(
IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1959 : clang::diag::err_drv_unknown_stdin_type);
1966 if (
const char *Ext = strrchr(Value,
'.'))
1973 Ty = types::TY_Object;
1983 Diag(clang::diag::warn_drv_treating_input_as_cxx)
1993 if (Ty != types::TY_Object) {
1994 if (Args.hasArg(options::OPT_ObjC))
1995 Ty = types::TY_ObjC;
1996 else if (Args.hasArg(options::OPT_ObjCXX))
1997 Ty = types::TY_ObjCXX;
2000 assert(InputTypeArg &&
"InputType set w/o InputTypeArg");
2001 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
2004 const char *Ext = strrchr(Value,
'.');
2006 Ty = types::TY_Object;
2010 InputTypeArg->claim();
2015 Inputs.push_back(std::make_pair(Ty, A));
2017 }
else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
2018 StringRef
Value = A->getValue();
2020 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
2021 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
2024 }
else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
2025 StringRef
Value = A->getValue();
2027 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
2028 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
2034 Inputs.push_back(std::make_pair(types::TY_Object, A));
2036 }
else if (A->getOption().matches(options::OPT_x)) {
2045 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
2046 InputType = types::TY_Object;
2048 }
else if (A->getOption().getID() == options::OPT__SLASH_U) {
2049 assert(A->getNumValues() == 1 &&
"The /U option has one value.");
2050 StringRef Val = A->getValue(0);
2051 if (Val.find_first_of(
"/\\") != StringRef::npos) {
2053 Diag(diag::warn_slash_u_filename) << Val;
2054 Diag(diag::note_use_dashdash);
2058 if (
CCCIsCPP() && Inputs.empty()) {
2062 Inputs.push_back(std::make_pair(types::TY_C, A));
2069 class OffloadingActionBuilder final {
2071 bool IsValid =
false;
2077 std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
2080 class DeviceActionBuilder {
2084 enum ActionBuilderReturnCode {
2103 DerivedArgList &Args;
2112 DeviceActionBuilder(
Compilation &C, DerivedArgList &Args,
2115 : C(C), Args(Args), Inputs(Inputs),
2116 AssociatedOffloadKind(AssociatedOffloadKind) {}
2117 virtual ~DeviceActionBuilder() {}
2122 virtual ActionBuilderReturnCode
2126 return ABRT_Inactive;
2131 virtual ActionBuilderReturnCode addDeviceDepences(
Action *HostAction) {
2132 return ABRT_Inactive;
2137 virtual void appendTopLevelActions(
ActionList &AL) {}
2148 virtual bool canUseBundlerUnbundler()
const {
return false; }
2152 bool isValid() {
return !ToolChains.empty(); }
2156 return AssociatedOffloadKind;
2162 class CudaActionBuilderBase :
public DeviceActionBuilder {
2166 bool CompileHostOnly =
false;
2167 bool CompileDeviceOnly =
false;
2176 Action *CudaFatBinary =
nullptr;
2179 bool IsActive =
false;
2181 CudaActionBuilderBase(
Compilation &C, DerivedArgList &Args,
2184 : DeviceActionBuilder(C, Args, Inputs, OFKind) {}
2186 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2193 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2194 assert(!GpuArchList.empty() &&
2195 "We should have at least one GPU architecture.");
2199 if (IA->getType() != types::TY_CUDA &&
2200 IA->getType() != types::TY_HIP) {
2203 return ABRT_Inactive;
2209 if (CompileHostOnly)
2210 return ABRT_Success;
2213 auto Ty = IA->getType() == types::TY_HIP ? types::TY_HIP_DEVICE
2214 : types::TY_CUDA_DEVICE;
2215 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2216 CudaDeviceActions.push_back(
2220 return ABRT_Success;
2224 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2225 CudaDeviceActions.clear();
2226 for (
auto Arch : GpuArchList) {
2227 CudaDeviceActions.push_back(UA);
2229 AssociatedOffloadKind);
2231 return ABRT_Success;
2234 return IsActive ? ABRT_Success : ABRT_Inactive;
2237 void appendTopLevelActions(
ActionList &AL)
override {
2242 AssociatedOffloadKind);
2247 if (CudaFatBinary) {
2249 CudaDeviceActions.clear();
2250 CudaFatBinary =
nullptr;
2254 if (CudaDeviceActions.empty())
2260 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2261 "Expecting one action per GPU architecture.");
2262 assert(ToolChains.size() == 1 &&
2263 "Expecting to have a sing CUDA toolchain.");
2264 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
2265 AddTopLevel(CudaDeviceActions[I], GpuArchList[I]);
2267 CudaDeviceActions.clear();
2285 assert(HostTC &&
"No toolchain for host compilation.");
2287 HostTC->
getTriple().getArch() == llvm::Triple::amdgcn) {
2296 ToolChains.push_back(
2301 Arg *PartialCompilationArg = Args.getLastArg(
2302 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
2303 options::OPT_cuda_compile_host_device);
2304 CompileHostOnly = PartialCompilationArg &&
2305 PartialCompilationArg->getOption().matches(
2306 options::OPT_cuda_host_only);
2307 CompileDeviceOnly = PartialCompilationArg &&
2308 PartialCompilationArg->getOption().matches(
2309 options::OPT_cuda_device_only);
2312 std::set<CudaArch> GpuArchs;
2314 for (Arg *A : Args) {
2315 if (!(A->getOption().matches(options::OPT_cuda_gpu_arch_EQ) ||
2316 A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ)))
2320 const StringRef ArchStr = A->getValue();
2321 if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ) &&
2328 C.
getDriver().
Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
2330 }
else if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
2331 GpuArchs.insert(Arch);
2332 else if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ))
2333 GpuArchs.erase(Arch);
2335 llvm_unreachable(
"Unexpected option.");
2340 GpuArchList.push_back(Arch);
2345 if (GpuArchList.empty())
2354 class CudaActionBuilder final :
public CudaActionBuilderBase {
2356 CudaActionBuilder(
Compilation &C, DerivedArgList &Args,
2360 ActionBuilderReturnCode
2363 PhasesTy &Phases)
override {
2365 return ABRT_Inactive;
2369 if (CudaDeviceActions.empty())
2370 return ABRT_Success;
2372 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2373 "Expecting one action per GPU architecture.");
2374 assert(!CompileHostOnly &&
2375 "Not expecting CUDA actions in host-only compilation.");
2385 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2388 for (
auto Ph : Phases) {
2393 if (Ph > FinalPhase)
2406 if (!isa<AssembleJobAction>(CudaDeviceActions[I]) ||
2410 Action *AssembleAction = CudaDeviceActions[I];
2411 assert(AssembleAction->
getType() == types::TY_Object);
2412 assert(AssembleAction->
getInputs().size() == 1);
2415 assert(BackendAction->getType() == types::TY_PP_Asm);
2417 for (
auto &A : {AssembleAction, BackendAction}) {
2421 DeviceActions.push_back(
2427 if (!DeviceActions.empty()) {
2431 if (!CompileDeviceOnly) {
2432 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
2436 CudaFatBinary =
nullptr;
2441 CudaDeviceActions.clear();
2445 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
2450 return ABRT_Success;
2454 "instructions should only occur " 2455 "before the backend phase!");
2458 for (
Action *&A : CudaDeviceActions)
2461 return ABRT_Success;
2466 class HIPActionBuilder final :
public CudaActionBuilderBase {
2471 HIPActionBuilder(
Compilation &C, DerivedArgList &Args,
2475 bool canUseBundlerUnbundler()
const override {
return true; }
2477 ActionBuilderReturnCode
2480 PhasesTy &Phases)
override {
2485 return ABRT_Success;
2488 CudaDeviceActions.size() == GpuArchList.size()) &&
2489 "Expecting one action per GPU architecture.");
2490 assert(!CompileHostOnly &&
2491 "Not expecting CUDA actions in host-only compilation.");
2499 DeviceLinkerInputs.resize(CudaDeviceActions.size());
2500 auto LI = DeviceLinkerInputs.begin();
2501 for (
auto *A : CudaDeviceActions) {
2508 CudaDeviceActions.clear();
2509 return ABRT_Success;
2513 for (
Action *&A : CudaDeviceActions)
2515 AssociatedOffloadKind);
2517 return ABRT_Success;
2523 for (
auto &LI : DeviceLinkerInputs) {
2524 auto *DeviceLinkAction =
2526 DA.
add(*DeviceLinkAction, *ToolChains[0],
2535 class OpenMPActionBuilder final :
public DeviceActionBuilder {
2543 OpenMPActionBuilder(
Compilation &C, DerivedArgList &Args,
2547 ActionBuilderReturnCode
2550 PhasesTy &Phases)
override {
2553 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2554 "Number of OpenMP actions and toolchains do not match.");
2559 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2560 "Toolchains and linker inputs sizes do not match.");
2561 auto LI = DeviceLinkerInputs.begin();
2562 for (
auto *A : OpenMPDeviceActions) {
2569 OpenMPDeviceActions.clear();
2570 return ABRT_Success;
2574 for (
Action *&A : OpenMPDeviceActions)
2577 return ABRT_Success;
2580 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2583 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2584 OpenMPDeviceActions.clear();
2585 for (
unsigned I = 0; I < ToolChains.size(); ++I)
2586 OpenMPDeviceActions.push_back(
2588 return ABRT_Success;
2592 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2593 OpenMPDeviceActions.clear();
2594 for (
unsigned I = 0; I < ToolChains.size(); ++I) {
2595 OpenMPDeviceActions.push_back(UA);
2596 UA->registerDependentActionInfo(
2599 return ABRT_Success;
2606 if (isa<CompileJobAction>(HostAction)) {
2608 assert(ToolChains.size() == OpenMPDeviceActions.size() &&
2609 "Toolchains and device action sizes do not match.");
2613 auto TC = ToolChains.begin();
2614 for (
Action *&A : OpenMPDeviceActions) {
2615 assert(isa<CompileJobAction>(A));
2622 return ABRT_Success;
2625 void appendTopLevelActions(
ActionList &AL)
override {
2626 if (OpenMPDeviceActions.empty())
2630 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2631 "Number of OpenMP actions and toolchains do not match.");
2634 auto TI = ToolChains.begin();
2635 for (
auto *A : OpenMPDeviceActions) {
2642 OpenMPDeviceActions.clear();
2646 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2647 "Toolchains and linker inputs sizes do not match.");
2650 auto TC = ToolChains.begin();
2651 for (
auto &LI : DeviceLinkerInputs) {
2652 auto *DeviceLinkAction =
2654 DA.
add(*DeviceLinkAction, **TC,
nullptr,
2664 for (
auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE;
2666 ToolChains.push_back(TI->second);
2668 DeviceLinkerInputs.resize(ToolChains.size());
2672 bool canUseBundlerUnbundler()
const override {
2689 OffloadingActionBuilder(
Compilation &C, DerivedArgList &Args,
2697 SpecializedBuilders.push_back(
new CudaActionBuilder(C, Args, Inputs));
2700 SpecializedBuilders.push_back(
new HIPActionBuilder(C, Args, Inputs));
2703 SpecializedBuilders.push_back(
new OpenMPActionBuilder(C, Args, Inputs));
2711 unsigned ValidBuilders = 0u;
2712 unsigned ValidBuildersSupportingBundling = 0u;
2713 for (
auto *SB : SpecializedBuilders) {
2714 IsValid = IsValid && !SB->initialize();
2717 if (SB->isValid()) {
2719 if (SB->canUseBundlerUnbundler())
2720 ++ValidBuildersSupportingBundling;
2724 ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling;
2727 ~OffloadingActionBuilder() {
2728 for (
auto *SB : SpecializedBuilders)
2737 addDeviceDependencesToHostAction(
Action *HostAction,
const Arg *InputArg,
2739 DeviceActionBuilder::PhasesTy &Phases) {
2743 if (SpecializedBuilders.empty())
2746 assert(HostAction &&
"Invalid host action!");
2751 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2752 unsigned InactiveBuilders = 0u;
2753 unsigned IgnoringBuilders = 0u;
2754 for (
auto *SB : SpecializedBuilders) {
2755 if (!SB->isValid()) {
2761 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
2766 if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host)
2771 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2772 OffloadKind |= SB->getAssociatedOffloadKind();
2777 if (IgnoringBuilders &&
2778 SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders))
2795 bool addHostDependenceToDeviceActions(
Action *&HostAction,
2796 const Arg *InputArg) {
2806 if (CanUseBundler && isa<InputAction>(HostAction) &&
2807 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
2809 auto UnbundlingHostAction =
2814 HostAction = UnbundlingHostAction;
2817 assert(HostAction &&
"Invalid host action!");
2820 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2821 for (
auto *SB : SpecializedBuilders) {
2825 auto RetCode = SB->addDeviceDepences(HostAction);
2829 assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&
2830 "Host dependence not expected to be ignored.!");
2834 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2835 OffloadKind |= SB->getAssociatedOffloadKind();
2845 const Arg *InputArg) {
2848 for (
auto *SB : SpecializedBuilders) {
2851 SB->appendTopLevelActions(OffloadAL);
2856 if (CanUseBundler && !OffloadAL.empty()) {
2858 OffloadAL.push_back(HostAction);
2862 assert(HostAction == AL.back() &&
"Host action not in the list??");
2864 AL.back() = HostAction;
2866 AL.append(OffloadAL.begin(), OffloadAL.end());
2883 for (
auto *SB : SpecializedBuilders) {
2887 SB->appendLinkDependences(DDeps);
2891 unsigned ActiveOffloadKinds = 0u;
2892 for (
auto &I : InputArgToOffloadKindMap)
2893 ActiveOffloadKinds |= I.second;
2910 nullptr, ActiveOffloadKinds);
2918 llvm::PrettyStackTraceString CrashInfo(
"Building compilation actions");
2920 if (!SuppressMissingInputWarning && Inputs.empty()) {
2921 Diag(clang::diag::err_drv_no_input_files);
2926 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
2929 if (Args.hasArg(options::OPT_emit_llvm))
2930 Diag(clang::diag::err_drv_emit_llvm_link);
2932 !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower(
"lld"))
2933 Diag(clang::diag::err_drv_lto_without_lld);
2938 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
2939 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
2942 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
2943 StringRef V = A->getValue();
2944 if (Inputs.size() > 1 && !V.empty() &&
2945 !llvm::sys::path::is_separator(V.back())) {
2947 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
2948 << A->getSpelling() << V;
2949 Args.eraseArg(options::OPT__SLASH_Fo);
2954 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
2955 StringRef V = A->getValue();
2956 if (Inputs.size() > 1 && !V.empty() &&
2957 !llvm::sys::path::is_separator(V.back())) {
2959 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
2960 << A->getSpelling() << V;
2961 Args.eraseArg(options::OPT__SLASH_Fa);
2966 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
2967 if (A->getValue()[0] ==
'\0') {
2969 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
2970 Args.eraseArg(options::OPT__SLASH_o);
2978 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
2979 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
2980 if (YcArg && YcArg->getValue()[0] ==
'\0') {
2981 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YcArg->getSpelling();
2982 Args.eraseArg(options::OPT__SLASH_Yc);
2985 if (YuArg && YuArg->getValue()[0] ==
'\0') {
2986 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
2987 Args.eraseArg(options::OPT__SLASH_Yu);
2990 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
2991 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
2992 Args.eraseArg(options::OPT__SLASH_Yc);
2993 Args.eraseArg(options::OPT__SLASH_Yu);
2994 YcArg = YuArg =
nullptr;
2996 if (YcArg && Inputs.size() > 1) {
2997 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
2998 Args.eraseArg(options::OPT__SLASH_Yc);
3001 if (Args.hasArg(options::OPT__SLASH_Y_)) {
3004 Args.eraseArg(options::OPT__SLASH_Fp);
3005 Args.eraseArg(options::OPT__SLASH_Yc);
3006 Args.eraseArg(options::OPT__SLASH_Yu);
3007 YcArg = YuArg =
nullptr;
3011 OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
3017 for (
auto &I : Inputs) {
3019 const Arg *InputArg = I.second;
3027 if (InitialPhase > FinalPhase) {
3028 if (InputArg->isClaimed())
3035 if (Args.hasArg(options::OPT_Qunused_arguments))
3041 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
3042 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase);
3048 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
3049 << InputArg->getAsString(Args) << !!FinalPhaseArg
3050 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
3052 Diag(clang::diag::warn_drv_input_file_unused)
3053 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase)
3055 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
3071 Actions.push_back(ClangClPch);
3085 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
3093 if (Phase > FinalPhase)
3097 Current = OffloadBuilder.addDeviceDependencesToHostAction(
3098 Current, InputArg, Phase, FinalPhase, PL);
3104 assert((i + 1) == e &&
"linking must be final compilation step.");
3105 LinkerInputs.push_back(Current);
3114 if (NewCurrent == Current)
3117 Current = NewCurrent;
3121 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
3124 if (Current->
getType() == types::TY_Nothing)
3130 Actions.push_back(Current);
3133 OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg);
3137 if (!LinkerInputs.empty()) {
3139 LA = OffloadBuilder.processHostLinkAction(LA);
3140 Actions.push_back(LA);
3146 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
3147 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
3151 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
3155 Args.ClaimAllArgs(options::OPT_cuda_host_only);
3156 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
3162 llvm::PrettyStackTraceString CrashInfo(
"Constructing phase actions");
3173 llvm_unreachable(
"link action invalid here.");
3177 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
3178 OutputTy = types::TY_Dependencies;
3181 if (!Args.hasFlag(options::OPT_frewrite_includes,
3182 options::OPT_fno_rewrite_includes,
false) &&
3183 !Args.hasFlag(options::OPT_frewrite_imports,
3184 options::OPT_fno_rewrite_imports,
false) &&
3188 "Cannot preprocess this input type!");
3195 "Cannot precompile this input type!");
3196 if (Args.hasArg(options::OPT_fsyntax_only)) {
3198 OutputTy = types::TY_Nothing;
3203 if (Args.hasArg(options::OPT_fsyntax_only))
3205 if (Args.hasArg(options::OPT_rewrite_objc))
3207 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
3209 types::TY_RewrittenLegacyObjC);
3210 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
3212 if (Args.hasArg(options::OPT__migrate))
3214 if (Args.hasArg(options::OPT_emit_ast))
3216 if (Args.hasArg(options::OPT_module_file_info))
3218 if (Args.hasArg(options::OPT_verify_pch))
3225 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
3228 if (Args.hasArg(options::OPT_emit_llvm)) {
3230 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
3239 llvm_unreachable(
"invalid phase in ConstructPhaseAction");
3243 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3245 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
3250 unsigned NumOutputs = 0;
3252 if (A->getType() != types::TY_Nothing)
3255 if (NumOutputs > 1) {
3256 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
3257 FinalOutput =
nullptr;
3262 llvm::StringSet<> ArchNames;
3264 for (
const Arg *A : C.
getArgs())
3265 if (A->getOption().matches(options::OPT_arch))
3266 ArchNames.insert(A->getValue());
3269 std::map<std::pair<const Action *, std::string>,
InputInfo> CachedResults;
3277 const char *LinkingOutput =
nullptr;
3278 if (isa<LipoJobAction>(A)) {
3280 LinkingOutput = FinalOutput->getValue();
3288 ArchNames.size() > 1,
3289 LinkingOutput, CachedResults,
3295 if (Diags.hasErrorOccurred() ||
3296 C.
getArgs().hasArg(options::OPT_Qunused_arguments))
3300 (void)C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH);
3303 (void)C.
getArgs().hasArg(options::OPT_driver_mode);
3304 (void)C.
getArgs().hasArg(options::OPT_rsp_quoting);
3310 if (!A->isClaimed()) {
3316 const Option &Opt = A->getOption();
3317 if (Opt.getKind() == Option::FlagClass) {
3318 bool DuplicateClaimed =
false;
3320 for (
const Arg *AA : C.
getArgs().filtered(&Opt)) {
3321 if (AA->isClaimed()) {
3322 DuplicateClaimed =
true;
3327 if (DuplicateClaimed)
3333 if (!
IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
3334 Diag(clang::diag::warn_drv_unused_argument)
3335 << A->getAsString(C.
getArgs());
3343 class ToolSelector final {
3354 bool IsHostSelector;
3365 bool CanBeCollapsed =
true) {
3367 if (Inputs.size() != 1)
3370 Action *CurAction = *Inputs.begin();
3371 if (CanBeCollapsed &&
3377 if (
auto *OA = dyn_cast<OffloadAction>(CurAction)) {
3381 if (!IsHostSelector) {
3382 if (OA->hasSingleDeviceDependence(
true)) {
3384 OA->getSingleDeviceDependence(
true);
3385 if (CanBeCollapsed &&
3388 SavedOffloadAction.push_back(OA);
3391 }
else if (OA->hasHostDependence()) {
3392 CurAction = OA->getHostDependence();
3393 if (CanBeCollapsed &&
3396 SavedOffloadAction.push_back(OA);
3406 bool canCollapseAssembleAction()
const {
3407 return TC.useIntegratedAs() && !SaveTemps &&
3408 !C.
getArgs().hasArg(options::OPT_via_file_asm) &&
3409 !C.
getArgs().hasArg(options::OPT__SLASH_FA) &&
3410 !C.
getArgs().hasArg(options::OPT__SLASH_Fa);
3414 bool canCollapsePreprocessorAction()
const {
3415 return !C.
getArgs().hasArg(options::OPT_no_integrated_cpp) &&
3416 !C.
getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
3417 !C.
getArgs().hasArg(options::OPT_rewrite_objc);
3422 struct JobActionInfo final {
3432 static void AppendCollapsedOffloadAction(
ActionList &CollapsedOffloadAction,
3434 unsigned ElementNum) {
3435 assert(ElementNum <= ActionInfo.size() &&
"Invalid number of elements.");
3436 for (
unsigned I = 0; I < ElementNum; ++I)
3437 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
3438 ActionInfo[I].SavedOffloadAction.end());
3454 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
3459 if (!AJ || !BJ || !CJ)
3463 const Tool *T = TC.SelectTool(*CJ);
3470 const Tool *BT = TC.SelectTool(*BJ);
3478 Inputs = &CJ->getInputs();
3479 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3486 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
3495 auto *CJ = getPrevDependentAction(BJ->getInputs(), CompileJobOffloadActions,
3497 if (!AJ || !BJ || !CJ)
3500 assert(isa<CompileJobAction>(CJ) &&
3501 "Expecting compile job preceding backend job.");
3504 const Tool *T = TC.SelectTool(*CJ);
3511 Inputs = &BJ->getInputs();
3512 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3519 if (ActionInfo.size() < 2)
3531 bool InputIsBitcode =
true;
3532 for (
size_t i = 1; i < ActionInfo.size(); i++)
3533 if (ActionInfo[i].JA->getType() != types::TY_LLVM_BC &&
3534 ActionInfo[i].JA->getType() != types::TY_LTO_BC) {
3535 InputIsBitcode =
false;
3538 if (!InputIsBitcode && !canCollapsePreprocessorAction())
3542 const Tool *T = TC.SelectTool(*CJ);
3546 if (T->
canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode))
3549 Inputs = &CJ->getInputs();
3550 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3559 void combineWithPreprocessor(
const Tool *T,
const ActionList *&Inputs,
3566 auto *PJ = getPrevDependentAction(*Inputs, PreprocessJobOffloadActions);
3567 if (!PJ || !isa<PreprocessJobAction>(PJ))
3572 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
3573 PreprocessJobOffloadActions.end());
3574 Inputs = &PJ->getInputs();
3579 const Compilation &C,
bool SaveTemps,
bool EmbedBitcode)
3580 : TC(TC), C(C), BaseAction(BaseAction), SaveTemps(SaveTemps),
3581 EmbedBitcode(EmbedBitcode) {
3582 assert(BaseAction &&
"Invalid base action.");
3599 ActionChain.back().JA = BaseAction;
3600 while (ActionChain.back().JA) {
3601 const Action *CurAction = ActionChain.back().JA;
3604 ActionChain.resize(ActionChain.size() + 1);
3605 JobActionInfo &AI = ActionChain.back();
3609 getPrevDependentAction(CurAction->
getInputs(), AI.SavedOffloadAction);
3613 ActionChain.pop_back();
3621 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
3622 CollapsedOffloadAction);
3624 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
3626 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
3632 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
3644 StringRef BoundArch,
3646 std::string TriplePlusArch = TC->
getTriple().normalize();
3647 if (!BoundArch.empty()) {
3648 TriplePlusArch +=
"-";
3649 TriplePlusArch += BoundArch;
3651 TriplePlusArch +=
"-";
3653 return TriplePlusArch;
3658 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3659 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3661 std::pair<const Action *, std::string> ActionTC = {
3663 auto CachedResult = CachedResults.find(ActionTC);
3664 if (CachedResult != CachedResults.end()) {
3665 return CachedResult->second;
3667 InputInfo Result = BuildJobsForActionNoCache(
3668 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
3669 CachedResults, TargetDeviceOffloadKind);
3670 CachedResults[ActionTC] = Result;
3674 InputInfo Driver::BuildJobsForActionNoCache(
3676 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3677 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3679 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3682 bool BuildingForOffloadDevice = TargetDeviceOffloadKind !=
Action::OFK_None;
3714 if (OA->hasSingleDeviceDependence()) {
3716 OA->doOnEachDeviceDependence([&](
Action *DepA,
const ToolChain *DepTC,
3717 const char *DepBoundArch) {
3720 !!DepBoundArch, LinkingOutput,
3730 OA->doOnEachDependence(
3731 BuildingForOffloadDevice,
3734 C, DepA, DepTC, DepBoundArch,
false,
3735 !!DepBoundArch, LinkingOutput, CachedResults,
3739 A = BuildingForOffloadDevice
3740 ? OA->getSingleDeviceDependence(
true)
3741 : OA->getHostDependence();
3744 if (
const InputAction *IA = dyn_cast<InputAction>(A)) {
3747 const Arg &Input = IA->getInputArg();
3749 if (Input.getOption().matches(options::OPT_INPUT)) {
3750 const char *
Name = Input.getValue();
3760 if (!ArchName.empty())
3761 TC = &getToolChain(C.
getArgs(),
3768 MultipleArchs, LinkingOutput, CachedResults,
3769 TargetDeviceOffloadKind);
3775 const JobAction *JA = cast<JobAction>(A);
3780 const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions);
3787 for (
const auto *OA : CollapsedOffloadActions)
3788 cast<OffloadAction>(OA)->doOnEachDependence(
3789 BuildingForOffloadDevice,
3792 C, DepA, DepTC, DepBoundArch,
false,
3793 !!DepBoundArch, LinkingOutput, CachedResults,
3799 for (
const Action *Input : *Inputs) {
3803 bool SubJobAtTopLevel =
3804 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
3806 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
3811 const char *BaseInput = InputInfos[0].getBaseInput();
3815 if (JA->
getType() == types::TY_dSYM)
3816 BaseInput = InputInfos[0].getFilename();
3819 if (!OffloadDependencesInputInfo.empty())
3820 InputInfos.append(OffloadDependencesInputInfo.begin(),
3821 OffloadDependencesInputInfo.end());
3824 llvm::Triple EffectiveTriple;
3826 const ArgList &Args =
3828 if (InputInfos.size() != 1) {
3832 EffectiveTriple = llvm::Triple(
3840 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) {
3844 for (
auto &UI : UA->getDependentActionsInfo()) {
3846 "Unbundling with no offloading??");
3853 UI.DependentOffloadKind,
3854 UI.DependentToolChain->getTriple().normalize(),
3865 UnbundlingResults.push_back(CurI);
3874 Arch = UI.DependentBoundArch;
3879 UI.DependentOffloadKind)}] =
3885 std::pair<const Action *, std::string> ActionTC = {
3887 assert(CachedResults.find(ActionTC) != CachedResults.end() &&
3888 "Result does not exist??");
3889 Result = CachedResults[ActionTC];
3890 }
else if (JA->
getType() == types::TY_Nothing)
3900 AtTopLevel, MultipleArchs,
3907 <<
" - \"" << T->
getName() <<
"\", inputs: [";
3908 for (
unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
3909 llvm::errs() << InputInfos[i].getAsString();
3911 llvm::errs() <<
", ";
3913 if (UnbundlingResults.empty())
3914 llvm::errs() <<
"], output: " << Result.
getAsString() <<
"\n";
3916 llvm::errs() <<
"], outputs: [";
3917 for (
unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) {
3918 llvm::errs() << UnbundlingResults[i].getAsString();
3920 llvm::errs() <<
", ";
3922 llvm::errs() <<
"] \n";
3925 if (UnbundlingResults.empty())
3927 C, *JA, Result, InputInfos,
3932 C, *JA, UnbundlingResults, InputInfos,
3941 return Target.isOSWindows() ?
"a.exe" :
"a.out";
3953 if (ArgValue.empty()) {
3955 Filename = BaseName;
3956 }
else if (llvm::sys::path::is_separator(Filename.back())) {
3958 llvm::sys::path::append(Filename, BaseName);
3961 if (!llvm::sys::path::has_extension(ArgValue)) {
3965 if (FileType == types::TY_Image &&
3966 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
3971 llvm::sys::path::replace_extension(Filename, Extension);
3974 return Args.MakeArgString(Filename.c_str());
3978 const char *BaseInput,
3979 StringRef BoundArch,
bool AtTopLevel,
3981 StringRef OffloadingPrefix)
const {
3982 llvm::PrettyStackTraceString CrashInfo(
"Computing output path");
3984 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
3985 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
3990 if (C.
getArgs().hasArg(options::OPT__SLASH_P)) {
3991 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
3992 StringRef BaseName = llvm::sys::path::filename(BaseInput);
3994 if (Arg *A = C.
getArgs().getLastArg(options::OPT__SLASH_Fi))
3995 NameArg = A->getValue();
4006 if (JA.
getType() == types::TY_PP_Asm &&
4007 (C.
getArgs().hasArg(options::OPT__SLASH_FA) ||
4008 C.
getArgs().hasArg(options::OPT__SLASH_Fa))) {
4010 StringRef BaseName = llvm::sys::path::filename(BaseInput);
4011 StringRef FaValue = C.
getArgs().getLastArgValue(options::OPT__SLASH_Fa);
4019 !C.
getArgs().hasArg(options::OPT__SLASH_Fo)) ||
4021 StringRef
Name = llvm::sys::path::filename(BaseInput);
4022 std::pair<StringRef, StringRef> Split = Name.split(
'.');
4025 Arg *A = C.
getArgs().getLastArg(options::OPT_fcrash_diagnostics_dir);
4028 llvm::sys::path::append(CrashDirectory, Split.first);
4029 const char *Middle = Suffix ?
"-%%%%%%." :
"-%%%%%%";
4030 std::error_code EC =
4031 llvm::sys::fs::createUniqueFile(CrashDirectory + Middle + Suffix, TmpName);
4033 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
4046 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
4047 BaseName = BasePath;
4049 BaseName = llvm::sys::path::filename(BasePath);
4052 const char *NamedOutput;
4054 if ((JA.
getType() == types::TY_Object || JA.
getType() == types::TY_LTO_BC) &&
4055 C.
getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
4059 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
4063 }
else if (JA.
getType() == types::TY_Image &&
4064 C.
getArgs().hasArg(options::OPT__SLASH_Fe,
4065 options::OPT__SLASH_o)) {
4069 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
4073 }
else if (JA.
getType() == types::TY_Image) {
4080 Output += OffloadingPrefix;
4081 if (MultipleArchs && !BoundArch.empty()) {
4083 Output.append(BoundArch);
4085 NamedOutput = C.
getArgs().MakeArgString(Output.c_str());
4091 assert(Suffix &&
"All types used for output should have a suffix.");
4093 std::string::size_type
End = std::string::npos;
4095 End = BaseName.rfind(
'.');
4097 Suffixed += OffloadingPrefix;
4098 if (MultipleArchs && !BoundArch.empty()) {
4100 Suffixed.append(BoundArch);
4105 if (!AtTopLevel && C.
getArgs().hasArg(options::OPT_emit_llvm) &&
4106 JA.
getType() == types::TY_LLVM_BC)
4110 NamedOutput = C.
getArgs().MakeArgString(Suffixed.c_str());
4115 JA.
getType() != types::TY_PCH) {
4116 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
4118 llvm::sys::path::remove_filename(TempPath);
4119 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
4120 llvm::sys::path::append(TempPath, OutputFileName);
4121 NamedOutput = C.
getArgs().MakeArgString(TempPath.c_str());
4127 bool SameFile =
false;
4129 llvm::sys::fs::current_path(Result);
4130 llvm::sys::path::append(Result, BaseName);
4131 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
4134 StringRef
Name = llvm::sys::path::filename(BaseInput);
4135 std::pair<StringRef, StringRef> Split = Name.split(
'.');
4144 llvm::sys::path::remove_filename(BasePath);
4145 if (BasePath.empty())
4146 BasePath = NamedOutput;
4148 llvm::sys::path::append(BasePath, NamedOutput);
4162 llvm::sys::path::append(
P, Name);
4163 if (llvm::sys::fs::exists(Twine(
P)))
4168 llvm::sys::path::append(R, Name);
4169 if (llvm::sys::fs::exists(Twine(R)))
4173 llvm::sys::path::append(
P, Name);
4174 if (llvm::sys::fs::exists(Twine(
P)))
4181 llvm::sys::path::append(
P, Name);
4182 if (llvm::sys::fs::exists(Twine(
P)))
4189 void Driver::generatePrefixedToolNames(
4193 Names.emplace_back((TargetTriple +
"-" +
Tool).str());
4194 Names.emplace_back(
Tool);
4197 std::string DefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
4198 if (DefaultTargetTriple != TargetTriple)
4199 Names.emplace_back((DefaultTargetTriple +
"-" +
Tool).str());
4204 for (
const auto &
Name : Names) {
4205 llvm::sys::path::append(Dir,
Name);
4206 if (llvm::sys::fs::can_execute(Twine(Dir)))
4208 llvm::sys::path::remove_filename(Dir);
4215 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
4220 if (llvm::sys::fs::is_directory(PrefixDir)) {
4226 if (llvm::sys::fs::can_execute(Twine(P)))
4232 for (
const auto &Path : List) {
4239 for (
const auto &TargetSpecificExecutable : TargetSpecificExecutables)
4240 if (llvm::ErrorOr<std::string>
P =
4241 llvm::sys::findProgramByName(TargetSpecificExecutable))
4249 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
4251 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
4260 if (Arg *FpArg = C.
getArgs().getLastArg(options::OPT__SLASH_Fp)) {
4264 Output = FpArg->getValue();
4268 if (!llvm::sys::path::has_extension(Output))
4270 }
else if (Arg *YcArg = C.
getArgs().getLastArg(options::OPT__SLASH_Yc)) {
4271 Output = YcArg->getValue();
4272 llvm::sys::path::replace_extension(Output,
".pch");
4275 llvm::sys::path::replace_extension(Output,
".pch");
4277 return Output.str();
4280 const ToolChain &Driver::getToolChain(
const ArgList &Args,
4281 const llvm::Triple &
Target)
const {
4283 auto &TC = ToolChains[Target.str()];
4285 switch (Target.getOS()) {
4286 case llvm::Triple::Haiku:
4287 TC = llvm::make_unique<toolchains::Haiku>(*
this,
Target, Args);
4289 case llvm::Triple::Ananas:
4290 TC = llvm::make_unique<toolchains::Ananas>(*
this,
Target, Args);
4292 case llvm::Triple::CloudABI:
4293 TC = llvm::make_unique<toolchains::CloudABI>(*
this,
Target, Args);
4295 case llvm::Triple::Darwin:
4296 case llvm::Triple::MacOSX:
4297 case llvm::Triple::IOS:
4298 case llvm::Triple::TvOS:
4299 case llvm::Triple::WatchOS:
4300 TC = llvm::make_unique<toolchains::DarwinClang>(*
this,
Target, Args);
4302 case llvm::Triple::DragonFly:
4303 TC = llvm::make_unique<toolchains::DragonFly>(*
this,
Target, Args);
4305 case llvm::Triple::OpenBSD:
4306 TC = llvm::make_unique<toolchains::OpenBSD>(*
this,
Target, Args);
4308 case llvm::Triple::NetBSD:
4309 TC = llvm::make_unique<toolchains::NetBSD>(*
this,
Target, Args);
4311 case llvm::Triple::FreeBSD:
4312 TC = llvm::make_unique<toolchains::FreeBSD>(*
this,
Target, Args);
4314 case llvm::Triple::Minix:
4315 TC = llvm::make_unique<toolchains::Minix>(*
this,
Target, Args);
4317 case llvm::Triple::Linux:
4318 case llvm::Triple::ELFIAMCU:
4319 if (Target.getArch() == llvm::Triple::hexagon)
4320 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
4322 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
4323 !Target.hasEnvironment())
4324 TC = llvm::make_unique<toolchains::MipsLLVMToolChain>(*
this, Target,
4327 TC = llvm::make_unique<toolchains::Linux>(*
this,
Target, Args);
4329 case llvm::Triple::NaCl:
4330 TC = llvm::make_unique<toolchains::NaClToolChain>(*
this,
Target, Args);
4332 case llvm::Triple::Fuchsia:
4333 TC = llvm::make_unique<toolchains::Fuchsia>(*
this,
Target, Args);
4335 case llvm::Triple::Solaris:
4336 TC = llvm::make_unique<toolchains::Solaris>(*
this,
Target, Args);
4338 case llvm::Triple::AMDHSA:
4339 TC = llvm::make_unique<toolchains::AMDGPUToolChain>(*
this,
Target, Args);
4341 case llvm::Triple::Win32:
4342 switch (Target.getEnvironment()) {
4344 if (Target.isOSBinFormatELF())
4345 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
4346 else if (Target.isOSBinFormatMachO())
4347 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
4349 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this,
Target, Args);
4351 case llvm::Triple::GNU:
4352 TC = llvm::make_unique<toolchains::MinGW>(*
this,
Target, Args);
4354 case llvm::Triple::Itanium:
4355 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(*
this,
Target,
4358 case llvm::Triple::MSVC:
4359 case llvm::Triple::UnknownEnvironment:
4360 if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
4361 .startswith_lower(
"bfd"))
4362 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(
4363 *
this, Target, Args);
4366 llvm::make_unique<toolchains::MSVCToolChain>(*
this,
Target, Args);
4370 case llvm::Triple::PS4:
4371 TC = llvm::make_unique<toolchains::PS4CPU>(*
this,
Target, Args);
4373 case llvm::Triple::Contiki:
4374 TC = llvm::make_unique<toolchains::Contiki>(*
this,
Target, Args);
4379 switch (Target.getArch()) {
4380 case llvm::Triple::tce:
4381 TC = llvm::make_unique<toolchains::TCEToolChain>(*
this,
Target, Args);
4383 case llvm::Triple::tcele:
4384 TC = llvm::make_unique<toolchains::TCELEToolChain>(*
this,
Target, Args);
4386 case llvm::Triple::hexagon:
4387 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this,
Target,
4390 case llvm::Triple::lanai:
4391 TC = llvm::make_unique<toolchains::LanaiToolChain>(*
this,
Target, Args);
4393 case llvm::Triple::xcore:
4394 TC = llvm::make_unique<toolchains::XCoreToolChain>(*
this,
Target, Args);
4396 case llvm::Triple::wasm32:
4397 case llvm::Triple::wasm64:
4398 TC = llvm::make_unique<toolchains::WebAssembly>(*
this,
Target, Args);
4400 case llvm::Triple::avr:
4401 TC = llvm::make_unique<toolchains::AVRToolChain>(*
this,
Target, Args);
4403 case llvm::Triple::riscv32:
4404 case llvm::Triple::riscv64:
4405 TC = llvm::make_unique<toolchains::RISCVToolChain>(*
this,
Target, Args);
4408 if (Target.getVendor() == llvm::Triple::Myriad)
4409 TC = llvm::make_unique<toolchains::MyriadToolChain>(*
this, Target,
4412 TC = llvm::make_unique<toolchains::BareMetal>(*
this, Target, Args);
4413 else if (Target.isOSBinFormatELF())
4414 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
4415 else if (Target.isOSBinFormatMachO())
4416 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
4418 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this,
Target, Args);
4433 if (JA.
size() != 1 ||
4438 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
4439 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
4451 unsigned &Micro,
bool &HadExtra) {
4454 Major = Minor = Micro = 0;
4458 if (Str.consumeInteger(10, Major))
4465 Str = Str.drop_front(1);
4467 if (Str.consumeInteger(10, Minor))
4473 Str = Str.drop_front(1);
4475 if (Str.consumeInteger(10, Micro))
4493 unsigned CurDigit = 0;
4494 while (CurDigit < Digits.size()) {
4496 if (Str.consumeInteger(10, Digit))
4498 Digits[CurDigit] = Digit;
4503 Str = Str.drop_front(1);
4511 std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks()
const {
4512 unsigned IncludedFlagsBitmask = 0;
4515 if (Mode == CLMode) {
4523 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
4527 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group,
false);
StringRef getSysRoot() const
Returns the sysroot path.
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
static bool DiagnoseInputExistence(const Driver &D, const DerivedArgList &Args, StringRef Value, types::ID Ty)
Check that the file referenced by Value exists.
ID
ID - Ordered values for successive stages in the compilation process which interact with user options...
static bool ContainsCompileOrAssembleAction(const Action *A)
Check whether the given input tree contains any compilation or assembly actions.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
bool isCollapsingWithNextDependentActionLegal() const
Return true if this function can be collapsed with others.
const llvm::opt::ArgStringList & getTempFiles() const
std::string ModeSuffix
Driver mode part of the executable name, as g++.
const char * CudaArchToString(CudaArch A)
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
T * MakeAction(Args &&... Arg)
Creates a new Action owned by this Compilation.
bool canLipoType(ID Id)
canLipoType - Is this type acceptable as the output of a universal build (currently, just the Nothing, Image, and Object types).
Set a ToolChain's effective triple.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type, or null if unspecified.
unsigned CCCUsePCH
Use lazy precompiled headers for PCH support.
void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args, InputList &Inputs) const
BuildInputs - Construct the list of inputs and their types from the given arguments.
void setResponseFile(const char *FileName)
Set to pass arguments via a response file when launching the command.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
std::string DyldPrefix
Dynamic loader prefix, if present.
static StringRef getCategoryNameFromID(unsigned CategoryID)
Given a category ID, return the name of the category.
DiagnosticBuilder Diag(unsigned DiagID) const
InputInfo BuildJobsForAction(Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch, bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput, std::map< std::pair< const Action *, std::string >, InputInfo > &CachedResults, Action::OffloadKind TargetDeviceOffloadKind) const
BuildJobsForAction - Construct the jobs to perform for the action A and return an InputInfo for the r...
CudaArch StringToCudaArch(llvm::StringRef S)
Type used to communicate device actions.
const char * getClassName() const
RAII class that determines when any errors have occurred between the time the instance was created an...
void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch, OffloadKind Kind)
Register information about a dependent action.
const ArgStringMap & getFailureResultFiles() const
float __ovld __cnfn normalize(float p)
Returns a vector in the same direction as p but with a length of 1.
Driver(StringRef ClangExecutable, StringRef TargetTriple, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< vfs::FileSystem > VFS=nullptr)
const llvm::opt::DerivedArgList & getArgsForToolChain(const ToolChain *TC, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind)
getArgsForToolChain - Return the derived argument list for the tool chain TC (or the default tool cha...
void addOffloadDeviceToolChain(const ToolChain *DeviceToolChain, Action::OffloadKind OffloadKind)
Compilation * BuildCompilation(ArrayRef< const char *> Args)
BuildCompilation - Construct a compilation object for a command line argument vector.
std::string TargetPrefix
Target part of the executable name, as i686-linux-android.
Contains the files in the compilation diagnostic report generated by generateCompilationDiagnostics.
static bool ScanDirForExecutable(SmallString< 128 > &Dir, ArrayRef< std::string > Names)
std::string Dir
The path the driver executable was in, as invoked from the command line.
ID lookupCXXTypeForCType(ID Id)
lookupCXXTypeForCType - Lookup CXX input type that corresponds to given C type (used for clang++ emul...
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
Type used to communicate host actions.
static unsigned getNumberOfCategories()
Return the number of diagnostic categories.
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
Action - Represent an abstract compilation step to perform.
bool HandleImmediateArgs(const Compilation &C)
HandleImmediateArgs - Handle any arguments which should be treated before building actions or binding...
Concrete class used by the front-end to report problems and issues.
types::ID getType() const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
OffloadKind getOffloadingDeviceKind() const
std::unique_ptr< llvm::opt::OptTable > createDriverOptTable()
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
An unknown OpenMP runtime.
const llvm::opt::InputArgList & getInputArgs() const
input_iterator input_begin()
bool isHIP(ID Id)
isHIP - Is this a HIP input.
static Arg * MakeInputArg(DerivedArgList &Args, OptTable &Opts, StringRef Value, bool Claim=true)
bool hasOffloadToolChain() const
Return true if an offloading tool chain of a given kind exists.
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed, or INVALID if this input is not preprocessed.
void add(Action &A, const ToolChain &TC, const char *BoundArch, OffloadKind OKind)
Add a action along with the associated toolchain, bound arch, and offload kind.
void PrintActions(const Compilation &C) const
PrintActions - Print the list of actions.
const ToolChain & getDefaultToolChain() const
const ArgStringMap & getResultFiles() const
unsigned GenReproducer
Force clang to emit reproducer for driver invocation.
ID lookupHeaderTypeForSourceType(ID Id)
Lookup header file input type that corresponds to given source file type (used for clang-cl emulation...
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
ActionClass getKind() const
const char * getPhaseName(ID Id)
const Tool & getCreator() const
getCreator - Return the Tool which caused the creation of this job.
bool isSaveTempsObj() const
Defines version macros and version-related utility functions for Clang.
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
static std::string GetTriplePlusArchString(const ToolChain *TC, StringRef BoundArch, Action::OffloadKind OffloadKind)
Return a string that uniquely identifies the result of a job.
void HandleAutocompletions(StringRef PassedFlags) const
HandleAutocompletions - Handle –autocomplete by searching and printing possible flags, descriptions, and its arguments.
void getCompilationPhases(ID Id, llvm::SmallVectorImpl< phases::ID > &Phases)
getCompilationPhases - Get the list of compilation phases ('Phases') to be done for type 'Id'...
void BuildUniversalActions(Compilation &C, const ToolChain &TC, const InputList &BAInputs) const
BuildUniversalActions - Construct the list of actions to perform for the given arguments, which may require a universal build.
llvm::opt::InputArgList ParseArgStrings(ArrayRef< const char *> Args, bool &ContainsError)
ParseArgStrings - Parse the given list of strings into an ArgList.
void setCannotBeCollapsedWithNextDependentAction()
Mark this action as not legal to collapse.
Action * ConstructPhaseAction(Compilation &C, const llvm::opt::ArgList &Args, phases::ID Phase, Action *Input, Action::OffloadKind TargetDeviceOffloadKind=Action::OFK_None) const
ConstructAction - Construct the appropriate action to do for Phase on the Input, taking in to account...
const ActionList & getActions() const
Get each of the individual arrays.
const_offload_toolchains_range getOffloadToolChains() const
static void PrintDiagnosticCategories(raw_ostream &OS)
PrintDiagnosticCategories - Implement the –print-diagnostic-categories option.
void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const
void PrintHelp(bool ShowHidden) const
PrintHelp - Print the help text.
static void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote)
Print a command argument, and optionally quote it.
void generateCompilationDiagnostics(Compilation &C, const Command &FailingCommand, StringRef AdditionalInformation="", CompilationDiagnosticReport *GeneratedReport=nullptr)
generateCompilationDiagnostics - Generate diagnostics information including preprocessed source file(...
static unsigned PrintActions1(const Compilation &C, Action *A, std::map< Action *, unsigned > &Ids)
bool embedBitcodeInObject() const
Encodes a location in the source.
const llvm::opt::DerivedArgList & getArgs() const
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Command - An executable path/name and argument vector to execute.
bool isCuda(ID Id)
isCuda - Is this a CUDA input.
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
std::string InstalledDir
The path to the installed clang directory, if any.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
const char * addResultFile(const char *Name, const JobAction *JA)
addResultFile - Add a file to remove on failure, and returns its argument.
bool isSaveTempsEnabled() const
static std::vector< std::string > getDiagnosticFlags()
Get the string of all diagnostic flags.
std::string UserConfigDir
User directory for config files.
bool isAcceptedByClang(ID Id)
isAcceptedByClang - Can clang handle this input type.
An offload action combines host or/and device actions according to the programming model implementati...
const char * getDefaultImageName() const
Returns the default name for linked images (e.g., "a.out").
void ExecuteJobs(const JobList &Jobs, SmallVectorImpl< std::pair< int, const Command *>> &FailingCommands) const
ExecuteJob - Execute a single job.
void setIgnoreAllWarnings(bool Val)
When set to true, any unmapped warnings are ignored.
static bool searchForFile(SmallVectorImpl< char > &FilePath, ArrayRef< std::string > Dirs, StringRef FileName)
Looks the given directories for the specified file.
unsigned getOffloadingHostActiveKinds() const
void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)
const Action & getSource() const
getSource - Return the Action which caused the creation of this job.
Dataflow Directional Tag Classes.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
const char * getExecutable() const
unsigned CCCPrintBindings
Only print tool bindings, don't build any jobs.
static llvm::Triple computeTargetTriple(const Driver &D, StringRef TargetTriple, const ArgList &Args, StringRef DarwinArchName="")
Compute target triple from args.
const llvm::opt::ArgStringList & getArguments() const
std::string SysRoot
sysroot, if present
std::string Name
The name the driver was invoked as.
Defines the virtual file system interface vfs::FileSystem.
llvm::SmallVector< std::string, 4 > TemporaryFiles
int ExecuteCompilation(Compilation &C, SmallVectorImpl< std::pair< int, const Command *> > &FailingCommands)
ExecuteCompilation - Execute the compilation according to the command line arguments and return an ap...
ActionList & getActions()
ParsedClangName ClangNameParts
Target and driver mode components extracted from clang executable name.
bool getCheckInputsExist() const
std::string ClangExecutable
The original path to the clang executable.
void BuildJobs(Compilation &C) const
BuildJobs - Bind actions to concrete tools and translate arguments to form the list of jobs to run...
ID getPrecompiledType(ID Id)
getPrecompiledType - Get the ID of the type for this input when it has been precompiled, or INVALID if this input is not precompiled.
bool ShouldUseClangCompiler(const JobAction &JA) const
ShouldUseClangCompiler - Should the clang compiler be used to handle this action. ...
Compilation - A set of tasks to perform for a single driver invocation.
void BuildActions(Compilation &C, llvm::opt::DerivedArgList &Args, const InputList &Inputs, ActionList &Actions) const
BuildActions - Construct the list of actions to perform for the given arguments, which are only done ...
const Driver & getDriver() const
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
std::string GetFilePath(StringRef Name, const ToolChain &TC) const
GetFilePath - Lookup Name in the list of file search paths.
static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args)
bool CleanupFileMap(const ArgStringMap &Files, const JobAction *JA, bool IssueErrors=false) const
CleanupFileMap - Remove the files in the given map.
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
void propagateHostOffloadInfo(unsigned OKinds, const char *OArch)
Append the host offload info of this action and propagate it to its dependences.
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
void ParseDriverMode(StringRef ProgramName, ArrayRef< const char *> Args)
ParseDriverMode - Look for and handle the driver mode option in Args.
const llvm::opt::OptTable & getOpts() const
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
std::string getOffloadingKindPrefix() const
Return a string containing the offload kind of the action.
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
__DEVICE__ int max(int __a, int __b)
std::string DriverTitle
Driver title to use with help.
static const char * MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, StringRef BaseName, types::ID FileType)
Create output filename based on ArgValue, which could either be a full filename, filename without ext...
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
void PrintVersion(const Compilation &C, raw_ostream &OS) const
PrintVersion - Print the driver version.
void CreateOffloadingDeviceToolChains(Compilation &C, InputList &Inputs)
CreateOffloadingDeviceToolChains - create all the toolchains required to support offloading devices g...
bool appendSuffixForType(ID Id)
appendSuffixForType - When generating outputs of this type, should the suffix be appended (instead of...
ID lookupTypeForTypeSpecifier(const char *Name)
lookupTypeForTypSpecifier - Lookup the type to use for a user specified type name.
const char * GetNamedOutputPath(Compilation &C, const JobAction &JA, const char *BaseInput, StringRef BoundArch, bool AtTopLevel, bool MultipleArchs, StringRef NormalizedTriple) const
GetNamedOutputPath - Return the name to use for the output of the action JA.
void initCompilationForDiagnostics()
initCompilationForDiagnostics - Remove stale state and suppress output so compilation can be reexecut...
bool isSrcFile(ID Id)
isSrcFile - Is this a source file, i.e.
const char * DriverMode
Corresponding driver mode argument, as '–driver-mode=g++'.
const char * getOffloadingArch() const
virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
std::string SystemConfigDir
System directory for config files.
std::string ResourceDir
The path to the compiler resource directory.