48 #include "clang/Config/config.h" 57 #include "llvm/ADT/ArrayRef.h" 58 #include "llvm/ADT/STLExtras.h" 59 #include "llvm/ADT/SmallSet.h" 60 #include "llvm/ADT/StringExtras.h" 61 #include "llvm/ADT/StringSet.h" 62 #include "llvm/ADT/StringSwitch.h" 63 #include "llvm/Config/llvm-config.h" 64 #include "llvm/Option/Arg.h" 65 #include "llvm/Option/ArgList.h" 66 #include "llvm/Option/OptSpecifier.h" 67 #include "llvm/Option/OptTable.h" 68 #include "llvm/Option/Option.h" 69 #include "llvm/Support/CommandLine.h" 70 #include "llvm/Support/ErrorHandling.h" 71 #include "llvm/Support/FileSystem.h" 72 #include "llvm/Support/FormatVariadic.h" 73 #include "llvm/Support/Path.h" 74 #include "llvm/Support/PrettyStackTrace.h" 75 #include "llvm/Support/Process.h" 76 #include "llvm/Support/Program.h" 77 #include "llvm/Support/StringSaver.h" 78 #include "llvm/Support/TargetRegistry.h" 79 #include "llvm/Support/VirtualFileSystem.h" 80 #include "llvm/Support/raw_ostream.h" 90 using namespace clang;
97 Mode(GCCMode), SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
98 LTOMode(
LTOK_None), ClangExecutable(ClangExecutable),
99 SysRoot(DEFAULT_SYSROOT), DriverTitle(
"clang LLVM compiler"),
100 CCPrintOptionsFilename(nullptr), CCPrintHeadersFilename(nullptr),
101 CCLogDiagnosticsFilename(nullptr), CCCPrintBindings(
false),
103 CCGenDiagnostics(
false), TargetTriple(TargetTriple),
104 CCCGenericGCCName(
""), Saver(Alloc), CheckInputsExist(
true),
105 GenReproducer(
false), SuppressMissingInputWarning(
false) {
109 this->VFS = llvm::vfs::getRealFileSystem();
111 Name = llvm::sys::path::filename(ClangExecutable);
112 Dir = llvm::sys::path::parent_path(ClangExecutable);
115 #if defined(CLANG_CONFIG_FILE_SYSTEM_DIR) 118 #if defined(CLANG_CONFIG_FILE_USER_DIR) 123 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
125 if (ClangResourceDir !=
"") {
126 llvm::sys::path::append(P, ClangResourceDir);
128 StringRef ClangLibdirSuffix(CLANG_LIBDIR_SUFFIX);
129 P = llvm::sys::path::parent_path(
Dir);
130 llvm::sys::path::append(P, Twine(
"lib") + ClangLibdirSuffix,
"clang",
131 CLANG_VERSION_STRING);
142 for (
const char *ArgPtr : Args) {
144 if (ArgPtr ==
nullptr)
146 const StringRef Arg = ArgPtr;
147 setDriverModeFromOption(Arg);
151 void Driver::setDriverModeFromOption(StringRef Opt) {
152 const std::string OptName =
153 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
154 if (!Opt.startswith(OptName))
156 StringRef
Value = Opt.drop_front(OptName.size());
159 .Case(
"gcc", GCCMode)
160 .Case(
"g++", GXXMode)
161 .Case(
"cpp", CPPMode)
166 Diag(diag::err_drv_unsupported_option_argument) << OptName <<
Value;
171 bool &ContainsError) {
172 llvm::PrettyStackTraceString CrashInfo(
"Command line argument parsing");
173 ContainsError =
false;
175 unsigned IncludedFlagsBitmask;
176 unsigned ExcludedFlagsBitmask;
177 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
178 getIncludeExcludeOptionFlagMasks(IsClCompatMode);
180 unsigned MissingArgIndex, MissingArgCount;
182 getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount,
183 IncludedFlagsBitmask, ExcludedFlagsBitmask);
186 if (MissingArgCount) {
187 Diag(diag::err_drv_missing_argument)
188 << Args.getArgString(MissingArgIndex) << MissingArgCount;
195 for (
const Arg *A : Args) {
198 auto ArgString = A->getAsString(Args);
201 ArgString, Nearest, IncludedFlagsBitmask,
203 DiagID = diag::err_drv_unsupported_opt;
204 Diag(DiagID) << ArgString;
206 DiagID = diag::err_drv_unsupported_opt_with_suggestion;
207 Diag(DiagID) << ArgString << Nearest;
215 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue(
"")) {
216 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
218 diag::warn_drv_empty_joined_argument,
223 for (
const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {
225 auto ArgString = A->getAsString(Args);
228 ArgString, Nearest, IncludedFlagsBitmask, ExcludedFlagsBitmask) > 1) {
229 DiagID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl
230 : diag::err_drv_unknown_argument;
231 Diags.
Report(DiagID) << ArgString;
233 DiagID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl_with_suggestion
234 : diag::err_drv_unknown_argument_with_suggestion;
235 Diags.
Report(DiagID) << ArgString << Nearest;
247 phases::ID Driver::getFinalPhase(
const DerivedArgList &DAL,
248 Arg **FinalPhaseArg)
const {
249 Arg *PhaseArg =
nullptr;
253 if (
CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
254 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
255 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
256 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
260 }
else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
264 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
265 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
266 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
267 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
268 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
269 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
270 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
271 options::OPT__analyze_auto)) ||
272 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
276 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
280 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
288 *FinalPhaseArg = PhaseArg;
294 StringRef
Value,
bool Claim =
true) {
295 Arg *A =
new Arg(Opts.getOption(options::OPT_INPUT),
Value,
296 Args.getBaseArgs().MakeIndex(Value), Value.data());
297 Args.AddSynthesizedArg(A);
303 DerivedArgList *Driver::TranslateInputArgs(
const InputArgList &Args)
const {
304 DerivedArgList *DAL =
new DerivedArgList(Args);
306 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
307 bool HasNostdlibxx = Args.hasArg(options::OPT_nostdlibxx);
308 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
309 for (Arg *A : Args) {
316 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
317 A->getOption().matches(options::OPT_Xlinker)) &&
318 A->containsValue(
"--no-demangle")) {
320 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
323 for (StringRef Val : A->getValues())
324 if (Val !=
"--no-demangle")
325 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val);
333 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
334 (A->getValue(0) == StringRef(
"-MD") ||
335 A->getValue(0) == StringRef(
"-MMD"))) {
337 if (A->getValue(0) == StringRef(
"-MD"))
338 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
340 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
341 if (A->getNumValues() == 2)
342 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
348 if (A->getOption().matches(options::OPT_l)) {
349 StringRef
Value = A->getValue();
352 if (!HasNostdlib && !HasNodefaultlib && !HasNostdlibxx &&
354 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx));
359 if (Value ==
"cc_kext") {
360 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext));
366 if (A->getOption().matches(options::OPT__DASH_DASH)) {
368 for (StringRef Val : A->getValues())
377 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false))
378 DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
382 #if defined(HOST_LINK_VERSION) 383 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
384 strlen(HOST_LINK_VERSION) > 0) {
385 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
387 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
399 StringRef TargetTriple,
401 StringRef DarwinArchName =
"") {
403 if (
const Arg *A = Args.getLastArg(options::OPT_target))
404 TargetTriple = A->getValue();
411 if (TargetTriple.find(
"-unknown-gnu") != StringRef::npos ||
412 TargetTriple.find(
"-pc-gnu") != StringRef::npos)
413 Target.setOSName(
"hurd");
416 if (Target.isOSBinFormatMachO()) {
418 if (!DarwinArchName.empty()) {
424 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
425 StringRef ArchName = A->getValue();
432 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
433 options::OPT_mbig_endian)) {
434 if (A->getOption().matches(options::OPT_mlittle_endian)) {
435 llvm::Triple LE = Target.getLittleEndianArchVariant();
436 if (LE.getArch() != llvm::Triple::UnknownArch)
437 Target = std::move(LE);
439 llvm::Triple BE = Target.getBigEndianArchVariant();
440 if (BE.getArch() != llvm::Triple::UnknownArch)
441 Target = std::move(BE);
446 if (Target.getArch() == llvm::Triple::tce ||
447 Target.getOS() == llvm::Triple::Minix)
451 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
452 options::OPT_m32, options::OPT_m16);
454 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
456 if (A->getOption().matches(options::OPT_m64)) {
457 AT = Target.get64BitArchVariant().getArch();
458 if (Target.getEnvironment() == llvm::Triple::GNUX32)
459 Target.setEnvironment(llvm::Triple::GNU);
460 }
else if (A->getOption().matches(options::OPT_mx32) &&
461 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
462 AT = llvm::Triple::x86_64;
463 Target.setEnvironment(llvm::Triple::GNUX32);
464 }
else if (A->getOption().matches(options::OPT_m32)) {
465 AT = Target.get32BitArchVariant().getArch();
466 if (Target.getEnvironment() == llvm::Triple::GNUX32)
467 Target.setEnvironment(llvm::Triple::GNU);
468 }
else if (A->getOption().matches(options::OPT_m16) &&
469 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
470 AT = llvm::Triple::x86;
471 Target.setEnvironment(llvm::Triple::CODE16);
474 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
479 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
480 if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
481 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-miamcu" 484 if (A && !A->getOption().matches(options::OPT_m32))
485 D.
Diag(diag::err_drv_argument_not_allowed_with)
486 <<
"-miamcu" << A->getBaseArg().getAsString(Args);
488 Target.setArch(llvm::Triple::x86);
489 Target.setArchName(
"i586");
490 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
491 Target.setEnvironmentName(
"");
492 Target.setOS(llvm::Triple::ELFIAMCU);
493 Target.setVendor(llvm::Triple::UnknownVendor);
494 Target.setVendorName(
"intel");
499 A = Args.getLastArg(options::OPT_mabi_EQ);
500 if (A && Target.isMIPS()) {
501 StringRef ABIName = A->getValue();
502 if (ABIName ==
"32") {
503 Target = Target.get32BitArchVariant();
504 if (Target.getEnvironment() == llvm::Triple::GNUABI64 ||
505 Target.getEnvironment() == llvm::Triple::GNUABIN32)
506 Target.setEnvironment(llvm::Triple::GNU);
507 }
else if (ABIName ==
"n32") {
508 Target = Target.get64BitArchVariant();
509 if (Target.getEnvironment() == llvm::Triple::GNU ||
510 Target.getEnvironment() == llvm::Triple::GNUABI64)
511 Target.setEnvironment(llvm::Triple::GNUABIN32);
512 }
else if (ABIName ==
"64") {
513 Target = Target.get64BitArchVariant();
514 if (Target.getEnvironment() == llvm::Triple::GNU ||
515 Target.getEnvironment() == llvm::Triple::GNUABIN32)
516 Target.setEnvironment(llvm::Triple::GNUABI64);
525 void Driver::setLTOMode(
const llvm::opt::ArgList &Args) {
527 if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ,
528 options::OPT_fno_lto,
false))
531 StringRef LTOName(
"full");
533 const Arg *A = Args.getLastArg(options::OPT_flto_EQ);
535 LTOName = A->getValue();
537 LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
544 Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
551 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
553 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
555 RuntimeName = A->getValue();
557 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
565 Diag(diag::err_drv_unsupported_option_argument)
566 << A->getOption().getName() << A->getValue();
569 Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
584 llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
589 [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
593 if (IsCuda && IsHIP) {
594 Diag(clang::diag::err_drv_mix_cuda_hip);
599 const llvm::Triple &HostTriple = HostTC->
getTriple();
600 StringRef DeviceTripleStr;
603 HostTriple.isArch64Bit() ?
"nvptx64-nvidia-cuda" :
"nvptx-nvidia-cuda";
604 llvm::Triple CudaTriple(DeviceTripleStr);
607 auto &CudaTC = ToolChains[CudaTriple.str() +
"/" + HostTriple.str()];
609 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
615 const llvm::Triple &HostTriple = HostTC->
getTriple();
616 StringRef DeviceTripleStr;
618 DeviceTripleStr =
"amdgcn-amd-amdhsa";
619 llvm::Triple HIPTriple(DeviceTripleStr);
622 auto &HIPTC = ToolChains[HIPTriple.str() +
"/" + HostTriple.str()];
624 HIPTC = llvm::make_unique<toolchains::HIPToolChain>(
635 if (Arg *OpenMPTargets =
636 C.
getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
637 if (OpenMPTargets->getNumValues()) {
642 options::OPT_fopenmp, options::OPT_fopenmp_EQ,
643 options::OPT_fno_openmp,
false);
644 if (HasValidOpenMPRuntime) {
646 HasValidOpenMPRuntime =
650 if (HasValidOpenMPRuntime) {
651 llvm::StringMap<const char *> FoundNormalizedTriples;
652 for (
const char *Val : OpenMPTargets->getValues()) {
653 llvm::Triple TT(Val);
654 std::string NormalizedName = TT.normalize();
657 auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
658 if (Duplicate != FoundNormalizedTriples.end()) {
659 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
660 << Val << Duplicate->second;
666 FoundNormalizedTriples[NormalizedName] = Val;
669 if (TT.getArch() == llvm::Triple::UnknownArch)
670 Diag(clang::diag::err_drv_invalid_omp_target) << Val;
678 assert(HostTC &&
"Host toolchain should be always defined.");
680 ToolChains[TT.str() +
"/" + HostTC->
getTriple().normalize()];
682 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
691 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
693 Diag(clang::diag::warn_drv_empty_joined_argument)
714 StringRef FileName) {
716 for (
const StringRef &
Dir : Dirs) {
720 llvm::sys::path::append(WPath,
Dir, FileName);
721 llvm::sys::path::native(WPath);
722 if (llvm::sys::fs::is_regular_file(WPath)) {
723 FilePath = std::move(WPath);
730 bool Driver::readConfigFile(StringRef FileName) {
733 if (!llvm::cl::readConfigFile(FileName, Saver, NewCfgArgs)) {
734 Diag(diag::err_drv_cannot_read_config_file) << FileName;
740 llvm::sys::path::native(CfgFileName);
741 ConfigFile = CfgFileName.str();
743 CfgOptions = llvm::make_unique<InputArgList>(
750 if (CfgOptions->hasArg(options::OPT_config)) {
752 Diag(diag::err_drv_nested_config_file);
758 for (Arg *A : *CfgOptions)
763 bool Driver::loadConfigFile() {
764 std::string CfgFileName;
765 bool FileSpecifiedExplicitly =
false;
769 if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
772 CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
773 if (!CfgDir.empty()) {
774 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
780 if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
783 CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ));
784 if (!CfgDir.empty()) {
785 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
795 std::vector<std::string> ConfigFiles =
796 CLOptions->getAllArgValues(options::OPT_config);
797 if (ConfigFiles.size() > 1) {
798 Diag(diag::err_drv_duplicate_config);
802 if (!ConfigFiles.empty()) {
803 CfgFileName = ConfigFiles.front();
804 assert(!CfgFileName.empty());
808 if (llvm::sys::path::has_parent_path(CfgFileName)) {
810 if (llvm::sys::path::is_relative(CfgFileName))
811 llvm::sys::fs::current_path(CfgFilePath);
812 llvm::sys::path::append(CfgFilePath, CfgFileName);
813 if (!llvm::sys::fs::is_regular_file(CfgFilePath)) {
814 Diag(diag::err_drv_config_file_not_exist) << CfgFilePath;
817 return readConfigFile(CfgFilePath);
820 FileSpecifiedExplicitly =
true;
830 if (CfgFileName.empty())
834 StringRef CfgFileArch = CfgFileName;
835 size_t ArchPrefixLen = CfgFileArch.find(
'-');
836 if (ArchPrefixLen == StringRef::npos)
837 ArchPrefixLen = CfgFileArch.size();
838 llvm::Triple CfgTriple;
839 CfgFileArch = CfgFileArch.take_front(ArchPrefixLen);
841 if (CfgTriple.getArch() == llvm::Triple::ArchType::UnknownArch)
844 if (!StringRef(CfgFileName).endswith(
".cfg"))
845 CfgFileName +=
".cfg";
851 size_t FixedArchPrefixLen = 0;
857 CfgTriple.getTriple(), *CLOptions);
858 if (CfgTriple.getArch() != EffectiveTriple.getArch()) {
859 FixedConfigFile = EffectiveTriple.getArchName();
860 FixedArchPrefixLen = FixedConfigFile.size();
863 if (ArchPrefixLen < CfgFileName.size())
864 FixedConfigFile += CfgFileName.substr(ArchPrefixLen);
872 CfgFileSearchDirs.push_back(
Dir);
876 if (!FixedConfigFile.empty()) {
877 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
878 return readConfigFile(CfgFilePath);
880 FixedConfigFile.resize(FixedArchPrefixLen);
881 FixedConfigFile.append(
".cfg");
882 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
883 return readConfigFile(CfgFilePath);
887 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
888 return readConfigFile(CfgFilePath);
894 CfgFileName.append(
".cfg");
895 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
896 return readConfigFile(CfgFilePath);
901 if (FileSpecifiedExplicitly) {
902 Diag(diag::err_drv_config_file_not_found) << CfgFileName;
903 for (
const std::string &SearchDir : CfgFileSearchDirs)
904 if (!SearchDir.empty())
905 Diag(diag::note_drv_config_file_searched_in) << SearchDir;
913 llvm::PrettyStackTraceString CrashInfo(
"Compilation construction");
919 llvm::sys::Process::GetEnv(
"COMPILER_PATH")) {
920 StringRef CompilerPath = *CompilerPathValue;
921 while (!CompilerPath.empty()) {
922 std::pair<StringRef, StringRef>
Split =
923 CompilerPath.split(llvm::sys::EnvPathSeparator);
925 CompilerPath = Split.second;
937 CLOptions = llvm::make_unique<InputArgList>(
942 ContainsError = loadConfigFile();
943 bool HasConfigFile = !ContainsError && (CfgOptions.get() !=
nullptr);
946 InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
947 : std::move(*CLOptions));
949 auto appendOneArg = [&Args](
const Arg *Opt,
const Arg *BaseArg) {
950 unsigned Index = Args.MakeIndex(Opt->getSpelling());
951 Arg *Copy =
new llvm::opt::Arg(Opt->getOption(), Opt->getSpelling(),
953 Copy->getValues() = Opt->getValues();
954 if (Opt->isClaimed())
960 for (
auto *Opt : *CLOptions) {
961 if (Opt->getOption().matches(options::OPT_config))
963 const Arg *BaseArg = &Opt->getBaseArg();
966 appendOneArg(Opt, BaseArg);
972 for (
const auto *A : Args.filtered(options::OPT__SLASH_clang)) {
974 CLModePassThroughArgList.push_back(A->getValue());
977 if (!CLModePassThroughArgList.empty()) {
980 auto CLModePassThroughOptions = llvm::make_unique<InputArgList>(
984 for (
auto *Opt : *CLModePassThroughOptions) {
985 appendOneArg(Opt,
nullptr);
997 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
1000 Args.ClaimAllArgs(options::OPT_pipe);
1008 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
1010 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
1011 CCCGenericGCCName = A->getValue();
1013 options::OPT_fno_crash_diagnostics,
1014 !!::getenv(
"FORCE_CLANG_DIAGNOSTICS_CRASH"));
1019 llvm::Triple T(TargetTriple);
1020 T.setOS(llvm::Triple::Win32);
1021 T.setVendor(llvm::Triple::PC);
1022 T.setEnvironment(llvm::Triple::MSVC);
1023 T.setObjectFormat(llvm::Triple::COFF);
1024 TargetTriple = T.str();
1026 if (
const Arg *A = Args.getLastArg(options::OPT_target))
1027 TargetTriple = A->getValue();
1028 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
1030 for (
const Arg *A : Args.filtered(options::OPT_B)) {
1034 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1036 if (
const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
1039 if (
const Arg *A = Args.getLastArg(options::OPT_resource_dir))
1042 if (
const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
1043 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
1044 .Case(
"cwd", SaveTempsCwd)
1045 .Case(
"obj", SaveTempsObj)
1046 .Default(SaveTempsCwd);
1052 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
1053 StringRef
Name = A->getValue();
1054 unsigned Model = llvm::StringSwitch<unsigned>(
Name)
1055 .Case(
"off", EmbedNone)
1056 .Case(
"all", EmbedBitcode)
1057 .Case(
"bitcode", EmbedBitcode)
1058 .Case(
"marker", EmbedMarker)
1061 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1064 BitcodeEmbed =
static_cast<BitcodeEmbedMode
>(Model);
1067 std::unique_ptr<llvm::opt::InputArgList> UArgs =
1068 llvm::make_unique<InputArgList>(std::move(Args));
1071 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
1093 if (TC.
getTriple().isOSBinFormatMachO())
1098 if (CCCPrintPhases) {
1108 static void printArgList(raw_ostream &OS,
const llvm::opt::ArgList &Args) {
1109 llvm::opt::ArgStringList ASL;
1110 for (
const auto *A : Args)
1111 A->render(Args, ASL);
1113 for (
auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
1114 if (I != ASL.begin())
1121 bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename,
1124 assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&
1125 "Only knows about .crash files on Darwin");
1130 path::home_directory(CrashDiagDir);
1131 if (CrashDiagDir.startswith(
"/var/root"))
1133 path::append(CrashDiagDir,
"Library/Logs/DiagnosticReports");
1141 fs::file_status FileStatus;
1142 TimePoint<> LastAccessTime;
1146 for (fs::directory_iterator File(CrashDiagDir, EC), FileEnd;
1147 File != FileEnd && !EC; File.increment(EC)) {
1148 StringRef FileName = path::filename(File->path());
1149 if (!FileName.startswith(
Name))
1151 if (fs::status(File->path(), FileStatus))
1153 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
1154 llvm::MemoryBuffer::getFile(File->path());
1159 StringRef Data = CrashFile.get()->getBuffer();
1160 if (!Data.startswith(
"Process:"))
1163 size_t ParentProcPos = Data.find(
"Parent Process:");
1164 if (ParentProcPos == StringRef::npos)
1166 size_t LineEnd = Data.find_first_of(
"\n", ParentProcPos);
1167 if (LineEnd == StringRef::npos)
1169 StringRef ParentProcess = Data.slice(ParentProcPos+15, LineEnd).trim();
1170 int OpenBracket = -1, CloseBracket = -1;
1171 for (
size_t i = 0, e = ParentProcess.size(); i < e; ++i) {
1172 if (ParentProcess[i] ==
'[')
1174 if (ParentProcess[i] ==
']')
1180 if (OpenBracket < 0 || CloseBracket < 0 ||
1181 ParentProcess.slice(OpenBracket + 1, CloseBracket)
1182 .getAsInteger(10, CrashPID) || CrashPID != PID) {
1192 const auto FileAccessTime = FileStatus.getLastModificationTime();
1193 if (FileAccessTime > LastAccessTime) {
1194 CrashFilePath.assign(File->path());
1195 LastAccessTime = FileAccessTime;
1200 if (!CrashFilePath.empty()) {
1201 EC = fs::copy_file(CrashFilePath, ReproCrashFilename);
1216 if (C.
getArgs().hasArg(options::OPT_fno_crash_diagnostics))
1227 Diag(clang::diag::note_drv_command_failed_diag_msg)
1228 <<
"PLEASE submit a bug report to " BUG_REPORT_URL
" and include the " 1229 "crash backtrace, preprocessed source, and associated run script.";
1249 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
1250 bool IgnoreInput =
false;
1256 }
else if (!strcmp(it->second->getValue(),
"-")) {
1257 Diag(clang::diag::note_drv_command_failed_diag_msg)
1258 <<
"Error generating preprocessed source(s) - " 1259 "ignoring input from stdin.";
1264 it = Inputs.erase(it);
1271 if (Inputs.empty()) {
1272 Diag(clang::diag::note_drv_command_failed_diag_msg)
1273 <<
"Error generating preprocessed source(s) - " 1274 "no preprocessable inputs.";
1280 llvm::StringSet<> ArchNames;
1281 for (
const Arg *A : C.
getArgs()) {
1282 if (A->getOption().matches(options::OPT_arch)) {
1283 StringRef ArchName = A->getValue();
1284 ArchNames.insert(ArchName);
1287 if (ArchNames.size() > 1) {
1288 Diag(clang::diag::note_drv_command_failed_diag_msg)
1289 <<
"Error generating preprocessed source(s) - cannot generate " 1290 "preprocessed source with multiple -arch options.";
1297 if (TC.
getTriple().isOSBinFormatMachO())
1306 Diag(clang::diag::note_drv_command_failed_diag_msg)
1307 <<
"Error generating preprocessed source(s).";
1316 if (!FailingCommands.empty()) {
1317 Diag(clang::diag::note_drv_command_failed_diag_msg)
1318 <<
"Error generating preprocessed source(s).";
1323 if (TempFiles.empty()) {
1324 Diag(clang::diag::note_drv_command_failed_diag_msg)
1325 <<
"Error generating preprocessed source(s).";
1329 Diag(clang::diag::note_drv_command_failed_diag_msg)
1330 <<
"\n********************\n\n" 1331 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" 1332 "Preprocessed source(s) and associated run script(s) are located at:";
1336 for (
const char *TempFile : TempFiles) {
1337 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
1340 if (ReproCrashFilename.empty()) {
1341 ReproCrashFilename = TempFile;
1342 llvm::sys::path::replace_extension(ReproCrashFilename,
".crash");
1344 if (StringRef(TempFile).endswith(
".cache")) {
1347 VFS = llvm::sys::path::filename(TempFile);
1348 llvm::sys::path::append(VFS,
"vfs",
"vfs.yaml");
1356 llvm::sys::path::replace_extension(Script,
"sh");
1358 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::CD_CreateNew);
1360 Diag(clang::diag::note_drv_command_failed_diag_msg)
1361 <<
"Error generating run script: " << Script <<
" " << EC.message();
1364 <<
"# Driver args: ";
1366 ScriptOS <<
"# Original command: ";
1367 Cmd.
Print(ScriptOS,
"\n",
true);
1368 Cmd.
Print(ScriptOS,
"\n",
true, &CrashInfo);
1369 if (!AdditionalInformation.empty())
1370 ScriptOS <<
"\n# Additional information: " << AdditionalInformation
1374 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
1378 if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) {
1380 if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) {
1381 Diag(clang::diag::note_drv_command_failed_diag_msg)
1382 << ReproCrashFilename.str();
1384 llvm::sys::path::append(CrashDiagDir,
Name);
1385 CrashDiagDir +=
"_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
1386 Diag(clang::diag::note_drv_command_failed_diag_msg)
1387 <<
"Crash backtrace is located in";
1388 Diag(clang::diag::note_drv_command_failed_diag_msg)
1389 << CrashDiagDir.str();
1390 Diag(clang::diag::note_drv_command_failed_diag_msg)
1391 <<
"(choose the .crash file that corresponds to your crash)";
1395 for (
const auto &A : C.
getArgs().filtered(options::OPT_frewrite_map_file,
1396 options::OPT_frewrite_map_file_EQ))
1397 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
1399 Diag(clang::diag::note_drv_command_failed_diag_msg)
1400 <<
"\n\n********************";
1419 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1425 if (Diags.hasErrorOccurred())
1430 setUpResponseFiles(C, Job);
1435 if (FailingCommands.empty())
1441 for (
const auto &CmdPair : FailingCommands) {
1442 int CommandRes = CmdPair.first;
1443 const Command *FailingCommand = CmdPair.second;
1458 if (CommandRes == EX_IOERR) {
1476 Diag(clang::diag::err_drv_command_signalled)
1479 Diag(clang::diag::err_drv_command_failed)
1487 unsigned IncludedFlagsBitmask;
1488 unsigned ExcludedFlagsBitmask;
1489 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
1490 getIncludeExcludeOptionFlagMasks(
IsCLMode());
1494 ExcludedFlagsBitmask |= HelpHidden;
1496 std::string Usage = llvm::formatv(
"{0} [options] file...",
Name).str();
1498 IncludedFlagsBitmask, ExcludedFlagsBitmask,
1510 if (Arg *A = C.
getArgs().getLastArg(options::OPT_mthread_model)) {
1513 OS <<
"Thread model: " << A->getValue();
1522 if (!ConfigFile.empty())
1523 OS <<
"Configuration file: " << ConfigFile <<
'\n';
1536 if (PassedFlags ==
"")
1540 std::vector<std::string> SuggestedCompletions;
1541 std::vector<std::string> Flags;
1543 unsigned short DisableFlags =
1549 const bool HasSpace = PassedFlags.endswith(
",");
1553 StringRef TargetFlags = PassedFlags;
1554 while (TargetFlags !=
"") {
1556 std::tie(CurFlag, TargetFlags) = TargetFlags.split(
",");
1557 Flags.push_back(std::string(CurFlag));
1562 if (std::find(Flags.begin(), Flags.end(),
"-Xclang") != Flags.end() ||
1563 std::find(Flags.begin(), Flags.end(),
"-cc1") != Flags.end())
1567 Cur = Flags.at(Flags.size() - 1);
1569 if (Flags.size() >= 2) {
1570 Prev = Flags.at(Flags.size() - 2);
1571 SuggestedCompletions = Opts->suggestValueCompletions(Prev, Cur);
1574 if (SuggestedCompletions.empty())
1575 SuggestedCompletions = Opts->suggestValueCompletions(Cur,
"");
1582 if (SuggestedCompletions.empty() && HasSpace && !Flags.empty()) {
1583 llvm::outs() <<
'\n';
1589 if (SuggestedCompletions.empty() && !Cur.endswith(
"=")) {
1593 SuggestedCompletions = Opts->findByPrefix(Cur, DisableFlags);
1599 if (S.startswith(Cur))
1600 SuggestedCompletions.push_back(S);
1607 llvm::sort(SuggestedCompletions, [](StringRef A, StringRef B) {
1608 if (
int X = A.compare_lower(B))
1610 return A.compare(B) > 0;
1613 llvm::outs() << llvm::join(SuggestedCompletions,
"\n") <<
'\n';
1620 if (C.
getArgs().hasArg(options::OPT_dumpmachine)) {
1625 if (C.
getArgs().hasArg(options::OPT_dumpversion)) {
1632 llvm::outs() <<
"4.2.1\n";
1636 if (C.
getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
1641 if (C.
getArgs().hasArg(options::OPT_help) ||
1642 C.
getArgs().hasArg(options::OPT__help_hidden)) {
1647 if (C.
getArgs().hasArg(options::OPT__version)) {
1653 if (C.
getArgs().hasArg(options::OPT_v) ||
1654 C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1656 SuppressMissingInputWarning =
true;
1659 if (C.
getArgs().hasArg(options::OPT_v)) {
1661 llvm::errs() <<
"System configuration file directory: " 1664 llvm::errs() <<
"User configuration file directory: " 1670 if (C.
getArgs().hasArg(options::OPT_v))
1673 if (C.
getArgs().hasArg(options::OPT_print_resource_dir)) {
1678 if (C.
getArgs().hasArg(options::OPT_print_search_dirs)) {
1679 llvm::outs() <<
"programs: =";
1680 bool separator =
false;
1683 llvm::outs() <<
':';
1684 llvm::outs() << Path;
1687 llvm::outs() <<
"\n";
1694 llvm::outs() <<
':';
1697 llvm::outs() << sysroot << Path.substr(1);
1699 llvm::outs() << Path;
1701 llvm::outs() <<
"\n";
1707 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
1708 llvm::outs() <<
GetFilePath(A->getValue(), TC) <<
"\n";
1712 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
1713 StringRef ProgName = A->getValue();
1716 if (! ProgName.empty())
1719 llvm::outs() <<
"\n";
1723 if (Arg *A = C.
getArgs().getLastArg(options::OPT_autocomplete)) {
1724 StringRef PassedFlags = A->getValue();
1729 if (C.
getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
1738 llvm::outs() <<
GetFilePath(
"libgcc.a", TC) <<
"\n";
1744 if (C.
getArgs().hasArg(options::OPT_print_multi_lib)) {
1750 if (C.
getArgs().hasArg(options::OPT_print_multi_directory)) {
1753 llvm::outs() <<
".\n";
1756 assert(Suffix.front() ==
'/');
1757 llvm::outs() << Suffix.substr(1) <<
"\n";
1762 if (C.
getArgs().hasArg(options::OPT_print_target_triple)) {
1767 if (C.
getArgs().hasArg(options::OPT_print_effective_triple)) {
1769 llvm::outs() << Triple.getTriple() <<
"\n";
1780 std::map<Action *, unsigned> &Ids) {
1785 llvm::raw_string_ostream os(str);
1789 os <<
"\"" << IA->getInputArg().getValue() <<
"\"";
1791 os <<
'"' << BIA->getArchName() <<
'"' <<
", {" 1793 }
else if (
OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1794 bool IsFirst =
true;
1795 OA->doOnEachDependence(
1812 os <<
":" << BoundArch;
1822 const char *Prefix =
"{";
1823 for (
Action *PreRequisite : *AL) {
1834 std::string offload_str;
1835 llvm::raw_string_ostream offload_os(offload_str);
1836 if (!isa<OffloadAction>(A)) {
1839 offload_os <<
", (" << S;
1846 unsigned Id = Ids.size();
1848 llvm::errs() << Id <<
": " << os.str() <<
", " 1857 std::map<Action *, unsigned> Ids;
1865 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
1866 isa<AssembleJobAction>(A))
1878 DerivedArgList &Args = C.
getArgs();
1880 llvm::PrettyStackTraceString CrashInfo(
"Building universal build actions");
1883 llvm::StringSet<> ArchNames;
1885 for (Arg *A : Args) {
1886 if (A->getOption().matches(options::OPT_arch)) {
1889 llvm::Triple::ArchType Arch =
1891 if (Arch == llvm::Triple::UnknownArch) {
1892 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
1897 if (ArchNames.insert(A->getValue()).second)
1898 Archs.push_back(A->getValue());
1912 for (
Action* Act : SingleActions) {
1920 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
1924 for (
unsigned i = 0, e = Archs.size(); i != e; ++i)
1929 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1930 Actions.append(Inputs.begin(), Inputs.end());
1935 Arg *A = Args.getLastArg(options::OPT_g_Group);
1936 if (A && !A->getOption().matches(options::OPT_g0) &&
1937 !A->getOption().matches(options::OPT_gstabs) &&
1944 if (Act->getType() == types::TY_Image) {
1946 Inputs.push_back(Actions.back());
1953 if (Args.hasArg(options::OPT_verify_debug_info)) {
1954 Action* LastAction = Actions.back();
1957 LastAction, types::TY_Nothing));
1975 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
1976 if (!llvm::sys::path::is_absolute(Path)) {
1978 llvm::sys::path::append(Directory, Value);
1979 Path.assign(Directory);
1983 if (D.
getVFS().exists(Path))
1987 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1988 llvm::sys::Process::FindInEnvPath(
"LIB", Value))
1991 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1999 D.
Diag(clang::diag::err_drv_no_such_file) << Path;
2009 types::ID InputType = types::TY_Nothing;
2010 Arg *InputTypeArg =
nullptr;
2013 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
2014 options::OPT__SLASH_TP)) {
2015 InputTypeArg = TCTP;
2016 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
2021 bool ShowNote =
false;
2022 for (Arg *A : Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) {
2024 Diag(clang::diag::warn_drv_overriding_flag_option)
2025 << Previous->getSpelling() << A->getSpelling();
2031 Diag(clang::diag::note_drv_t_option_is_global);
2034 assert(!Args.hasArg(options::OPT_x) &&
"-x and /TC or /TP is not allowed");
2037 for (Arg *A : Args) {
2038 if (A->getOption().getKind() == Option::InputClass) {
2039 const char *
Value = A->getValue();
2043 if (InputType == types::TY_Nothing) {
2046 InputTypeArg->claim();
2049 if (memcmp(Value,
"-", 2) == 0) {
2055 if (!Args.hasArgNoClaim(options::OPT_E) && !
CCCIsCPP())
2056 Diag(
IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
2057 : clang::diag::err_drv_unknown_stdin_type);
2065 if (
const char *Ext = strrchr(Value,
'.'))
2071 else if (
IsCLMode() && Args.hasArgNoClaim(options::OPT_E))
2074 Ty = types::TY_Object;
2084 Diag(clang::diag::warn_drv_treating_input_as_cxx)
2094 if (Ty != types::TY_Object) {
2095 if (Args.hasArg(options::OPT_ObjC))
2096 Ty = types::TY_ObjC;
2097 else if (Args.hasArg(options::OPT_ObjCXX))
2098 Ty = types::TY_ObjCXX;
2101 assert(InputTypeArg &&
"InputType set w/o InputTypeArg");
2102 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
2105 const char *Ext = strrchr(Value,
'.');
2107 Ty = types::TY_Object;
2111 InputTypeArg->claim();
2116 Inputs.push_back(std::make_pair(Ty, A));
2118 }
else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
2119 StringRef
Value = A->getValue();
2121 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
2122 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
2125 }
else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
2126 StringRef
Value = A->getValue();
2128 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
2129 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
2135 Inputs.push_back(std::make_pair(types::TY_Object, A));
2137 }
else if (A->getOption().matches(options::OPT_x)) {
2146 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
2147 InputType = types::TY_Object;
2149 }
else if (A->getOption().getID() == options::OPT__SLASH_U) {
2150 assert(A->getNumValues() == 1 &&
"The /U option has one value.");
2151 StringRef Val = A->getValue(0);
2152 if (Val.find_first_of(
"/\\") != StringRef::npos) {
2154 Diag(diag::warn_slash_u_filename) << Val;
2155 Diag(diag::note_use_dashdash);
2159 if (
CCCIsCPP() && Inputs.empty()) {
2163 Inputs.push_back(std::make_pair(types::TY_C, A));
2170 class OffloadingActionBuilder final {
2172 bool IsValid =
false;
2178 std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
2181 class DeviceActionBuilder {
2185 enum ActionBuilderReturnCode {
2204 DerivedArgList &Args;
2213 DeviceActionBuilder(
Compilation &C, DerivedArgList &Args,
2216 : C(C), Args(Args), Inputs(Inputs),
2217 AssociatedOffloadKind(AssociatedOffloadKind) {}
2218 virtual ~DeviceActionBuilder() {}
2223 virtual ActionBuilderReturnCode
2227 return ABRT_Inactive;
2232 virtual ActionBuilderReturnCode addDeviceDepences(
Action *HostAction) {
2233 return ABRT_Inactive;
2238 virtual void appendTopLevelActions(
ActionList &AL) {}
2249 virtual bool canUseBundlerUnbundler()
const {
return false; }
2253 bool isValid() {
return !ToolChains.empty(); }
2257 return AssociatedOffloadKind;
2263 class CudaActionBuilderBase :
public DeviceActionBuilder {
2267 bool CompileHostOnly =
false;
2268 bool CompileDeviceOnly =
false;
2277 Action *CudaFatBinary =
nullptr;
2280 bool IsActive =
false;
2282 CudaActionBuilderBase(
Compilation &C, DerivedArgList &Args,
2285 : DeviceActionBuilder(C, Args, Inputs, OFKind) {}
2287 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2294 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2295 assert(!GpuArchList.empty() &&
2296 "We should have at least one GPU architecture.");
2300 if (IA->getType() != types::TY_CUDA &&
2301 IA->getType() != types::TY_HIP) {
2304 return ABRT_Inactive;
2310 if (CompileHostOnly)
2311 return ABRT_Success;
2314 auto Ty = IA->getType() == types::TY_HIP ? types::TY_HIP_DEVICE
2315 : types::TY_CUDA_DEVICE;
2316 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2317 CudaDeviceActions.push_back(
2321 return ABRT_Success;
2325 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2326 CudaDeviceActions.clear();
2327 auto *IA = cast<InputAction>(UA->getInputs().back());
2328 std::string FileName = IA->getInputArg().getAsString(Args);
2332 if (IA->getType() == types::TY_Object &&
2333 (!llvm::sys::path::has_extension(FileName) ||
2335 llvm::sys::path::extension(FileName).drop_front()) !=
2337 return ABRT_Inactive;
2339 for (
auto Arch : GpuArchList) {
2340 CudaDeviceActions.push_back(UA);
2342 AssociatedOffloadKind);
2344 return ABRT_Success;
2347 return IsActive ? ABRT_Success : ABRT_Inactive;
2350 void appendTopLevelActions(
ActionList &AL)
override {
2355 AssociatedOffloadKind);
2360 if (CudaFatBinary) {
2362 CudaDeviceActions.clear();
2363 CudaFatBinary =
nullptr;
2367 if (CudaDeviceActions.empty())
2373 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2374 "Expecting one action per GPU architecture.");
2375 assert(ToolChains.size() == 1 &&
2376 "Expecting to have a sing CUDA toolchain.");
2377 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
2378 AddTopLevel(CudaDeviceActions[I], GpuArchList[I]);
2380 CudaDeviceActions.clear();
2398 assert(HostTC &&
"No toolchain for host compilation.");
2400 HostTC->
getTriple().getArch() == llvm::Triple::amdgcn) {
2409 ToolChains.push_back(
2414 Arg *PartialCompilationArg = Args.getLastArg(
2415 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
2416 options::OPT_cuda_compile_host_device);
2417 CompileHostOnly = PartialCompilationArg &&
2418 PartialCompilationArg->getOption().matches(
2419 options::OPT_cuda_host_only);
2420 CompileDeviceOnly = PartialCompilationArg &&
2421 PartialCompilationArg->getOption().matches(
2422 options::OPT_cuda_device_only);
2425 std::set<CudaArch> GpuArchs;
2427 for (Arg *A : Args) {
2428 if (!(A->getOption().matches(options::OPT_cuda_gpu_arch_EQ) ||
2429 A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ)))
2433 const StringRef ArchStr = A->getValue();
2434 if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ) &&
2441 C.
getDriver().
Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
2443 }
else if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
2444 GpuArchs.insert(Arch);
2445 else if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ))
2446 GpuArchs.erase(Arch);
2448 llvm_unreachable(
"Unexpected option.");
2453 GpuArchList.push_back(Arch);
2458 if (GpuArchList.empty())
2467 class CudaActionBuilder final :
public CudaActionBuilderBase {
2469 CudaActionBuilder(
Compilation &C, DerivedArgList &Args,
2473 ActionBuilderReturnCode
2476 PhasesTy &Phases)
override {
2478 return ABRT_Inactive;
2482 if (CudaDeviceActions.empty())
2483 return ABRT_Success;
2485 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2486 "Expecting one action per GPU architecture.");
2487 assert(!CompileHostOnly &&
2488 "Not expecting CUDA actions in host-only compilation.");
2498 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2501 for (
auto Ph : Phases) {
2506 if (Ph > FinalPhase)
2519 if (!isa<AssembleJobAction>(CudaDeviceActions[I]) ||
2523 Action *AssembleAction = CudaDeviceActions[I];
2524 assert(AssembleAction->
getType() == types::TY_Object);
2525 assert(AssembleAction->
getInputs().size() == 1);
2528 assert(BackendAction->getType() == types::TY_PP_Asm);
2530 for (
auto &A : {AssembleAction, BackendAction}) {
2534 DeviceActions.push_back(
2540 if (!DeviceActions.empty()) {
2544 if (!CompileDeviceOnly) {
2545 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
2549 CudaFatBinary =
nullptr;
2554 CudaDeviceActions.clear();
2558 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
2563 return ABRT_Success;
2567 "instructions should only occur " 2568 "before the backend phase!");
2571 for (
Action *&A : CudaDeviceActions)
2574 return ABRT_Success;
2579 class HIPActionBuilder final :
public CudaActionBuilderBase {
2585 HIPActionBuilder(
Compilation &C, DerivedArgList &Args,
2588 Relocatable(
false) {}
2590 bool canUseBundlerUnbundler()
const override {
return true; }
2592 ActionBuilderReturnCode
2595 PhasesTy &Phases)
override {
2600 if (CudaDeviceActions.empty() ||
2603 return ABRT_Success;
2606 CudaDeviceActions.size() == GpuArchList.size()) &&
2607 "Expecting one action per GPU architecture.");
2608 assert(!CompileHostOnly &&
2609 "Not expecting CUDA actions in host-only compilation.");
2617 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2621 AL.push_back(CudaDeviceActions[I]);
2622 CudaDeviceActions[I] =
2632 DDep.
add(*CudaDeviceActions[I], *ToolChains.front(),
2635 DDep, CudaDeviceActions[I]->getType());
2640 types::TY_HIP_FATBIN);
2642 if (!CompileDeviceOnly) {
2643 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
2644 AssociatedOffloadKind);
2647 CudaFatBinary =
nullptr;
2652 CudaDeviceActions.clear();
2654 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
2661 DeviceLinkerInputs.resize(CudaDeviceActions.size());
2662 auto LI = DeviceLinkerInputs.begin();
2663 for (
auto *A : CudaDeviceActions) {
2670 CudaDeviceActions.clear();
2671 return ABRT_Success;
2675 for (
Action *&A : CudaDeviceActions)
2677 AssociatedOffloadKind);
2679 return ABRT_Success;
2685 for (
auto &LI : DeviceLinkerInputs) {
2686 auto *DeviceLinkAction =
2688 DA.
add(*DeviceLinkAction, *ToolChains[0],
2695 Relocatable = Args.hasFlag(options::OPT_fgpu_rdc,
2696 options::OPT_fno_gpu_rdc,
false);
2704 class OpenMPActionBuilder final :
public DeviceActionBuilder {
2712 OpenMPActionBuilder(
Compilation &C, DerivedArgList &Args,
2716 ActionBuilderReturnCode
2719 PhasesTy &Phases)
override {
2720 if (OpenMPDeviceActions.empty())
2721 return ABRT_Inactive;
2724 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2725 "Number of OpenMP actions and toolchains do not match.");
2730 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2731 "Toolchains and linker inputs sizes do not match.");
2732 auto LI = DeviceLinkerInputs.begin();
2733 for (
auto *A : OpenMPDeviceActions) {
2740 OpenMPDeviceActions.clear();
2741 return ABRT_Success;
2745 for (
Action *&A : OpenMPDeviceActions)
2748 return ABRT_Success;
2751 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2754 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2755 OpenMPDeviceActions.clear();
2756 for (
unsigned I = 0; I < ToolChains.size(); ++I)
2757 OpenMPDeviceActions.push_back(
2759 return ABRT_Success;
2763 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2764 OpenMPDeviceActions.clear();
2765 auto *IA = cast<InputAction>(UA->getInputs().back());
2766 std::string FileName = IA->getInputArg().getAsString(Args);
2770 if (IA->getType() == types::TY_Object &&
2771 (!llvm::sys::path::has_extension(FileName) ||
2773 llvm::sys::path::extension(FileName).drop_front()) !=
2775 return ABRT_Inactive;
2776 for (
unsigned I = 0; I < ToolChains.size(); ++I) {
2777 OpenMPDeviceActions.push_back(UA);
2778 UA->registerDependentActionInfo(
2781 return ABRT_Success;
2788 if (isa<CompileJobAction>(HostAction)) {
2790 assert(ToolChains.size() == OpenMPDeviceActions.size() &&
2791 "Toolchains and device action sizes do not match.");
2795 auto TC = ToolChains.begin();
2796 for (
Action *&A : OpenMPDeviceActions) {
2797 assert(isa<CompileJobAction>(A));
2804 return ABRT_Success;
2807 void appendTopLevelActions(
ActionList &AL)
override {
2808 if (OpenMPDeviceActions.empty())
2812 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2813 "Number of OpenMP actions and toolchains do not match.");
2816 auto TI = ToolChains.begin();
2817 for (
auto *A : OpenMPDeviceActions) {
2824 OpenMPDeviceActions.clear();
2828 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2829 "Toolchains and linker inputs sizes do not match.");
2832 auto TC = ToolChains.begin();
2833 for (
auto &LI : DeviceLinkerInputs) {
2834 auto *DeviceLinkAction =
2836 DA.
add(*DeviceLinkAction, **TC,
nullptr,
2846 for (
auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE;
2848 ToolChains.push_back(TI->second);
2850 DeviceLinkerInputs.resize(ToolChains.size());
2854 bool canUseBundlerUnbundler()
const override {
2871 OffloadingActionBuilder(
Compilation &C, DerivedArgList &Args,
2879 SpecializedBuilders.push_back(
new CudaActionBuilder(C, Args, Inputs));
2882 SpecializedBuilders.push_back(
new HIPActionBuilder(C, Args, Inputs));
2885 SpecializedBuilders.push_back(
new OpenMPActionBuilder(C, Args, Inputs));
2893 unsigned ValidBuilders = 0u;
2894 unsigned ValidBuildersSupportingBundling = 0u;
2895 for (
auto *SB : SpecializedBuilders) {
2896 IsValid = IsValid && !SB->initialize();
2899 if (SB->isValid()) {
2901 if (SB->canUseBundlerUnbundler())
2902 ++ValidBuildersSupportingBundling;
2906 ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling;
2909 ~OffloadingActionBuilder() {
2910 for (
auto *SB : SpecializedBuilders)
2919 addDeviceDependencesToHostAction(
Action *HostAction,
const Arg *InputArg,
2921 DeviceActionBuilder::PhasesTy &Phases) {
2925 if (SpecializedBuilders.empty())
2928 assert(HostAction &&
"Invalid host action!");
2933 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2934 unsigned InactiveBuilders = 0u;
2935 unsigned IgnoringBuilders = 0u;
2936 for (
auto *SB : SpecializedBuilders) {
2937 if (!SB->isValid()) {
2943 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
2948 if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host)
2953 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2954 OffloadKind |= SB->getAssociatedOffloadKind();
2959 if (IgnoringBuilders &&
2960 SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders))
2977 bool addHostDependenceToDeviceActions(
Action *&HostAction,
2978 const Arg *InputArg) {
2988 if (CanUseBundler && isa<InputAction>(HostAction) &&
2989 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
2991 auto UnbundlingHostAction =
2996 HostAction = UnbundlingHostAction;
2999 assert(HostAction &&
"Invalid host action!");
3002 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
3003 for (
auto *SB : SpecializedBuilders) {
3007 auto RetCode = SB->addDeviceDepences(HostAction);
3011 assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&
3012 "Host dependence not expected to be ignored.!");
3016 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
3017 OffloadKind |= SB->getAssociatedOffloadKind();
3022 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction))
3032 const Arg *InputArg) {
3035 for (
auto *SB : SpecializedBuilders) {
3038 SB->appendTopLevelActions(OffloadAL);
3045 if (CanUseBundler && HostAction && !OffloadAL.empty()) {
3047 OffloadAL.push_back(HostAction);
3051 assert(HostAction == AL.back() &&
"Host action not in the list??");
3053 AL.back() = HostAction;
3055 AL.append(OffloadAL.begin(), OffloadAL.end());
3072 for (
auto *SB : SpecializedBuilders) {
3076 SB->appendLinkDependences(DDeps);
3080 unsigned ActiveOffloadKinds = 0u;
3081 for (
auto &I : InputArgToOffloadKindMap)
3082 ActiveOffloadKinds |= I.second;
3099 nullptr, ActiveOffloadKinds);
3107 llvm::PrettyStackTraceString CrashInfo(
"Building compilation actions");
3109 if (!SuppressMissingInputWarning && Inputs.empty()) {
3110 Diag(clang::diag::err_drv_no_input_files);
3115 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
3118 if (Args.hasArg(options::OPT_emit_llvm))
3119 Diag(clang::diag::err_drv_emit_llvm_link);
3121 !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower(
"lld"))
3122 Diag(clang::diag::err_drv_lto_without_lld);
3127 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
3128 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
3131 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
3132 StringRef V = A->getValue();
3133 if (Inputs.size() > 1 && !V.empty() &&
3134 !llvm::sys::path::is_separator(V.back())) {
3136 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
3137 << A->getSpelling() << V;
3138 Args.eraseArg(options::OPT__SLASH_Fo);
3143 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
3144 StringRef V = A->getValue();
3145 if (Inputs.size() > 1 && !V.empty() &&
3146 !llvm::sys::path::is_separator(V.back())) {
3148 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
3149 << A->getSpelling() << V;
3150 Args.eraseArg(options::OPT__SLASH_Fa);
3155 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
3156 if (A->getValue()[0] ==
'\0') {
3158 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
3159 Args.eraseArg(options::OPT__SLASH_o);
3164 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
3165 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
3166 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
3167 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
3168 Args.eraseArg(options::OPT__SLASH_Yc);
3169 Args.eraseArg(options::OPT__SLASH_Yu);
3170 YcArg = YuArg =
nullptr;
3172 if (YcArg && Inputs.size() > 1) {
3173 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
3174 Args.eraseArg(options::OPT__SLASH_Yc);
3181 Args.eraseArg(options::OPT__SLASH_Fp);
3182 Args.eraseArg(options::OPT__SLASH_Yc);
3183 Args.eraseArg(options::OPT__SLASH_Yu);
3184 YcArg = YuArg =
nullptr;
3188 OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
3195 for (
auto &I : Inputs) {
3197 const Arg *InputArg = I.second;
3205 if (InitialPhase > FinalPhase) {
3206 if (InputArg->isClaimed())
3213 if (Args.hasArg(options::OPT_Qunused_arguments))
3219 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
3220 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase);
3226 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
3227 << InputArg->getAsString(Args) << !!FinalPhaseArg
3228 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
3230 Diag(clang::diag::warn_drv_input_file_unused)
3231 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase)
3233 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
3249 Actions.push_back(ClangClPch);
3263 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
3271 if (Phase > FinalPhase)
3275 Current = OffloadBuilder.addDeviceDependencesToHostAction(
3276 Current, InputArg, Phase, FinalPhase, PL);
3282 assert((i + 1) == e &&
"linking must be final compilation step.");
3283 LinkerInputs.push_back(Current);
3305 if (NewCurrent == Current)
3308 if (
auto *HMA = dyn_cast<HeaderModulePrecompileJobAction>(NewCurrent))
3309 HeaderModuleAction = HMA;
3311 Current = NewCurrent;
3315 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
3318 if (Current->
getType() == types::TY_Nothing)
3324 Actions.push_back(Current);
3327 OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg);
3331 if (!LinkerInputs.empty()) {
3333 LA = OffloadBuilder.processHostLinkAction(LA);
3334 Actions.push_back(LA);
3340 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
3341 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
3345 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
3349 Args.ClaimAllArgs(options::OPT_cuda_host_only);
3350 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
3356 llvm::PrettyStackTraceString CrashInfo(
"Constructing phase actions");
3367 llvm_unreachable(
"link action invalid here.");
3371 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
3372 OutputTy = types::TY_Dependencies;
3375 if (!Args.hasFlag(options::OPT_frewrite_includes,
3376 options::OPT_fno_rewrite_includes,
false) &&
3377 !Args.hasFlag(options::OPT_frewrite_imports,
3378 options::OPT_fno_rewrite_imports,
false) &&
3382 "Cannot preprocess this input type!");
3389 "Cannot precompile this input type!");
3393 const char *ModName =
nullptr;
3394 if (OutputTy == types::TY_PCH) {
3395 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name_EQ))
3396 ModName = A->getValue();
3398 OutputTy = types::TY_ModuleFile;
3401 if (Args.hasArg(options::OPT_fsyntax_only)) {
3403 OutputTy = types::TY_Nothing;
3412 if (Args.hasArg(options::OPT_fsyntax_only))
3414 if (Args.hasArg(options::OPT_rewrite_objc))
3416 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
3418 types::TY_RewrittenLegacyObjC);
3419 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
3421 if (Args.hasArg(options::OPT__migrate))
3423 if (Args.hasArg(options::OPT_emit_ast))
3425 if (Args.hasArg(options::OPT_module_file_info))
3427 if (Args.hasArg(options::OPT_verify_pch))
3434 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
3437 if (Args.hasArg(options::OPT_emit_llvm)) {
3439 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
3448 llvm_unreachable(
"invalid phase in ConstructPhaseAction");
3452 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3454 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
3459 unsigned NumOutputs = 0;
3461 if (A->getType() != types::TY_Nothing)
3464 if (NumOutputs > 1) {
3465 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
3466 FinalOutput =
nullptr;
3471 llvm::StringSet<> ArchNames;
3473 for (
const Arg *A : C.
getArgs())
3474 if (A->getOption().matches(options::OPT_arch))
3475 ArchNames.insert(A->getValue());
3478 std::map<std::pair<const Action *, std::string>,
InputInfo> CachedResults;
3486 const char *LinkingOutput =
nullptr;
3487 if (isa<LipoJobAction>(A)) {
3489 LinkingOutput = FinalOutput->getValue();
3497 ArchNames.size() > 1,
3498 LinkingOutput, CachedResults,
3504 if (Diags.hasErrorOccurred() ||
3505 C.
getArgs().hasArg(options::OPT_Qunused_arguments))
3509 (void)C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH);
3512 (void)C.
getArgs().hasArg(options::OPT_driver_mode);
3513 (void)C.
getArgs().hasArg(options::OPT_rsp_quoting);
3519 if (!A->isClaimed()) {
3525 const Option &Opt = A->getOption();
3526 if (Opt.getKind() == Option::FlagClass) {
3527 bool DuplicateClaimed =
false;
3529 for (
const Arg *AA : C.
getArgs().filtered(&Opt)) {
3530 if (AA->isClaimed()) {
3531 DuplicateClaimed =
true;
3536 if (DuplicateClaimed)
3542 if (!
IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
3543 Diag(clang::diag::warn_drv_unused_argument)
3544 << A->getAsString(C.
getArgs());
3552 class ToolSelector final {
3563 bool IsHostSelector;
3574 bool CanBeCollapsed =
true) {
3576 if (Inputs.size() != 1)
3579 Action *CurAction = *Inputs.begin();
3580 if (CanBeCollapsed &&
3586 if (
auto *OA = dyn_cast<OffloadAction>(CurAction)) {
3590 if (!IsHostSelector) {
3591 if (OA->hasSingleDeviceDependence(
true)) {
3593 OA->getSingleDeviceDependence(
true);
3594 if (CanBeCollapsed &&
3597 SavedOffloadAction.push_back(OA);
3600 }
else if (OA->hasHostDependence()) {
3601 CurAction = OA->getHostDependence();
3602 if (CanBeCollapsed &&
3605 SavedOffloadAction.push_back(OA);
3615 bool canCollapseAssembleAction()
const {
3616 return TC.useIntegratedAs() && !SaveTemps &&
3617 !C.
getArgs().hasArg(options::OPT_via_file_asm) &&
3618 !C.
getArgs().hasArg(options::OPT__SLASH_FA) &&
3619 !C.
getArgs().hasArg(options::OPT__SLASH_Fa);
3623 bool canCollapsePreprocessorAction()
const {
3624 return !C.
getArgs().hasArg(options::OPT_no_integrated_cpp) &&
3625 !C.
getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
3626 !C.
getArgs().hasArg(options::OPT_rewrite_objc);
3631 struct JobActionInfo final {
3641 static void AppendCollapsedOffloadAction(
ActionList &CollapsedOffloadAction,
3643 unsigned ElementNum) {
3644 assert(ElementNum <= ActionInfo.size() &&
"Invalid number of elements.");
3645 for (
unsigned I = 0; I < ElementNum; ++I)
3646 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
3647 ActionInfo[I].SavedOffloadAction.end());
3663 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
3668 if (!AJ || !BJ || !CJ)
3672 const Tool *T = TC.SelectTool(*CJ);
3679 const Tool *BT = TC.SelectTool(*BJ);
3687 Inputs = CJ->getInputs();
3688 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3695 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
3704 auto *CJ = getPrevDependentAction(BJ->getInputs(), CompileJobOffloadActions,
3706 if (!AJ || !BJ || !CJ)
3709 assert(isa<CompileJobAction>(CJ) &&
3710 "Expecting compile job preceding backend job.");
3713 const Tool *T = TC.SelectTool(*CJ);
3720 Inputs = BJ->getInputs();
3721 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3728 if (ActionInfo.size() < 2)
3740 bool InputIsBitcode =
true;
3741 for (
size_t i = 1; i < ActionInfo.size(); i++)
3742 if (ActionInfo[i].JA->getType() != types::TY_LLVM_BC &&
3743 ActionInfo[i].JA->getType() != types::TY_LTO_BC) {
3744 InputIsBitcode =
false;
3747 if (!InputIsBitcode && !canCollapsePreprocessorAction())
3751 const Tool *T = TC.SelectTool(*CJ);
3755 if (T->
canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode))
3758 Inputs = CJ->getInputs();
3759 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3776 for (
Action *A : Inputs) {
3777 auto *PJ = getPrevDependentAction({A}, PreprocessJobOffloadActions);
3778 if (!PJ || !isa<PreprocessJobAction>(PJ)) {
3779 NewInputs.push_back(A);
3785 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
3786 PreprocessJobOffloadActions.end());
3787 NewInputs.append(PJ->input_begin(), PJ->input_end());
3794 const Compilation &C,
bool SaveTemps,
bool EmbedBitcode)
3795 : TC(TC), C(C), BaseAction(BaseAction), SaveTemps(SaveTemps),
3796 EmbedBitcode(EmbedBitcode) {
3797 assert(BaseAction &&
"Invalid base action.");
3814 ActionChain.back().JA = BaseAction;
3815 while (ActionChain.back().JA) {
3816 const Action *CurAction = ActionChain.back().JA;
3819 ActionChain.resize(ActionChain.size() + 1);
3820 JobActionInfo &AI = ActionChain.back();
3824 getPrevDependentAction(CurAction->
getInputs(), AI.SavedOffloadAction);
3828 ActionChain.pop_back();
3836 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
3837 CollapsedOffloadAction);
3839 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
3841 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
3847 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
3859 StringRef BoundArch,
3861 std::string TriplePlusArch = TC->
getTriple().normalize();
3862 if (!BoundArch.empty()) {
3863 TriplePlusArch +=
"-";
3864 TriplePlusArch += BoundArch;
3866 TriplePlusArch +=
"-";
3868 return TriplePlusArch;
3873 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3874 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3876 std::pair<const Action *, std::string> ActionTC = {
3878 auto CachedResult = CachedResults.find(ActionTC);
3879 if (CachedResult != CachedResults.end()) {
3880 return CachedResult->second;
3882 InputInfo Result = BuildJobsForActionNoCache(
3883 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
3884 CachedResults, TargetDeviceOffloadKind);
3885 CachedResults[ActionTC] = Result;
3889 InputInfo Driver::BuildJobsForActionNoCache(
3891 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3892 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3894 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3897 bool BuildingForOffloadDevice = TargetDeviceOffloadKind !=
Action::OFK_None;
3929 if (OA->hasSingleDeviceDependence()) {
3931 OA->doOnEachDeviceDependence([&](
Action *DepA,
const ToolChain *DepTC,
3932 const char *DepBoundArch) {
3935 !!DepBoundArch, LinkingOutput,
3945 OA->doOnEachDependence(
3946 BuildingForOffloadDevice,
3949 C, DepA, DepTC, DepBoundArch,
false,
3950 !!DepBoundArch, LinkingOutput, CachedResults,
3954 A = BuildingForOffloadDevice
3955 ? OA->getSingleDeviceDependence(
true)
3956 : OA->getHostDependence();
3959 if (
const InputAction *IA = dyn_cast<InputAction>(A)) {
3962 const Arg &Input = IA->getInputArg();
3964 if (Input.getOption().matches(options::OPT_INPUT)) {
3965 const char *
Name = Input.getValue();
3975 if (!ArchName.empty())
3976 TC = &getToolChain(C.
getArgs(),
3983 MultipleArchs, LinkingOutput, CachedResults,
3984 TargetDeviceOffloadKind);
3990 const JobAction *JA = cast<JobAction>(A);
3995 const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions);
4002 for (
const auto *OA : CollapsedOffloadActions)
4003 cast<OffloadAction>(OA)->doOnEachDependence(
4004 BuildingForOffloadDevice,
4007 C, DepA, DepTC, DepBoundArch,
false,
4008 !!DepBoundArch, LinkingOutput, CachedResults,
4014 for (
const Action *Input : Inputs) {
4018 bool SubJobAtTopLevel =
4019 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
4021 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
4026 const char *BaseInput = InputInfos[0].getBaseInput();
4030 if (JA->
getType() == types::TY_dSYM)
4031 BaseInput = InputInfos[0].getFilename();
4034 if (
auto *ModuleJA = dyn_cast<HeaderModulePrecompileJobAction>(JA))
4035 BaseInput = ModuleJA->getModuleName();
4038 if (!OffloadDependencesInputInfo.empty())
4039 InputInfos.append(OffloadDependencesInputInfo.begin(),
4040 OffloadDependencesInputInfo.end());
4043 llvm::Triple EffectiveTriple;
4045 const ArgList &Args =
4047 if (InputInfos.size() != 1) {
4051 EffectiveTriple = llvm::Triple(
4059 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) {
4063 for (
auto &UI : UA->getDependentActionsInfo()) {
4065 "Unbundling with no offloading??");
4072 UI.DependentOffloadKind,
4073 UI.DependentToolChain->getTriple().normalize(),
4084 UnbundlingResults.push_back(CurI);
4093 Arch = UI.DependentBoundArch;
4098 UI.DependentOffloadKind)}] =
4104 std::pair<const Action *, std::string> ActionTC = {
4106 assert(CachedResults.find(ActionTC) != CachedResults.end() &&
4107 "Result does not exist??");
4108 Result = CachedResults[ActionTC];
4109 }
else if (JA->
getType() == types::TY_Nothing)
4119 AtTopLevel, MultipleArchs,
4126 <<
" - \"" << T->
getName() <<
"\", inputs: [";
4127 for (
unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
4128 llvm::errs() << InputInfos[i].getAsString();
4130 llvm::errs() <<
", ";
4132 if (UnbundlingResults.empty())
4133 llvm::errs() <<
"], output: " << Result.
getAsString() <<
"\n";
4135 llvm::errs() <<
"], outputs: [";
4136 for (
unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) {
4137 llvm::errs() << UnbundlingResults[i].getAsString();
4139 llvm::errs() <<
", ";
4141 llvm::errs() <<
"] \n";
4144 if (UnbundlingResults.empty())
4146 C, *JA, Result, InputInfos,
4151 C, *JA, UnbundlingResults, InputInfos,
4160 return Target.isOSWindows() ?
"a.exe" :
"a.out";
4172 if (ArgValue.empty()) {
4174 Filename = BaseName;
4175 }
else if (llvm::sys::path::is_separator(Filename.back())) {
4177 llvm::sys::path::append(Filename, BaseName);
4180 if (!llvm::sys::path::has_extension(ArgValue)) {
4184 if (FileType == types::TY_Image &&
4185 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
4190 llvm::sys::path::replace_extension(Filename, Extension);
4193 return Args.MakeArgString(Filename.c_str());
4197 const char *BaseInput,
4198 StringRef BoundArch,
bool AtTopLevel,
4200 StringRef OffloadingPrefix)
const {
4201 llvm::PrettyStackTraceString CrashInfo(
"Computing output path");
4203 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
4204 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
4209 if (C.
getArgs().hasArg(options::OPT__SLASH_P)) {
4210 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
4211 StringRef BaseName = llvm::sys::path::filename(BaseInput);
4213 if (Arg *A = C.
getArgs().getLastArg(options::OPT__SLASH_Fi))
4214 NameArg = A->getValue();
4225 if (JA.
getType() == types::TY_PP_Asm &&
4226 (C.
getArgs().hasArg(options::OPT__SLASH_FA) ||
4227 C.
getArgs().hasArg(options::OPT__SLASH_Fa))) {
4229 StringRef BaseName = llvm::sys::path::filename(BaseInput);
4230 StringRef FaValue = C.
getArgs().getLastArgValue(options::OPT__SLASH_Fa);
4238 !C.
getArgs().hasArg(options::OPT__SLASH_Fo)) ||
4240 StringRef
Name = llvm::sys::path::filename(BaseInput);
4241 std::pair<StringRef, StringRef>
Split = Name.split(
'.');
4244 Arg *A = C.
getArgs().getLastArg(options::OPT_fcrash_diagnostics_dir);
4247 llvm::sys::path::append(CrashDirectory, Split.first);
4248 const char *Middle = Suffix ?
"-%%%%%%." :
"-%%%%%%";
4249 std::error_code EC =
4250 llvm::sys::fs::createUniqueFile(CrashDirectory + Middle + Suffix, TmpName);
4252 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
4265 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
4266 BaseName = BasePath;
4268 BaseName = llvm::sys::path::filename(BasePath);
4271 const char *NamedOutput;
4273 if ((JA.
getType() == types::TY_Object || JA.
getType() == types::TY_LTO_BC) &&
4274 C.
getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
4278 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
4282 }
else if (JA.
getType() == types::TY_Image &&
4283 C.
getArgs().hasArg(options::OPT__SLASH_Fe,
4284 options::OPT__SLASH_o)) {
4288 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
4292 }
else if (JA.
getType() == types::TY_Image) {
4299 Output += OffloadingPrefix;
4300 if (MultipleArchs && !BoundArch.empty()) {
4302 Output.append(BoundArch);
4304 NamedOutput = C.
getArgs().MakeArgString(Output.c_str());
4310 assert(Suffix &&
"All types used for output should have a suffix.");
4312 std::string::size_type
End = std::string::npos;
4314 End = BaseName.rfind(
'.');
4316 Suffixed += OffloadingPrefix;
4317 if (MultipleArchs && !BoundArch.empty()) {
4319 Suffixed.append(BoundArch);
4324 if (!AtTopLevel && C.
getArgs().hasArg(options::OPT_emit_llvm) &&
4325 JA.
getType() == types::TY_LLVM_BC)
4329 NamedOutput = C.
getArgs().MakeArgString(Suffixed.c_str());
4334 JA.
getType() != types::TY_PCH) {
4335 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
4337 llvm::sys::path::remove_filename(TempPath);
4338 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
4339 llvm::sys::path::append(TempPath, OutputFileName);
4340 NamedOutput = C.
getArgs().MakeArgString(TempPath.c_str());
4346 bool SameFile =
false;
4348 llvm::sys::fs::current_path(Result);
4349 llvm::sys::path::append(Result, BaseName);
4350 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
4353 StringRef
Name = llvm::sys::path::filename(BaseInput);
4354 std::pair<StringRef, StringRef>
Split = Name.split(
'.');
4363 llvm::sys::path::remove_filename(BasePath);
4364 if (BasePath.empty())
4365 BasePath = NamedOutput;
4367 llvm::sys::path::append(BasePath, NamedOutput);
4380 for (
const auto &
Dir :
P) {
4384 llvm::sys::path::append(P, Name);
4385 if (llvm::sys::fs::exists(Twine(P)))
4386 return P.str().str();
4395 llvm::sys::path::append(R, Name);
4396 if (llvm::sys::fs::exists(Twine(R)))
4400 llvm::sys::path::append(
P, Name);
4401 if (llvm::sys::fs::exists(Twine(
P)))
4413 void Driver::generatePrefixedToolNames(
4417 Names.emplace_back((TargetTriple +
"-" +
Tool).
str());
4418 Names.emplace_back(
Tool);
4421 std::string DefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
4422 if (DefaultTargetTriple != TargetTriple)
4423 Names.emplace_back((DefaultTargetTriple +
"-" +
Tool).
str());
4428 for (
const auto &
Name : Names) {
4429 llvm::sys::path::append(Dir,
Name);
4430 if (llvm::sys::fs::can_execute(Twine(Dir)))
4432 llvm::sys::path::remove_filename(Dir);
4439 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
4444 if (llvm::sys::fs::is_directory(PrefixDir)) {
4450 if (llvm::sys::fs::can_execute(Twine(P)))
4456 for (
const auto &Path : List) {
4463 for (
const auto &TargetSpecificExecutable : TargetSpecificExecutables)
4464 if (llvm::ErrorOr<std::string>
P =
4465 llvm::sys::findProgramByName(TargetSpecificExecutable))
4473 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
4475 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
4484 std::error_code EC = llvm::sys::fs::createUniqueDirectory(Prefix, Path);
4486 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
4495 if (Arg *FpArg = C.
getArgs().getLastArg(options::OPT__SLASH_Fp)) {
4499 Output = FpArg->getValue();
4503 if (!llvm::sys::path::has_extension(Output))
4506 if (Arg *YcArg = C.
getArgs().getLastArg(options::OPT__SLASH_Yc))
4507 Output = YcArg->getValue();
4510 llvm::sys::path::replace_extension(Output,
".pch");
4512 return Output.str();
4515 const ToolChain &Driver::getToolChain(
const ArgList &Args,
4516 const llvm::Triple &
Target)
const {
4518 auto &TC = ToolChains[Target.str()];
4520 switch (Target.getOS()) {
4521 case llvm::Triple::Haiku:
4522 TC = llvm::make_unique<toolchains::Haiku>(*
this, Target, Args);
4524 case llvm::Triple::Ananas:
4525 TC = llvm::make_unique<toolchains::Ananas>(*
this, Target, Args);
4527 case llvm::Triple::CloudABI:
4528 TC = llvm::make_unique<toolchains::CloudABI>(*
this, Target, Args);
4530 case llvm::Triple::Darwin:
4531 case llvm::Triple::MacOSX:
4532 case llvm::Triple::IOS:
4533 case llvm::Triple::TvOS:
4534 case llvm::Triple::WatchOS:
4535 TC = llvm::make_unique<toolchains::DarwinClang>(*
this, Target, Args);
4537 case llvm::Triple::DragonFly:
4538 TC = llvm::make_unique<toolchains::DragonFly>(*
this, Target, Args);
4540 case llvm::Triple::OpenBSD:
4541 TC = llvm::make_unique<toolchains::OpenBSD>(*
this, Target, Args);
4543 case llvm::Triple::NetBSD:
4544 TC = llvm::make_unique<toolchains::NetBSD>(*
this, Target, Args);
4546 case llvm::Triple::FreeBSD:
4547 TC = llvm::make_unique<toolchains::FreeBSD>(*
this, Target, Args);
4549 case llvm::Triple::Minix:
4550 TC = llvm::make_unique<toolchains::Minix>(*
this, Target, Args);
4552 case llvm::Triple::Linux:
4553 case llvm::Triple::ELFIAMCU:
4554 if (Target.getArch() == llvm::Triple::hexagon)
4555 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
4557 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
4558 !Target.hasEnvironment())
4559 TC = llvm::make_unique<toolchains::MipsLLVMToolChain>(*
this, Target,
4562 TC = llvm::make_unique<toolchains::Linux>(*
this, Target, Args);
4564 case llvm::Triple::NaCl:
4565 TC = llvm::make_unique<toolchains::NaClToolChain>(*
this, Target, Args);
4567 case llvm::Triple::Fuchsia:
4568 TC = llvm::make_unique<toolchains::Fuchsia>(*
this, Target, Args);
4570 case llvm::Triple::Solaris:
4571 TC = llvm::make_unique<toolchains::Solaris>(*
this, Target, Args);
4573 case llvm::Triple::AMDHSA:
4574 TC = llvm::make_unique<toolchains::AMDGPUToolChain>(*
this, Target, Args);
4576 case llvm::Triple::Win32:
4577 switch (Target.getEnvironment()) {
4579 if (Target.isOSBinFormatELF())
4580 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
4581 else if (Target.isOSBinFormatMachO())
4582 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
4584 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
4586 case llvm::Triple::GNU:
4587 TC = llvm::make_unique<toolchains::MinGW>(*
this, Target, Args);
4589 case llvm::Triple::Itanium:
4590 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(*
this, Target,
4593 case llvm::Triple::MSVC:
4594 case llvm::Triple::UnknownEnvironment:
4595 if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
4596 .startswith_lower(
"bfd"))
4597 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(
4598 *
this, Target, Args);
4601 llvm::make_unique<toolchains::MSVCToolChain>(*
this, Target, Args);
4605 case llvm::Triple::PS4:
4606 TC = llvm::make_unique<toolchains::PS4CPU>(*
this, Target, Args);
4608 case llvm::Triple::Contiki:
4609 TC = llvm::make_unique<toolchains::Contiki>(*
this, Target, Args);
4611 case llvm::Triple::Hurd:
4612 TC = llvm::make_unique<toolchains::Hurd>(*
this, Target, Args);
4617 switch (Target.getArch()) {
4618 case llvm::Triple::tce:
4619 TC = llvm::make_unique<toolchains::TCEToolChain>(*
this, Target, Args);
4621 case llvm::Triple::tcele:
4622 TC = llvm::make_unique<toolchains::TCELEToolChain>(*
this, Target, Args);
4624 case llvm::Triple::hexagon:
4625 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
4628 case llvm::Triple::lanai:
4629 TC = llvm::make_unique<toolchains::LanaiToolChain>(*
this, Target, Args);
4631 case llvm::Triple::xcore:
4632 TC = llvm::make_unique<toolchains::XCoreToolChain>(*
this, Target, Args);
4634 case llvm::Triple::wasm32:
4635 case llvm::Triple::wasm64:
4636 TC = llvm::make_unique<toolchains::WebAssembly>(*
this, Target, Args);
4638 case llvm::Triple::avr:
4639 TC = llvm::make_unique<toolchains::AVRToolChain>(*
this, Target, Args);
4641 case llvm::Triple::msp430:
4643 llvm::make_unique<toolchains::MSP430ToolChain>(*
this, Target, Args);
4645 case llvm::Triple::riscv32:
4646 case llvm::Triple::riscv64:
4647 TC = llvm::make_unique<toolchains::RISCVToolChain>(*
this, Target, Args);
4650 if (Target.getVendor() == llvm::Triple::Myriad)
4651 TC = llvm::make_unique<toolchains::MyriadToolChain>(*
this, Target,
4654 TC = llvm::make_unique<toolchains::BareMetal>(*
this, Target, Args);
4655 else if (Target.isOSBinFormatELF())
4656 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
4657 else if (Target.isOSBinFormatMachO())
4658 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
4660 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
4675 if (JA.
size() != 1 ||
4680 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
4681 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
4693 unsigned &Micro,
bool &HadExtra) {
4696 Major = Minor = Micro = 0;
4700 if (Str.consumeInteger(10, Major))
4707 Str = Str.drop_front(1);
4709 if (Str.consumeInteger(10, Minor))
4715 Str = Str.drop_front(1);
4717 if (Str.consumeInteger(10, Micro))
4735 unsigned CurDigit = 0;
4736 while (CurDigit < Digits.size()) {
4738 if (Str.consumeInteger(10, Digit))
4740 Digits[CurDigit] = Digit;
4745 Str = Str.drop_front(1);
4753 std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks(
bool IsClCompatMode)
const {
4754 unsigned IncludedFlagsBitmask = 0;
4757 if (IsClCompatMode) {
4765 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
4769 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.
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.
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.
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()
llvm::vfs::FileSystem & getVFS() const
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
std::string GetTemporaryDirectory(StringRef Prefix) const
GetTemporaryDirectory - Return the pathname of a temporary directory to use as part of compilation; t...
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.
llvm::opt::InputArgList ParseArgStrings(ArrayRef< const char *> Args, bool IsClCompatMode, bool &ContainsError)
ParseArgStrings - Parse the given list of strings into an ArgList.
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.
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.
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)
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
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 ...
Driver(StringRef ClangExecutable, StringRef TargetTriple, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
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.