45 #include "clang/Config/config.h" 54 #include "llvm/ADT/ArrayRef.h" 55 #include "llvm/ADT/STLExtras.h" 56 #include "llvm/ADT/SmallSet.h" 57 #include "llvm/ADT/StringExtras.h" 58 #include "llvm/ADT/StringSet.h" 59 #include "llvm/ADT/StringSwitch.h" 60 #include "llvm/Option/Arg.h" 61 #include "llvm/Option/ArgList.h" 62 #include "llvm/Option/OptSpecifier.h" 63 #include "llvm/Option/OptTable.h" 64 #include "llvm/Option/Option.h" 65 #include "llvm/Support/CommandLine.h" 66 #include "llvm/Support/ErrorHandling.h" 67 #include "llvm/Support/FileSystem.h" 68 #include "llvm/Support/Path.h" 69 #include "llvm/Support/PrettyStackTrace.h" 70 #include "llvm/Support/Process.h" 71 #include "llvm/Support/Program.h" 72 #include "llvm/Support/TargetRegistry.h" 73 #include "llvm/Support/raw_ostream.h" 74 #include "llvm/Support/StringSaver.h" 83 using namespace clang;
90 Mode(GCCMode), SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
91 LTOMode(
LTOK_None), ClangExecutable(ClangExecutable),
92 SysRoot(DEFAULT_SYSROOT),
93 DriverTitle(
"clang LLVM compiler"), CCPrintOptionsFilename(nullptr),
94 CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr),
95 CCCPrintBindings(
false), CCPrintHeaders(
false), CCLogDiagnostics(
false),
96 CCGenDiagnostics(
false), DefaultTargetTriple(DefaultTargetTriple),
97 CCCGenericGCCName(
""), Saver(Alloc),
98 CheckInputsExist(
true), CCCUsePCH(
true),
99 GenReproducer(
false), SuppressMissingInputWarning(
false) {
105 Name = llvm::sys::path::filename(ClangExecutable);
106 Dir = llvm::sys::path::parent_path(ClangExecutable);
109 #if defined(CLANG_CONFIG_FILE_SYSTEM_DIR) 112 #if defined(CLANG_CONFIG_FILE_USER_DIR) 117 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
119 if (ClangResourceDir !=
"") {
120 llvm::sys::path::append(P, ClangResourceDir);
122 StringRef ClangLibdirSuffix(CLANG_LIBDIR_SUFFIX);
123 P = llvm::sys::path::parent_path(
Dir);
124 llvm::sys::path::append(P, Twine(
"lib") + ClangLibdirSuffix,
"clang",
125 CLANG_VERSION_STRING);
135 for (
const char *ArgPtr : Args) {
137 if (ArgPtr ==
nullptr)
139 const StringRef Arg = ArgPtr;
140 setDriverModeFromOption(Arg);
144 void Driver::setDriverModeFromOption(StringRef Opt) {
145 const std::string OptName =
146 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
147 if (!Opt.startswith(OptName))
149 StringRef
Value = Opt.drop_front(OptName.size());
151 const unsigned M = llvm::StringSwitch<unsigned>(
Value)
152 .Case(
"gcc", GCCMode)
153 .Case(
"g++", GXXMode)
154 .Case(
"cpp", CPPMode)
159 Mode =
static_cast<DriverMode
>(M);
161 Diag(diag::err_drv_unsupported_option_argument) << OptName <<
Value;
165 bool &ContainsError) {
166 llvm::PrettyStackTraceString CrashInfo(
"Command line argument parsing");
167 ContainsError =
false;
169 unsigned IncludedFlagsBitmask;
170 unsigned ExcludedFlagsBitmask;
171 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
172 getIncludeExcludeOptionFlagMasks();
174 unsigned MissingArgIndex, MissingArgCount;
176 getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount,
177 IncludedFlagsBitmask, ExcludedFlagsBitmask);
180 if (MissingArgCount) {
181 Diag(diag::err_drv_missing_argument)
182 << Args.getArgString(MissingArgIndex) << MissingArgCount;
189 for (
const Arg *A : Args) {
191 Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
199 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue(
"")) {
200 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
202 diag::warn_drv_empty_joined_argument,
207 for (
const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {
208 auto ID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl
209 : diag::err_drv_unknown_argument;
211 Diags.
Report(
ID) << A->getAsString(Args);
222 phases::ID Driver::getFinalPhase(
const DerivedArgList &DAL,
223 Arg **FinalPhaseArg)
const {
224 Arg *PhaseArg =
nullptr;
228 if (
CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
229 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
230 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
231 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
235 }
else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
239 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
240 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
241 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
242 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
243 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
244 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
245 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
246 options::OPT__analyze_auto)) ||
247 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
251 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
255 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
263 *FinalPhaseArg = PhaseArg;
270 Arg *A =
new Arg(Opts.getOption(options::OPT_INPUT),
Value,
271 Args.getBaseArgs().MakeIndex(Value), Value.data());
272 Args.AddSynthesizedArg(A);
277 DerivedArgList *Driver::TranslateInputArgs(
const InputArgList &Args)
const {
278 DerivedArgList *DAL =
new DerivedArgList(Args);
280 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
281 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
282 for (Arg *A : Args) {
289 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
290 A->getOption().matches(options::OPT_Xlinker)) &&
291 A->containsValue(
"--no-demangle")) {
293 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
296 for (StringRef Val : A->getValues())
297 if (Val !=
"--no-demangle")
298 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val);
306 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
307 (A->getValue(0) == StringRef(
"-MD") ||
308 A->getValue(0) == StringRef(
"-MMD"))) {
310 if (A->getValue(0) == StringRef(
"-MD"))
311 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
313 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
314 if (A->getNumValues() == 2)
315 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
321 if (A->getOption().matches(options::OPT_l)) {
322 StringRef
Value = A->getValue();
325 if (!HasNostdlib && !HasNodefaultlib && Value ==
"stdc++") {
326 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx));
331 if (Value ==
"cc_kext") {
332 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext));
338 if (A->getOption().matches(options::OPT__DASH_DASH)) {
340 for (StringRef Val : A->getValues())
349 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false))
350 DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
354 #if defined(HOST_LINK_VERSION) 355 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
356 strlen(HOST_LINK_VERSION) > 0) {
357 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
359 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
371 StringRef DefaultTargetTriple,
373 StringRef DarwinArchName =
"") {
375 if (
const Arg *A = Args.getLastArg(options::OPT_target))
376 DefaultTargetTriple = A->getValue();
381 if (Target.isOSBinFormatMachO()) {
383 if (!DarwinArchName.empty()) {
389 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
390 StringRef ArchName = A->getValue();
397 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
398 options::OPT_mbig_endian)) {
399 if (A->getOption().matches(options::OPT_mlittle_endian)) {
400 llvm::Triple LE = Target.getLittleEndianArchVariant();
401 if (LE.getArch() != llvm::Triple::UnknownArch)
402 Target = std::move(LE);
404 llvm::Triple BE = Target.getBigEndianArchVariant();
405 if (BE.getArch() != llvm::Triple::UnknownArch)
406 Target = std::move(BE);
411 if (Target.getArch() == llvm::Triple::tce ||
412 Target.getOS() == llvm::Triple::Minix)
416 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
417 options::OPT_m32, options::OPT_m16);
419 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
421 if (A->getOption().matches(options::OPT_m64)) {
422 AT = Target.get64BitArchVariant().getArch();
423 if (Target.getEnvironment() == llvm::Triple::GNUX32)
424 Target.setEnvironment(llvm::Triple::GNU);
425 }
else if (A->getOption().matches(options::OPT_mx32) &&
426 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
427 AT = llvm::Triple::x86_64;
428 Target.setEnvironment(llvm::Triple::GNUX32);
429 }
else if (A->getOption().matches(options::OPT_m32)) {
430 AT = Target.get32BitArchVariant().getArch();
431 if (Target.getEnvironment() == llvm::Triple::GNUX32)
432 Target.setEnvironment(llvm::Triple::GNU);
433 }
else if (A->getOption().matches(options::OPT_m16) &&
434 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
435 AT = llvm::Triple::x86;
436 Target.setEnvironment(llvm::Triple::CODE16);
439 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
444 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
445 if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
446 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-miamcu" 449 if (A && !A->getOption().matches(options::OPT_m32))
450 D.
Diag(diag::err_drv_argument_not_allowed_with)
451 <<
"-miamcu" << A->getBaseArg().getAsString(Args);
453 Target.setArch(llvm::Triple::x86);
454 Target.setArchName(
"i586");
455 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
456 Target.setEnvironmentName(
"");
457 Target.setOS(llvm::Triple::ELFIAMCU);
458 Target.setVendor(llvm::Triple::UnknownVendor);
459 Target.setVendorName(
"intel");
467 void Driver::setLTOMode(
const llvm::opt::ArgList &Args) {
469 if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ,
470 options::OPT_fno_lto,
false))
473 StringRef LTOName(
"full");
475 const Arg *A = Args.getLastArg(options::OPT_flto_EQ);
477 LTOName = A->getValue();
479 LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
486 Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
493 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
495 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
497 RuntimeName = A->getValue();
499 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
507 Diag(diag::err_drv_unsupported_option_argument)
508 << A->getOption().getName() << A->getValue();
511 Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
524 if (llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
528 const llvm::Triple &HostTriple = HostTC->
getTriple();
529 llvm::Triple CudaTriple(HostTriple.isArch64Bit() ?
"nvptx64-nvidia-cuda" 530 :
"nvptx-nvidia-cuda");
533 auto &CudaTC = ToolChains[CudaTriple.str() +
"/" + HostTriple.str()];
535 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
546 if (Arg *OpenMPTargets =
547 C.
getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
548 if (OpenMPTargets->getNumValues()) {
553 options::OPT_fopenmp, options::OPT_fopenmp_EQ,
554 options::OPT_fno_openmp,
false);
555 if (HasValidOpenMPRuntime) {
557 HasValidOpenMPRuntime =
561 if (HasValidOpenMPRuntime) {
562 llvm::StringMap<const char *> FoundNormalizedTriples;
563 for (
const char *Val : OpenMPTargets->getValues()) {
564 llvm::Triple TT(Val);
565 std::string NormalizedName = TT.normalize();
568 auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
569 if (Duplicate != FoundNormalizedTriples.end()) {
570 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
571 << Val << Duplicate->second;
577 FoundNormalizedTriples[NormalizedName] = Val;
580 if (TT.getArch() == llvm::Triple::UnknownArch)
581 Diag(clang::diag::err_drv_invalid_omp_target) << Val;
589 assert(HostTC &&
"Host toolchain should be always defined.");
591 ToolChains[TT.str() +
"/" + HostTC->
getTriple().normalize()];
593 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
602 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
604 Diag(clang::diag::warn_drv_empty_joined_argument)
625 StringRef FileName) {
627 for (
const StringRef &
Dir : Dirs) {
631 llvm::sys::path::append(WPath,
Dir, FileName);
632 llvm::sys::path::native(WPath);
633 if (llvm::sys::fs::is_regular_file(WPath)) {
634 FilePath = std::move(WPath);
641 bool Driver::readConfigFile(StringRef FileName) {
644 if (!llvm::cl::readConfigFile(FileName, Saver, NewCfgArgs)) {
645 Diag(diag::err_drv_cannot_read_config_file) << FileName;
651 llvm::sys::path::native(CfgFileName);
652 ConfigFile = CfgFileName.str();
654 CfgOptions = llvm::make_unique<InputArgList>(
661 if (CfgOptions->hasArg(options::OPT_config)) {
663 Diag(diag::err_drv_nested_config_file);
669 for (Arg *A : *CfgOptions)
674 bool Driver::loadConfigFile() {
675 std::string CfgFileName;
676 bool FileSpecifiedExplicitly =
false;
680 if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
683 CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
684 if (!CfgDir.empty()) {
685 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
691 if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
694 CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ));
695 if (!CfgDir.empty()) {
696 if (llvm::sys::fs::make_absolute(CfgDir).value() != 0)
706 std::vector<std::string> ConfigFiles =
707 CLOptions->getAllArgValues(options::OPT_config);
708 if (ConfigFiles.size() > 1) {
709 Diag(diag::err_drv_duplicate_config);
713 if (!ConfigFiles.empty()) {
714 CfgFileName = ConfigFiles.front();
715 assert(!CfgFileName.empty());
719 if (llvm::sys::path::has_parent_path(CfgFileName)) {
721 if (llvm::sys::path::is_relative(CfgFileName))
722 llvm::sys::fs::current_path(CfgFilePath);
723 llvm::sys::path::append(CfgFilePath, CfgFileName);
724 if (!llvm::sys::fs::is_regular_file(CfgFilePath)) {
725 Diag(diag::err_drv_config_file_not_exist) << CfgFilePath;
728 return readConfigFile(CfgFilePath);
731 FileSpecifiedExplicitly =
true;
741 if (CfgFileName.empty())
745 StringRef CfgFileArch = CfgFileName;
746 size_t ArchPrefixLen = CfgFileArch.find(
'-');
747 if (ArchPrefixLen == StringRef::npos)
748 ArchPrefixLen = CfgFileArch.size();
749 llvm::Triple CfgTriple;
750 CfgFileArch = CfgFileArch.take_front(ArchPrefixLen);
752 if (CfgTriple.getArch() == llvm::Triple::ArchType::UnknownArch)
755 if (!StringRef(CfgFileName).endswith(
".cfg"))
756 CfgFileName +=
".cfg";
762 size_t FixedArchPrefixLen = 0;
768 CfgTriple.getTriple(), *CLOptions);
769 if (CfgTriple.getArch() != EffectiveTriple.getArch()) {
770 FixedConfigFile = EffectiveTriple.getArchName();
771 FixedArchPrefixLen = FixedConfigFile.size();
774 if (ArchPrefixLen < CfgFileName.size())
775 FixedConfigFile += CfgFileName.substr(ArchPrefixLen);
783 CfgFileSearchDirs.push_back(
Dir);
787 if (!FixedConfigFile.empty()) {
788 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
789 return readConfigFile(CfgFilePath);
791 FixedConfigFile.resize(FixedArchPrefixLen);
792 FixedConfigFile.append(
".cfg");
793 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile))
794 return readConfigFile(CfgFilePath);
798 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
799 return readConfigFile(CfgFilePath);
805 CfgFileName.append(
".cfg");
806 if (
searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName))
807 return readConfigFile(CfgFilePath);
812 if (FileSpecifiedExplicitly) {
813 Diag(diag::err_drv_config_file_not_found) << CfgFileName;
814 for (
const std::string &SearchDir : CfgFileSearchDirs)
815 if (!SearchDir.empty())
816 Diag(diag::note_drv_config_file_searched_in) << SearchDir;
824 llvm::PrettyStackTraceString CrashInfo(
"Compilation construction");
830 llvm::sys::Process::GetEnv(
"COMPILER_PATH")) {
831 StringRef CompilerPath = *CompilerPathValue;
832 while (!CompilerPath.empty()) {
833 std::pair<StringRef, StringRef> Split =
834 CompilerPath.split(llvm::sys::EnvPathSeparator);
836 CompilerPath = Split.second;
848 CLOptions = llvm::make_unique<InputArgList>(
853 ContainsError = loadConfigFile();
854 bool HasConfigFile = !ContainsError && (CfgOptions.get() !=
nullptr);
857 InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
858 : std::move(*CLOptions));
860 for (
auto *Opt : *CLOptions) {
861 const Arg *BaseArg = &Opt->getBaseArg();
864 Arg *Copy =
new llvm::opt::Arg(Opt->getOption(), Opt->getSpelling(),
865 Args.size(), BaseArg);
866 Copy->getValues() = Opt->getValues();
867 if (Opt->isClaimed())
879 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
882 Args.ClaimAllArgs(options::OPT_pipe);
890 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
892 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
893 CCCGenericGCCName = A->getValue();
895 Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth);
897 options::OPT_fno_crash_diagnostics,
898 !!::getenv(
"FORCE_CLANG_DIAGNOSTICS_CRASH"));
903 llvm::Triple
T(DefaultTargetTriple);
904 T.setOS(llvm::Triple::Win32);
905 T.setVendor(llvm::Triple::PC);
906 T.setEnvironment(llvm::Triple::MSVC);
907 T.setObjectFormat(llvm::Triple::COFF);
908 DefaultTargetTriple = T.str();
910 if (
const Arg *A = Args.getLastArg(options::OPT_target))
911 DefaultTargetTriple = A->getValue();
912 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
914 for (
const Arg *A : Args.filtered(options::OPT_B)) {
918 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
920 if (
const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
923 if (
const Arg *A = Args.getLastArg(options::OPT_resource_dir))
926 if (
const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
927 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
928 .Case(
"cwd", SaveTempsCwd)
929 .Case(
"obj", SaveTempsObj)
930 .Default(SaveTempsCwd);
936 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
937 StringRef
Name = A->getValue();
938 unsigned Model = llvm::StringSwitch<unsigned>(
Name)
939 .Case(
"off", EmbedNone)
940 .Case(
"all", EmbedBitcode)
941 .Case(
"bitcode", EmbedBitcode)
942 .Case(
"marker", EmbedMarker)
945 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
948 BitcodeEmbed =
static_cast<BitcodeEmbedMode
>(Model);
951 std::unique_ptr<llvm::opt::InputArgList> UArgs =
952 llvm::make_unique<InputArgList>(std::move(Args));
955 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
982 if (CCCPrintPhases) {
992 static void printArgList(raw_ostream &OS,
const llvm::opt::ArgList &Args) {
993 llvm::opt::ArgStringList ASL;
994 for (
const auto *A : Args)
995 A->render(Args, ASL);
997 for (
auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
998 if (I != ASL.begin())
1005 bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename,
1008 assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&
1009 "Only knows about .crash files on Darwin");
1014 path::home_directory(CrashDiagDir);
1015 if (CrashDiagDir.startswith(
"/var/root"))
1017 path::append(CrashDiagDir,
"Library/Logs/DiagnosticReports");
1025 fs::file_status FileStatus;
1026 TimePoint<> LastAccessTime;
1030 for (fs::directory_iterator File(CrashDiagDir, EC), FileEnd;
1031 File != FileEnd && !EC; File.increment(EC)) {
1032 StringRef FileName = path::filename(File->path());
1033 if (!FileName.startswith(
Name))
1035 if (fs::status(File->path(), FileStatus))
1037 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
1038 llvm::MemoryBuffer::getFile(File->path());
1043 StringRef Data = CrashFile.get()->getBuffer();
1044 if (!Data.startswith(
"Process:"))
1047 size_t ParentProcPos = Data.find(
"Parent Process:");
1048 if (ParentProcPos == StringRef::npos)
1050 size_t LineEnd = Data.find_first_of(
"\n", ParentProcPos);
1051 if (LineEnd == StringRef::npos)
1053 StringRef ParentProcess = Data.slice(ParentProcPos+15, LineEnd).trim();
1054 int OpenBracket = -1, CloseBracket = -1;
1055 for (
size_t i = 0, e = ParentProcess.size(); i < e; ++i) {
1056 if (ParentProcess[i] ==
'[')
1058 if (ParentProcess[i] ==
']')
1064 if (OpenBracket < 0 || CloseBracket < 0 ||
1065 ParentProcess.slice(OpenBracket + 1, CloseBracket)
1066 .getAsInteger(10, CrashPID) || CrashPID != PID) {
1076 const auto FileAccessTime = FileStatus.getLastModificationTime();
1077 if (FileAccessTime > LastAccessTime) {
1078 CrashFilePath.assign(File->path());
1079 LastAccessTime = FileAccessTime;
1084 if (!CrashFilePath.empty()) {
1085 EC = fs::copy_file(CrashFilePath, ReproCrashFilename);
1098 const Command &FailingCommand) {
1099 if (C.
getArgs().hasArg(options::OPT_fno_crash_diagnostics))
1110 Diag(clang::diag::note_drv_command_failed_diag_msg)
1111 <<
"PLEASE submit a bug report to " BUG_REPORT_URL
" and include the " 1112 "crash backtrace, preprocessed source, and associated run script.";
1132 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
1133 bool IgnoreInput =
false;
1139 }
else if (!strcmp(it->second->getValue(),
"-")) {
1140 Diag(clang::diag::note_drv_command_failed_diag_msg)
1141 <<
"Error generating preprocessed source(s) - " 1142 "ignoring input from stdin.";
1147 it = Inputs.erase(it);
1154 if (Inputs.empty()) {
1155 Diag(clang::diag::note_drv_command_failed_diag_msg)
1156 <<
"Error generating preprocessed source(s) - " 1157 "no preprocessable inputs.";
1163 llvm::StringSet<> ArchNames;
1164 for (
const Arg *A : C.
getArgs()) {
1165 if (A->getOption().matches(options::OPT_arch)) {
1166 StringRef ArchName = A->getValue();
1167 ArchNames.insert(ArchName);
1170 if (ArchNames.size() > 1) {
1171 Diag(clang::diag::note_drv_command_failed_diag_msg)
1172 <<
"Error generating preprocessed source(s) - cannot generate " 1173 "preprocessed source with multiple -arch options.";
1180 if (TC.
getTriple().isOSBinFormatMachO())
1189 Diag(clang::diag::note_drv_command_failed_diag_msg)
1190 <<
"Error generating preprocessed source(s).";
1199 if (!FailingCommands.empty()) {
1203 Diag(clang::diag::note_drv_command_failed_diag_msg)
1204 <<
"Error generating preprocessed source(s).";
1209 if (TempFiles.empty()) {
1210 Diag(clang::diag::note_drv_command_failed_diag_msg)
1211 <<
"Error generating preprocessed source(s).";
1215 Diag(clang::diag::note_drv_command_failed_diag_msg)
1216 <<
"\n********************\n\n" 1217 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" 1218 "Preprocessed source(s) and associated run script(s) are located at:";
1222 for (
const char *TempFile : TempFiles) {
1223 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
1224 if (ReproCrashFilename.empty()) {
1225 ReproCrashFilename = TempFile;
1226 llvm::sys::path::replace_extension(ReproCrashFilename,
".crash");
1228 if (StringRef(TempFile).endswith(
".cache")) {
1231 VFS = llvm::sys::path::filename(TempFile);
1232 llvm::sys::path::append(VFS,
"vfs",
"vfs.yaml");
1239 std::string Script = CrashInfo.
Filename.rsplit(
'.').first.str() +
".sh";
1241 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::F_Excl);
1243 Diag(clang::diag::note_drv_command_failed_diag_msg)
1244 <<
"Error generating run script: " + Script +
" " + EC.message();
1247 <<
"# Driver args: ";
1249 ScriptOS <<
"# Original command: ";
1250 Cmd.
Print(ScriptOS,
"\n",
true);
1251 Cmd.
Print(ScriptOS,
"\n",
true, &CrashInfo);
1252 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
1256 if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) {
1258 if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) {
1259 Diag(clang::diag::note_drv_command_failed_diag_msg)
1260 << ReproCrashFilename.str();
1262 llvm::sys::path::append(CrashDiagDir,
Name);
1263 CrashDiagDir +=
"_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
1264 Diag(clang::diag::note_drv_command_failed_diag_msg)
1265 <<
"Crash backtrace is located in";
1266 Diag(clang::diag::note_drv_command_failed_diag_msg)
1267 << CrashDiagDir.str();
1268 Diag(clang::diag::note_drv_command_failed_diag_msg)
1269 <<
"(choose the .crash file that corresponds to your crash)";
1273 for (
const auto &A : C.
getArgs().filtered(options::OPT_frewrite_map_file,
1274 options::OPT_frewrite_map_file_EQ))
1275 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
1277 Diag(clang::diag::note_drv_command_failed_diag_msg)
1278 <<
"\n\n********************";
1297 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1303 if (Diags.hasErrorOccurred())
1308 setUpResponseFiles(C, Job);
1316 if (FailingCommands.empty())
1321 for (
const auto &CmdPair : FailingCommands) {
1322 int Res = CmdPair.first;
1323 const Command *FailingCommand = CmdPair.second;
1347 Diag(clang::diag::err_drv_command_signalled)
1358 unsigned IncludedFlagsBitmask;
1359 unsigned ExcludedFlagsBitmask;
1360 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
1361 getIncludeExcludeOptionFlagMasks();
1365 ExcludedFlagsBitmask |= HelpHidden;
1368 IncludedFlagsBitmask, ExcludedFlagsBitmask,
1380 if (Arg *A = C.
getArgs().getLastArg(options::OPT_mthread_model)) {
1383 OS <<
"Thread model: " << A->getValue();
1392 if (!ConfigFile.empty())
1393 OS <<
"Configuration file: " << ConfigFile <<
'\n';
1408 std::vector<std::string> SuggestedCompletions;
1410 unsigned short DisableFlags =
1416 if (PassedFlags.size() > 0 && PassedFlags[0] ==
'#') {
1418 PassedFlags = PassedFlags.substr(1);
1421 if (PassedFlags.find(
',') == StringRef::npos) {
1425 SuggestedCompletions = Opts->findByPrefix(PassedFlags, DisableFlags);
1431 if (S.startswith(PassedFlags))
1432 SuggestedCompletions.push_back(S);
1438 StringRef Option, Arg;
1439 std::tie(Option, Arg) = PassedFlags.split(
',');
1440 SuggestedCompletions = Opts->suggestValueCompletions(Option, Arg);
1447 std::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(),
1448 [](StringRef A, StringRef B) {
1449 if (
int X = A.compare_lower(B))
1451 return A.compare(B) > 0;
1454 llvm::outs() << llvm::join(SuggestedCompletions,
"\n") <<
'\n';
1461 if (C.
getArgs().hasArg(options::OPT_dumpmachine)) {
1466 if (C.
getArgs().hasArg(options::OPT_dumpversion)) {
1473 llvm::outs() <<
"4.2.1\n";
1477 if (C.
getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
1482 if (C.
getArgs().hasArg(options::OPT_help) ||
1483 C.
getArgs().hasArg(options::OPT__help_hidden)) {
1488 if (C.
getArgs().hasArg(options::OPT__version)) {
1494 if (C.
getArgs().hasArg(options::OPT_v) ||
1495 C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1497 SuppressMissingInputWarning =
true;
1500 if (C.
getArgs().hasArg(options::OPT_v)) {
1502 llvm::errs() <<
"System configuration file directory: " 1505 llvm::errs() <<
"User configuration file directory: " 1511 if (C.
getArgs().hasArg(options::OPT_v))
1514 if (C.
getArgs().hasArg(options::OPT_print_resource_dir)) {
1519 if (C.
getArgs().hasArg(options::OPT_print_search_dirs)) {
1520 llvm::outs() <<
"programs: =";
1521 bool separator =
false;
1524 llvm::outs() <<
':';
1525 llvm::outs() << Path;
1528 llvm::outs() <<
"\n";
1535 llvm::outs() <<
':';
1538 llvm::outs() << sysroot << Path.substr(1);
1540 llvm::outs() << Path;
1542 llvm::outs() <<
"\n";
1548 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
1549 llvm::outs() <<
GetFilePath(A->getValue(), TC) <<
"\n";
1553 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
1558 if (Arg *A = C.
getArgs().getLastArg(options::OPT_autocomplete)) {
1559 StringRef PassedFlags = A->getValue();
1564 if (C.
getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
1573 llvm::outs() <<
GetFilePath(
"libgcc.a", TC) <<
"\n";
1579 if (C.
getArgs().hasArg(options::OPT_print_multi_lib)) {
1585 if (C.
getArgs().hasArg(options::OPT_print_multi_directory)) {
1588 llvm::outs() <<
".\n";
1591 assert(Suffix.front() ==
'/');
1592 llvm::outs() << Suffix.substr(1) <<
"\n";
1604 std::map<Action *, unsigned> &Ids) {
1609 llvm::raw_string_ostream os(str);
1613 os <<
"\"" << IA->getInputArg().getValue() <<
"\"";
1615 os <<
'"' << BIA->getArchName() <<
'"' <<
", {" 1617 }
else if (
OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1618 bool IsFirst =
true;
1619 OA->doOnEachDependence(
1636 os <<
":" << BoundArch;
1646 const char *Prefix =
"{";
1647 for (
Action *PreRequisite : *AL) {
1658 std::string offload_str;
1659 llvm::raw_string_ostream offload_os(offload_str);
1660 if (!isa<OffloadAction>(A)) {
1663 offload_os <<
", (" << S;
1670 unsigned Id = Ids.size();
1672 llvm::errs() << Id <<
": " << os.str() <<
", " 1681 std::map<Action *, unsigned> Ids;
1689 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
1690 isa<AssembleJobAction>(A))
1702 DerivedArgList &Args = C.
getArgs();
1704 llvm::PrettyStackTraceString CrashInfo(
"Building universal build actions");
1707 llvm::StringSet<> ArchNames;
1709 for (Arg *A : Args) {
1710 if (A->getOption().matches(options::OPT_arch)) {
1713 llvm::Triple::ArchType Arch =
1715 if (Arch == llvm::Triple::UnknownArch) {
1716 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
1721 if (ArchNames.insert(A->getValue()).second)
1722 Archs.push_back(A->getValue());
1736 for (
Action* Act : SingleActions) {
1744 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
1748 for (
unsigned i = 0, e = Archs.size(); i != e; ++i)
1753 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1754 Actions.append(Inputs.begin(), Inputs.end());
1759 Arg *A = Args.getLastArg(options::OPT_g_Group);
1760 if (A && !A->getOption().matches(options::OPT_g0) &&
1761 !A->getOption().matches(options::OPT_gstabs) &&
1768 if (Act->getType() == types::TY_Image) {
1770 Inputs.push_back(Actions.back());
1777 if (Args.hasArg(options::OPT_verify_debug_info)) {
1778 Action* LastAction = Actions.back();
1781 LastAction, types::TY_Nothing));
1799 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
1800 if (!llvm::sys::path::is_absolute(Path)) {
1802 llvm::sys::path::append(Directory, Value);
1803 Path.assign(Directory);
1807 if (llvm::sys::fs::exists(Twine(Path)))
1811 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1812 llvm::sys::Process::FindInEnvPath(
"LIB", Value))
1815 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1823 D.
Diag(clang::diag::err_drv_no_such_file) << Path;
1833 types::ID InputType = types::TY_Nothing;
1834 Arg *InputTypeArg =
nullptr;
1837 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1838 options::OPT__SLASH_TP)) {
1839 InputTypeArg = TCTP;
1840 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
1845 bool ShowNote =
false;
1846 for (Arg *A : Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) {
1848 Diag(clang::diag::warn_drv_overriding_flag_option)
1849 << Previous->getSpelling() << A->getSpelling();
1855 Diag(clang::diag::note_drv_t_option_is_global);
1858 assert(!Args.hasArg(options::OPT_x) &&
"-x and /TC or /TP is not allowed");
1861 for (Arg *A : Args) {
1862 if (A->getOption().getKind() == Option::InputClass) {
1863 const char *
Value = A->getValue();
1867 if (InputType == types::TY_Nothing) {
1870 InputTypeArg->claim();
1873 if (memcmp(Value,
"-", 2) == 0) {
1879 if (!Args.hasArgNoClaim(options::OPT_E) && !
CCCIsCPP())
1880 Diag(
IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1881 : clang::diag::err_drv_unknown_stdin_type);
1888 if (
const char *Ext = strrchr(Value,
'.'))
1895 Ty = types::TY_Object;
1905 Diag(clang::diag::warn_drv_treating_input_as_cxx)
1915 if (Ty != types::TY_Object) {
1916 if (Args.hasArg(options::OPT_ObjC))
1917 Ty = types::TY_ObjC;
1918 else if (Args.hasArg(options::OPT_ObjCXX))
1919 Ty = types::TY_ObjCXX;
1922 assert(InputTypeArg &&
"InputType set w/o InputTypeArg");
1923 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
1926 const char *Ext = strrchr(Value,
'.');
1928 Ty = types::TY_Object;
1932 InputTypeArg->claim();
1937 Inputs.push_back(std::make_pair(Ty, A));
1939 }
else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1940 StringRef
Value = A->getValue();
1942 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
1943 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1946 }
else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1947 StringRef
Value = A->getValue();
1949 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
1950 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1956 Inputs.push_back(std::make_pair(types::TY_Object, A));
1958 }
else if (A->getOption().matches(options::OPT_x)) {
1967 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
1968 InputType = types::TY_Object;
1970 }
else if (A->getOption().getID() == options::OPT__SLASH_U) {
1971 assert(A->getNumValues() == 1 &&
"The /U option has one value.");
1972 StringRef Val = A->getValue(0);
1973 if (Val.find_first_of(
"/\\") != StringRef::npos) {
1975 Diag(diag::warn_slash_u_filename) << Val;
1976 Diag(diag::note_use_dashdash);
1980 if (
CCCIsCPP() && Inputs.empty()) {
1984 Inputs.push_back(std::make_pair(types::TY_C, A));
1991 class OffloadingActionBuilder final {
1993 bool IsValid =
false;
1999 std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
2002 class DeviceActionBuilder {
2006 enum ActionBuilderReturnCode {
2025 DerivedArgList &Args;
2034 DeviceActionBuilder(
Compilation &C, DerivedArgList &Args,
2037 : C(C), Args(Args), Inputs(Inputs),
2038 AssociatedOffloadKind(AssociatedOffloadKind) {}
2039 virtual ~DeviceActionBuilder() {}
2044 virtual ActionBuilderReturnCode
2048 return ABRT_Inactive;
2053 virtual ActionBuilderReturnCode addDeviceDepences(
Action *HostAction) {
2054 return ABRT_Inactive;
2059 virtual void appendTopLevelActions(
ActionList &AL) {}
2067 virtual bool initialize() {
return false; }
2070 virtual bool canUseBundlerUnbundler()
const {
return false; }
2074 bool isValid() {
return !ToolChains.empty(); }
2078 return AssociatedOffloadKind;
2084 class CudaActionBuilder final :
public DeviceActionBuilder {
2087 bool CompileHostOnly =
false;
2088 bool CompileDeviceOnly =
false;
2097 Action *CudaFatBinary =
nullptr;
2100 bool IsActive =
false;
2103 CudaActionBuilder(
Compilation &C, DerivedArgList &Args,
2107 ActionBuilderReturnCode
2110 PhasesTy &Phases)
override {
2112 return ABRT_Inactive;
2116 if (CudaDeviceActions.empty())
2117 return ABRT_Success;
2119 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2120 "Expecting one action per GPU architecture.");
2121 assert(!CompileHostOnly &&
2122 "Not expecting CUDA actions in host-only compilation.");
2132 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
2135 for (
auto Ph : Phases) {
2140 if (Ph > FinalPhase)
2144 C, Args, Ph, CudaDeviceActions[I]);
2153 if (!isa<AssembleJobAction>(CudaDeviceActions[I]) ||
2157 Action *AssembleAction = CudaDeviceActions[I];
2158 assert(AssembleAction->
getType() == types::TY_Object);
2159 assert(AssembleAction->
getInputs().size() == 1);
2162 assert(BackendAction->getType() == types::TY_PP_Asm);
2164 for (
auto &A : {AssembleAction, BackendAction}) {
2168 DeviceActions.push_back(
2174 if (!DeviceActions.empty()) {
2178 if (!CompileDeviceOnly) {
2179 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
2183 CudaFatBinary =
nullptr;
2188 CudaDeviceActions.clear();
2192 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
2197 return ABRT_Success;
2201 "instructions should only occur " 2202 "before the backend phase!");
2205 for (
Action *&A : CudaDeviceActions)
2208 return ABRT_Success;
2211 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2218 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2219 assert(!GpuArchList.empty() &&
2220 "We should have at least one GPU architecture.");
2224 if (IA->getType() != types::TY_CUDA) {
2227 return ABRT_Inactive;
2233 if (CompileHostOnly)
2234 return ABRT_Success;
2237 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
2239 IA->getInputArg(), types::TY_CUDA_DEVICE));
2241 return ABRT_Success;
2244 return IsActive ? ABRT_Success : ABRT_Inactive;
2247 void appendTopLevelActions(
ActionList &AL)
override {
2257 if (CudaFatBinary) {
2259 CudaDeviceActions.clear();
2260 CudaFatBinary =
nullptr;
2264 if (CudaDeviceActions.empty())
2270 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2271 "Expecting one action per GPU architecture.");
2272 assert(ToolChains.size() == 1 &&
2273 "Expecting to have a sing CUDA toolchain.");
2274 for (
unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
2275 AddTopLevel(CudaDeviceActions[I], GpuArchList[I]);
2277 CudaDeviceActions.clear();
2280 bool initialize()
override {
2286 assert(HostTC &&
"No toolchain for host compilation.");
2297 Arg *PartialCompilationArg = Args.getLastArg(
2298 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
2299 options::OPT_cuda_compile_host_device);
2300 CompileHostOnly = PartialCompilationArg &&
2301 PartialCompilationArg->getOption().matches(
2302 options::OPT_cuda_host_only);
2303 CompileDeviceOnly = PartialCompilationArg &&
2304 PartialCompilationArg->getOption().matches(
2305 options::OPT_cuda_device_only);
2308 std::set<CudaArch> GpuArchs;
2310 for (Arg *A : Args) {
2311 if (!(A->getOption().matches(options::OPT_cuda_gpu_arch_EQ) ||
2312 A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ)))
2316 const StringRef ArchStr = A->getValue();
2317 if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ) &&
2324 C.
getDriver().
Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
2326 }
else if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
2327 GpuArchs.insert(Arch);
2328 else if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ))
2329 GpuArchs.erase(Arch);
2331 llvm_unreachable(
"Unexpected option.");
2336 GpuArchList.push_back(Arch);
2341 if (GpuArchList.empty())
2350 class OpenMPActionBuilder final :
public DeviceActionBuilder {
2358 OpenMPActionBuilder(
Compilation &C, DerivedArgList &Args,
2362 ActionBuilderReturnCode
2365 PhasesTy &Phases)
override {
2368 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2369 "Number of OpenMP actions and toolchains do not match.");
2374 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2375 "Toolchains and linker inputs sizes do not match.");
2376 auto LI = DeviceLinkerInputs.begin();
2377 for (
auto *A : OpenMPDeviceActions) {
2384 OpenMPDeviceActions.clear();
2385 return ABRT_Success;
2389 for (
Action *&A : OpenMPDeviceActions)
2392 return ABRT_Success;
2395 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2398 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2399 OpenMPDeviceActions.clear();
2400 for (
unsigned I = 0; I < ToolChains.size(); ++I)
2401 OpenMPDeviceActions.push_back(
2403 return ABRT_Success;
2407 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2408 OpenMPDeviceActions.clear();
2409 for (
unsigned I = 0; I < ToolChains.size(); ++I) {
2410 OpenMPDeviceActions.push_back(UA);
2411 UA->registerDependentActionInfo(
2414 return ABRT_Success;
2421 if (isa<CompileJobAction>(HostAction)) {
2423 assert(ToolChains.size() == OpenMPDeviceActions.size() &&
2424 "Toolchains and device action sizes do not match.");
2428 auto TC = ToolChains.begin();
2429 for (
Action *&A : OpenMPDeviceActions) {
2430 assert(isa<CompileJobAction>(A));
2437 return ABRT_Success;
2440 void appendTopLevelActions(
ActionList &AL)
override {
2441 if (OpenMPDeviceActions.empty())
2445 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2446 "Number of OpenMP actions and toolchains do not match.");
2449 auto TI = ToolChains.begin();
2450 for (
auto *A : OpenMPDeviceActions) {
2457 OpenMPDeviceActions.clear();
2461 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2462 "Toolchains and linker inputs sizes do not match.");
2465 auto TC = ToolChains.begin();
2466 for (
auto &LI : DeviceLinkerInputs) {
2467 auto *DeviceLinkAction =
2469 DA.
add(*DeviceLinkAction, **TC,
nullptr,
2475 bool initialize()
override {
2479 for (
auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE;
2481 ToolChains.push_back(TI->second);
2483 DeviceLinkerInputs.resize(ToolChains.size());
2487 bool canUseBundlerUnbundler()
const override {
2504 OffloadingActionBuilder(
Compilation &C, DerivedArgList &Args,
2512 SpecializedBuilders.push_back(
new CudaActionBuilder(C, Args, Inputs));
2515 SpecializedBuilders.push_back(
new OpenMPActionBuilder(C, Args, Inputs));
2523 unsigned ValidBuilders = 0u;
2524 unsigned ValidBuildersSupportingBundling = 0u;
2525 for (
auto *SB : SpecializedBuilders) {
2526 IsValid = IsValid && !SB->initialize();
2529 if (SB->isValid()) {
2531 if (SB->canUseBundlerUnbundler())
2532 ++ValidBuildersSupportingBundling;
2536 ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling;
2539 ~OffloadingActionBuilder() {
2540 for (
auto *SB : SpecializedBuilders)
2549 addDeviceDependencesToHostAction(
Action *HostAction,
const Arg *InputArg,
2551 DeviceActionBuilder::PhasesTy &Phases) {
2555 if (SpecializedBuilders.empty())
2558 assert(HostAction &&
"Invalid host action!");
2563 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2564 unsigned InactiveBuilders = 0u;
2565 unsigned IgnoringBuilders = 0u;
2566 for (
auto *SB : SpecializedBuilders) {
2567 if (!SB->isValid()) {
2573 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
2578 if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host)
2583 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2584 OffloadKind |= SB->getAssociatedOffloadKind();
2589 if (IgnoringBuilders &&
2590 SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders))
2607 bool addHostDependenceToDeviceActions(
Action *&HostAction,
2608 const Arg *InputArg) {
2618 if (CanUseBundler && isa<InputAction>(HostAction) &&
2619 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
2621 auto UnbundlingHostAction =
2626 HostAction = UnbundlingHostAction;
2629 assert(HostAction &&
"Invalid host action!");
2632 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2633 for (
auto *SB : SpecializedBuilders) {
2637 auto RetCode = SB->addDeviceDepences(HostAction);
2641 assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&
2642 "Host dependence not expected to be ignored.!");
2646 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2647 OffloadKind |= SB->getAssociatedOffloadKind();
2657 const Arg *InputArg) {
2660 for (
auto *SB : SpecializedBuilders) {
2663 SB->appendTopLevelActions(OffloadAL);
2668 if (CanUseBundler && !OffloadAL.empty()) {
2670 OffloadAL.push_back(HostAction);
2674 assert(HostAction == AL.back() &&
"Host action not in the list??");
2676 AL.back() = HostAction;
2678 AL.append(OffloadAL.begin(), OffloadAL.end());
2695 for (
auto *SB : SpecializedBuilders) {
2699 SB->appendLinkDependences(DDeps);
2703 unsigned ActiveOffloadKinds = 0u;
2704 for (
auto &I : InputArgToOffloadKindMap)
2705 ActiveOffloadKinds |= I.second;
2722 nullptr, ActiveOffloadKinds);
2730 llvm::PrettyStackTraceString CrashInfo(
"Building compilation actions");
2732 if (!SuppressMissingInputWarning && Inputs.empty()) {
2733 Diag(clang::diag::err_drv_no_input_files);
2738 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
2741 if (Args.hasArg(options::OPT_emit_llvm))
2742 Diag(clang::diag::err_drv_emit_llvm_link);
2744 !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower(
"lld"))
2745 Diag(clang::diag::err_drv_lto_without_lld);
2750 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
2751 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
2754 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
2755 StringRef V = A->getValue();
2756 if (Inputs.size() > 1 && !V.empty() &&
2757 !llvm::sys::path::is_separator(V.back())) {
2759 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
2760 << A->getSpelling() << V;
2761 Args.eraseArg(options::OPT__SLASH_Fo);
2766 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
2767 StringRef V = A->getValue();
2768 if (Inputs.size() > 1 && !V.empty() &&
2769 !llvm::sys::path::is_separator(V.back())) {
2771 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
2772 << A->getSpelling() << V;
2773 Args.eraseArg(options::OPT__SLASH_Fa);
2778 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
2779 if (A->getValue()[0] ==
'\0') {
2781 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
2782 Args.eraseArg(options::OPT__SLASH_o);
2790 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
2791 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
2792 if (YcArg && YcArg->getValue()[0] ==
'\0') {
2793 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YcArg->getSpelling();
2794 Args.eraseArg(options::OPT__SLASH_Yc);
2797 if (YuArg && YuArg->getValue()[0] ==
'\0') {
2798 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
2799 Args.eraseArg(options::OPT__SLASH_Yu);
2802 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
2803 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
2804 Args.eraseArg(options::OPT__SLASH_Yc);
2805 Args.eraseArg(options::OPT__SLASH_Yu);
2806 YcArg = YuArg =
nullptr;
2808 if (YcArg || YuArg) {
2809 StringRef Val = YcArg ? YcArg->getValue() : YuArg->getValue();
2810 bool FoundMatchingInclude =
false;
2811 for (
const Arg *Inc : Args.filtered(options::OPT_include)) {
2813 if (Inc->getValue() == Val)
2814 FoundMatchingInclude =
true;
2816 if (!FoundMatchingInclude) {
2817 Diag(clang::diag::warn_drv_ycyu_no_fi_arg_clang_cl)
2818 << (YcArg ? YcArg : YuArg)->getSpelling();
2819 Args.eraseArg(options::OPT__SLASH_Yc);
2820 Args.eraseArg(options::OPT__SLASH_Yu);
2821 YcArg = YuArg =
nullptr;
2824 if (YcArg && Inputs.size() > 1) {
2825 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
2826 Args.eraseArg(options::OPT__SLASH_Yc);
2829 if (Args.hasArg(options::OPT__SLASH_Y_)) {
2832 Args.eraseArg(options::OPT__SLASH_Fp);
2833 Args.eraseArg(options::OPT__SLASH_Yc);
2834 Args.eraseArg(options::OPT__SLASH_Yu);
2835 YcArg = YuArg =
nullptr;
2839 OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
2845 for (
auto &I : Inputs) {
2847 const Arg *InputArg = I.second;
2855 if (InitialPhase > FinalPhase) {
2860 if (Args.hasArg(options::OPT_Qunused_arguments))
2866 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
2867 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase);
2873 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
2874 << InputArg->getAsString(Args) << !!FinalPhaseArg
2875 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
2877 Diag(clang::diag::warn_drv_input_file_unused)
2878 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase)
2880 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
2890 Arg *PchInputArg =
MakeInputArg(Args, *Opts, YcArg->getValue());
2898 Actions.push_back(ClangClPch);
2910 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
2918 if (Phase > FinalPhase)
2922 Current = OffloadBuilder.addDeviceDependencesToHostAction(
2923 Current, InputArg, Phase, FinalPhase, PL);
2929 assert((i + 1) == e &&
"linking must be final compilation step.");
2930 LinkerInputs.push_back(Current);
2939 if (NewCurrent == Current)
2942 Current = NewCurrent;
2946 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
2949 if (Current->
getType() == types::TY_Nothing)
2955 Actions.push_back(Current);
2958 OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg);
2962 if (!LinkerInputs.empty()) {
2964 LA = OffloadBuilder.processHostLinkAction(LA);
2965 Actions.push_back(LA);
2971 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
2972 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
2976 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
2980 Args.ClaimAllArgs(options::OPT_cuda_host_only);
2981 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
2986 llvm::PrettyStackTraceString CrashInfo(
"Constructing phase actions");
2997 llvm_unreachable(
"link action invalid here.");
3001 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
3002 OutputTy = types::TY_Dependencies;
3005 if (!Args.hasFlag(options::OPT_frewrite_includes,
3006 options::OPT_fno_rewrite_includes,
false) &&
3007 !Args.hasFlag(options::OPT_frewrite_imports,
3008 options::OPT_fno_rewrite_imports,
false) &&
3012 "Cannot preprocess this input type!");
3019 "Cannot precompile this input type!");
3020 if (Args.hasArg(options::OPT_fsyntax_only)) {
3022 OutputTy = types::TY_Nothing;
3027 if (Args.hasArg(options::OPT_fsyntax_only))
3029 if (Args.hasArg(options::OPT_rewrite_objc))
3031 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
3033 types::TY_RewrittenLegacyObjC);
3034 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
3036 if (Args.hasArg(options::OPT__migrate))
3038 if (Args.hasArg(options::OPT_emit_ast))
3040 if (Args.hasArg(options::OPT_module_file_info))
3042 if (Args.hasArg(options::OPT_verify_pch))
3049 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
3052 if (Args.hasArg(options::OPT_emit_llvm)) {
3054 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
3063 llvm_unreachable(
"invalid phase in ConstructPhaseAction");
3067 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3069 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
3074 unsigned NumOutputs = 0;
3076 if (A->getType() != types::TY_Nothing)
3079 if (NumOutputs > 1) {
3080 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
3081 FinalOutput =
nullptr;
3086 llvm::StringSet<> ArchNames;
3088 for (
const Arg *A : C.
getArgs())
3089 if (A->getOption().matches(options::OPT_arch))
3090 ArchNames.insert(A->getValue());
3093 std::map<std::pair<const Action *, std::string>,
InputInfo> CachedResults;
3101 const char *LinkingOutput =
nullptr;
3102 if (isa<LipoJobAction>(A)) {
3104 LinkingOutput = FinalOutput->getValue();
3112 ArchNames.size() > 1,
3113 LinkingOutput, CachedResults,
3119 if (Diags.hasErrorOccurred() ||
3120 C.
getArgs().hasArg(options::OPT_Qunused_arguments))
3124 (void)C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH);
3127 (void)C.
getArgs().hasArg(options::OPT_driver_mode);
3128 (void)C.
getArgs().hasArg(options::OPT_rsp_quoting);
3134 if (!A->isClaimed()) {
3140 const Option &Opt = A->getOption();
3141 if (Opt.getKind() == Option::FlagClass) {
3142 bool DuplicateClaimed =
false;
3144 for (
const Arg *AA : C.
getArgs().filtered(&Opt)) {
3145 if (AA->isClaimed()) {
3146 DuplicateClaimed =
true;
3151 if (DuplicateClaimed)
3157 if (!
IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
3158 Diag(clang::diag::warn_drv_unused_argument)
3159 << A->getAsString(C.
getArgs());
3167 class ToolSelector final {
3178 bool IsHostSelector;
3189 bool CanBeCollapsed =
true) {
3191 if (Inputs.size() != 1)
3194 Action *CurAction = *Inputs.begin();
3195 if (CanBeCollapsed &&
3201 if (
auto *OA = dyn_cast<OffloadAction>(CurAction)) {
3205 if (!IsHostSelector) {
3206 if (OA->hasSingleDeviceDependence(
true)) {
3208 OA->getSingleDeviceDependence(
true);
3209 if (CanBeCollapsed &&
3212 SavedOffloadAction.push_back(OA);
3215 }
else if (OA->hasHostDependence()) {
3216 CurAction = OA->getHostDependence();
3217 if (CanBeCollapsed &&
3220 SavedOffloadAction.push_back(OA);
3230 bool canCollapseAssembleAction()
const {
3231 return TC.useIntegratedAs() && !SaveTemps &&
3232 !C.
getArgs().hasArg(options::OPT_via_file_asm) &&
3233 !C.
getArgs().hasArg(options::OPT__SLASH_FA) &&
3234 !C.
getArgs().hasArg(options::OPT__SLASH_Fa);
3238 bool canCollapsePreprocessorAction()
const {
3239 return !C.
getArgs().hasArg(options::OPT_no_integrated_cpp) &&
3240 !C.
getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
3241 !C.
getArgs().hasArg(options::OPT_rewrite_objc);
3246 struct JobActionInfo final {
3256 static void AppendCollapsedOffloadAction(
ActionList &CollapsedOffloadAction,
3258 unsigned ElementNum) {
3259 assert(ElementNum <= ActionInfo.size() &&
"Invalid number of elements.");
3260 for (
unsigned I = 0; I < ElementNum; ++I)
3261 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
3262 ActionInfo[I].SavedOffloadAction.end());
3278 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
3283 if (!AJ || !BJ || !CJ)
3287 const Tool *
T = TC.SelectTool(*CJ);
3294 const Tool *BT = TC.SelectTool(*BJ);
3302 Inputs = &CJ->getInputs();
3303 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3310 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
3319 auto *CJ = getPrevDependentAction(BJ->getInputs(), CompileJobOffloadActions,
3321 if (!AJ || !BJ || !CJ)
3324 assert(isa<CompileJobAction>(CJ) &&
3325 "Expecting compile job preceding backend job.");
3328 const Tool *
T = TC.SelectTool(*CJ);
3335 Inputs = &BJ->getInputs();
3336 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3343 if (ActionInfo.size() < 2 || !canCollapsePreprocessorAction())
3351 const Tool *
T = TC.SelectTool(*CJ);
3355 if (T->
canEmitIR() && (SaveTemps || EmbedBitcode))
3358 Inputs = &CJ->getInputs();
3359 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3368 void combineWithPreprocessor(
const Tool *
T,
const ActionList *&Inputs,
3375 auto *PJ = getPrevDependentAction(*Inputs, PreprocessJobOffloadActions);
3376 if (!PJ || !isa<PreprocessJobAction>(PJ))
3381 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
3382 PreprocessJobOffloadActions.end());
3383 Inputs = &PJ->getInputs();
3388 const Compilation &C,
bool SaveTemps,
bool EmbedBitcode)
3389 : TC(TC), C(C), BaseAction(BaseAction), SaveTemps(SaveTemps),
3390 EmbedBitcode(EmbedBitcode) {
3391 assert(BaseAction &&
"Invalid base action.");
3408 ActionChain.back().JA = BaseAction;
3409 while (ActionChain.back().JA) {
3410 const Action *CurAction = ActionChain.back().JA;
3413 ActionChain.resize(ActionChain.size() + 1);
3414 JobActionInfo &AI = ActionChain.back();
3418 getPrevDependentAction(CurAction->
getInputs(), AI.SavedOffloadAction);
3422 ActionChain.pop_back();
3430 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
3431 CollapsedOffloadAction);
3433 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
3435 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
3441 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
3453 StringRef BoundArch,
3455 std::string TriplePlusArch = TC->
getTriple().normalize();
3456 if (!BoundArch.empty()) {
3457 TriplePlusArch +=
"-";
3458 TriplePlusArch += BoundArch;
3460 TriplePlusArch +=
"-";
3462 return TriplePlusArch;
3467 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3468 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3470 std::pair<const Action *, std::string> ActionTC = {
3472 auto CachedResult = CachedResults.find(ActionTC);
3473 if (CachedResult != CachedResults.end()) {
3474 return CachedResult->second;
3476 InputInfo Result = BuildJobsForActionNoCache(
3477 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
3478 CachedResults, TargetDeviceOffloadKind);
3479 CachedResults[ActionTC] = Result;
3483 InputInfo Driver::BuildJobsForActionNoCache(
3485 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3486 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3488 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3491 bool BuildingForOffloadDevice = TargetDeviceOffloadKind !=
Action::OFK_None;
3523 if (OA->hasSingleDeviceDependence()) {
3525 OA->doOnEachDeviceDependence([&](
Action *DepA,
const ToolChain *DepTC,
3526 const char *DepBoundArch) {
3529 !!DepBoundArch, LinkingOutput,
3539 OA->doOnEachDependence(
3540 BuildingForOffloadDevice,
3543 C, DepA, DepTC, DepBoundArch,
false,
3544 !!DepBoundArch, LinkingOutput, CachedResults,
3548 A = BuildingForOffloadDevice
3549 ? OA->getSingleDeviceDependence(
true)
3550 : OA->getHostDependence();
3553 if (
const InputAction *IA = dyn_cast<InputAction>(A)) {
3556 const Arg &Input = IA->getInputArg();
3558 if (Input.getOption().matches(options::OPT_INPUT)) {
3559 const char *
Name = Input.getValue();
3569 if (!ArchName.empty())
3570 TC = &getToolChain(C.
getArgs(),
3577 MultipleArchs, LinkingOutput, CachedResults,
3578 TargetDeviceOffloadKind);
3584 const JobAction *JA = cast<JobAction>(A);
3589 const Tool *
T = TS.getTool(Inputs, CollapsedOffloadActions);
3596 for (
const auto *OA : CollapsedOffloadActions)
3597 cast<OffloadAction>(OA)->doOnEachDependence(
3598 BuildingForOffloadDevice,
3601 C, DepA, DepTC, DepBoundArch,
false,
3602 !!DepBoundArch, LinkingOutput, CachedResults,
3608 for (
const Action *Input : *Inputs) {
3612 bool SubJobAtTopLevel =
3613 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
3615 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
3620 const char *BaseInput = InputInfos[0].getBaseInput();
3624 if (JA->
getType() == types::TY_dSYM)
3625 BaseInput = InputInfos[0].getFilename();
3628 if (!OffloadDependencesInputInfo.empty())
3629 InputInfos.append(OffloadDependencesInputInfo.begin(),
3630 OffloadDependencesInputInfo.end());
3633 llvm::Triple EffectiveTriple;
3635 const ArgList &Args =
3637 if (InputInfos.size() != 1) {
3641 EffectiveTriple = llvm::Triple(
3649 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) {
3653 for (
auto &UI : UA->getDependentActionsInfo()) {
3655 "Unbundling with no offloading??");
3662 UI.DependentOffloadKind,
3663 UI.DependentToolChain->getTriple().normalize(),
3667 false, MultipleArchs,
3671 UnbundlingResults.push_back(CurI);
3676 UI.DependentToolChain, BoundArch,
3677 UI.DependentOffloadKind)}] = CurI;
3682 std::pair<const Action *, std::string> ActionTC = {
3684 assert(CachedResults.find(ActionTC) != CachedResults.end() &&
3685 "Result does not exist??");
3686 Result = CachedResults[ActionTC];
3687 }
else if (JA->
getType() == types::TY_Nothing)
3697 AtTopLevel, MultipleArchs,
3704 <<
" - \"" << T->
getName() <<
"\", inputs: [";
3705 for (
unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
3706 llvm::errs() << InputInfos[i].getAsString();
3708 llvm::errs() <<
", ";
3710 if (UnbundlingResults.empty())
3711 llvm::errs() <<
"], output: " << Result.
getAsString() <<
"\n";
3713 llvm::errs() <<
"], outputs: [";
3714 for (
unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) {
3715 llvm::errs() << UnbundlingResults[i].getAsString();
3717 llvm::errs() <<
", ";
3719 llvm::errs() <<
"] \n";
3722 if (UnbundlingResults.empty())
3724 C, *JA, Result, InputInfos,
3729 C, *JA, UnbundlingResults, InputInfos,
3738 return Target.isOSWindows() ?
"a.exe" :
"a.out";
3750 if (ArgValue.empty()) {
3752 Filename = BaseName;
3753 }
else if (llvm::sys::path::is_separator(Filename.back())) {
3755 llvm::sys::path::append(Filename, BaseName);
3758 if (!llvm::sys::path::has_extension(ArgValue)) {
3762 if (FileType == types::TY_Image &&
3763 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
3768 llvm::sys::path::replace_extension(Filename, Extension);
3771 return Args.MakeArgString(Filename.c_str());
3775 const char *BaseInput,
3776 StringRef BoundArch,
bool AtTopLevel,
3778 StringRef OffloadingPrefix)
const {
3779 llvm::PrettyStackTraceString CrashInfo(
"Computing output path");
3781 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
3782 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
3787 if (C.
getArgs().hasArg(options::OPT__SLASH_P)) {
3788 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
3789 StringRef BaseName = llvm::sys::path::filename(BaseInput);
3791 if (Arg *A = C.
getArgs().getLastArg(options::OPT__SLASH_Fi))
3792 NameArg = A->getValue();
3800 (isa<PreprocessJobAction>(JA) || JA.
getType() == types::TY_ModuleFile))
3804 if (JA.
getType() == types::TY_PP_Asm &&
3805 (C.
getArgs().hasArg(options::OPT__SLASH_FA) ||
3806 C.
getArgs().hasArg(options::OPT__SLASH_Fa))) {
3808 StringRef BaseName = llvm::sys::path::filename(BaseInput);
3809 StringRef FaValue = C.
getArgs().getLastArgValue(options::OPT__SLASH_Fa);
3817 !C.
getArgs().hasArg(options::OPT__SLASH_Fo)) ||
3819 StringRef
Name = llvm::sys::path::filename(BaseInput);
3820 std::pair<StringRef, StringRef> Split = Name.split(
'.');
3830 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
3831 BaseName = BasePath;
3833 BaseName = llvm::sys::path::filename(BasePath);
3836 const char *NamedOutput;
3838 if ((JA.
getType() == types::TY_Object || JA.
getType() == types::TY_LTO_BC) &&
3839 C.
getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
3843 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
3847 }
else if (JA.
getType() == types::TY_Image &&
3848 C.
getArgs().hasArg(options::OPT__SLASH_Fe,
3849 options::OPT__SLASH_o)) {
3853 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
3857 }
else if (JA.
getType() == types::TY_Image) {
3864 Output += OffloadingPrefix;
3865 if (MultipleArchs && !BoundArch.empty()) {
3867 Output.append(BoundArch);
3869 NamedOutput = C.
getArgs().MakeArgString(Output.c_str());
3875 assert(Suffix &&
"All types used for output should have a suffix.");
3877 std::string::size_type
End = std::string::npos;
3879 End = BaseName.rfind(
'.');
3881 Suffixed += OffloadingPrefix;
3882 if (MultipleArchs && !BoundArch.empty()) {
3884 Suffixed.append(BoundArch);
3889 if (!AtTopLevel && C.
getArgs().hasArg(options::OPT_emit_llvm) &&
3890 JA.
getType() == types::TY_LLVM_BC)
3894 NamedOutput = C.
getArgs().MakeArgString(Suffixed.c_str());
3899 JA.
getType() != types::TY_PCH) {
3900 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
3902 llvm::sys::path::remove_filename(TempPath);
3903 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
3904 llvm::sys::path::append(TempPath, OutputFileName);
3905 NamedOutput = C.
getArgs().MakeArgString(TempPath.c_str());
3911 bool SameFile =
false;
3913 llvm::sys::fs::current_path(Result);
3914 llvm::sys::path::append(Result, BaseName);
3915 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
3918 StringRef
Name = llvm::sys::path::filename(BaseInput);
3919 std::pair<StringRef, StringRef> Split = Name.split(
'.');
3928 llvm::sys::path::remove_filename(BasePath);
3929 if (BasePath.empty())
3930 BasePath = NamedOutput;
3932 llvm::sys::path::append(BasePath, NamedOutput);
3946 llvm::sys::path::append(
P, Name);
3947 if (llvm::sys::fs::exists(Twine(
P)))
3952 llvm::sys::path::append(R, Name);
3953 if (llvm::sys::fs::exists(Twine(R)))
3957 llvm::sys::path::append(
P, Name);
3958 if (llvm::sys::fs::exists(Twine(
P)))
3965 llvm::sys::path::append(
P, Name);
3966 if (llvm::sys::fs::exists(Twine(
P)))
3973 void Driver::generatePrefixedToolNames(
3977 Names.emplace_back((DefaultTargetTriple +
"-" +
Tool).str());
3978 Names.emplace_back(
Tool);
3981 std::string LLVMDefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
3982 if (LLVMDefaultTargetTriple != DefaultTargetTriple)
3983 Names.emplace_back((LLVMDefaultTargetTriple +
"-" +
Tool).str());
3988 for (
const auto &
Name : Names) {
3989 llvm::sys::path::append(Dir,
Name);
3990 if (llvm::sys::fs::can_execute(Twine(Dir)))
3992 llvm::sys::path::remove_filename(Dir);
3999 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
4004 if (llvm::sys::fs::is_directory(PrefixDir)) {
4010 if (llvm::sys::fs::can_execute(Twine(P)))
4016 for (
const auto &Path : List) {
4023 for (
const auto &TargetSpecificExecutable : TargetSpecificExecutables)
4024 if (llvm::ErrorOr<std::string>
P =
4025 llvm::sys::findProgramByName(TargetSpecificExecutable))
4033 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
4035 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
4044 if (Arg *FpArg = C.
getArgs().getLastArg(options::OPT__SLASH_Fp)) {
4048 Output = FpArg->getValue();
4052 if (!llvm::sys::path::has_extension(Output))
4056 llvm::sys::path::replace_extension(Output,
".pch");
4058 return Output.str();
4061 const ToolChain &Driver::getToolChain(
const ArgList &Args,
4062 const llvm::Triple &Target)
const {
4064 auto &TC = ToolChains[Target.str()];
4066 switch (Target.getOS()) {
4067 case llvm::Triple::Haiku:
4068 TC = llvm::make_unique<toolchains::Haiku>(*
this, Target, Args);
4070 case llvm::Triple::Ananas:
4071 TC = llvm::make_unique<toolchains::Ananas>(*
this, Target, Args);
4073 case llvm::Triple::CloudABI:
4074 TC = llvm::make_unique<toolchains::CloudABI>(*
this, Target, Args);
4076 case llvm::Triple::Darwin:
4077 case llvm::Triple::MacOSX:
4078 case llvm::Triple::IOS:
4079 case llvm::Triple::TvOS:
4080 case llvm::Triple::WatchOS:
4081 TC = llvm::make_unique<toolchains::DarwinClang>(*
this, Target, Args);
4083 case llvm::Triple::DragonFly:
4084 TC = llvm::make_unique<toolchains::DragonFly>(*
this, Target, Args);
4086 case llvm::Triple::OpenBSD:
4087 TC = llvm::make_unique<toolchains::OpenBSD>(*
this, Target, Args);
4089 case llvm::Triple::NetBSD:
4090 TC = llvm::make_unique<toolchains::NetBSD>(*
this, Target, Args);
4092 case llvm::Triple::FreeBSD:
4093 TC = llvm::make_unique<toolchains::FreeBSD>(*
this, Target, Args);
4095 case llvm::Triple::Minix:
4096 TC = llvm::make_unique<toolchains::Minix>(*
this, Target, Args);
4098 case llvm::Triple::Linux:
4099 case llvm::Triple::ELFIAMCU:
4100 if (Target.getArch() == llvm::Triple::hexagon)
4101 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
4103 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
4104 !Target.hasEnvironment())
4105 TC = llvm::make_unique<toolchains::MipsLLVMToolChain>(*
this, Target,
4108 TC = llvm::make_unique<toolchains::Linux>(*
this, Target, Args);
4110 case llvm::Triple::NaCl:
4111 TC = llvm::make_unique<toolchains::NaClToolChain>(*
this, Target, Args);
4113 case llvm::Triple::Fuchsia:
4114 TC = llvm::make_unique<toolchains::Fuchsia>(*
this, Target, Args);
4116 case llvm::Triple::Solaris:
4117 TC = llvm::make_unique<toolchains::Solaris>(*
this, Target, Args);
4119 case llvm::Triple::AMDHSA:
4120 TC = llvm::make_unique<toolchains::AMDGPUToolChain>(*
this, Target, Args);
4122 case llvm::Triple::Win32:
4123 switch (Target.getEnvironment()) {
4125 if (Target.isOSBinFormatELF())
4126 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
4127 else if (Target.isOSBinFormatMachO())
4128 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
4130 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
4132 case llvm::Triple::GNU:
4133 TC = llvm::make_unique<toolchains::MinGW>(*
this, Target, Args);
4135 case llvm::Triple::Itanium:
4136 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(*
this, Target,
4139 case llvm::Triple::MSVC:
4140 case llvm::Triple::UnknownEnvironment:
4141 if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
4142 .startswith_lower(
"bfd"))
4143 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(
4144 *
this, Target, Args);
4147 llvm::make_unique<toolchains::MSVCToolChain>(*
this, Target, Args);
4151 case llvm::Triple::PS4:
4152 TC = llvm::make_unique<toolchains::PS4CPU>(*
this, Target, Args);
4154 case llvm::Triple::Contiki:
4155 TC = llvm::make_unique<toolchains::Contiki>(*
this, Target, Args);
4160 switch (Target.getArch()) {
4161 case llvm::Triple::tce:
4162 TC = llvm::make_unique<toolchains::TCEToolChain>(*
this, Target, Args);
4164 case llvm::Triple::tcele:
4165 TC = llvm::make_unique<toolchains::TCELEToolChain>(*
this, Target, Args);
4167 case llvm::Triple::hexagon:
4168 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
4171 case llvm::Triple::lanai:
4172 TC = llvm::make_unique<toolchains::LanaiToolChain>(*
this, Target, Args);
4174 case llvm::Triple::xcore:
4175 TC = llvm::make_unique<toolchains::XCoreToolChain>(*
this, Target, Args);
4177 case llvm::Triple::wasm32:
4178 case llvm::Triple::wasm64:
4179 TC = llvm::make_unique<toolchains::WebAssembly>(*
this, Target, Args);
4181 case llvm::Triple::avr:
4182 TC = llvm::make_unique<toolchains::AVRToolChain>(*
this, Target, Args);
4185 if (Target.getVendor() == llvm::Triple::Myriad)
4186 TC = llvm::make_unique<toolchains::MyriadToolChain>(*
this, Target,
4189 TC = llvm::make_unique<toolchains::BareMetal>(*
this, Target, Args);
4190 else if (Target.isOSBinFormatELF())
4191 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
4192 else if (Target.isOSBinFormatMachO())
4193 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
4195 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
4210 if (JA.
size() != 1 ||
4215 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
4216 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
4228 unsigned &Micro,
bool &HadExtra) {
4231 Major = Minor = Micro = 0;
4235 if (Str.consumeInteger(10, Major))
4242 Str = Str.drop_front(1);
4244 if (Str.consumeInteger(10, Minor))
4250 Str = Str.drop_front(1);
4252 if (Str.consumeInteger(10, Micro))
4270 unsigned CurDigit = 0;
4271 while (CurDigit < Digits.size()) {
4273 if (Str.consumeInteger(10, Digit))
4275 Digits[CurDigit] = Digit;
4280 Str = Str.drop_front(1);
4288 std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks()
const {
4289 unsigned IncludedFlagsBitmask = 0;
4292 if (Mode == CLMode) {
4300 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
4304 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...
Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< vfs::FileSystem > VFS=nullptr)
static bool ContainsCompileOrAssembleAction(const Action *A)
Check whether the given input tree contains any compilation or assembly actions.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
bool isCollapsingWithNextDependentActionLegal() const
Return true if this function can be collapsed with others.
const llvm::opt::ArgStringList & getTempFiles() const
std::string ModeSuffix
Driver mode part of the executable name, as g++.
const char * CudaArchToString(CudaArch A)
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
T * MakeAction(Args &&... Arg)
Creates a new Action owned by this Compilation.
bool canLipoType(ID Id)
canLipoType - Is this type acceptable as the output of a universal build (currently, just the Nothing, Image, and Object types).
Set a ToolChain's effective triple.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type, or null if unspecified.
unsigned CCCUsePCH
Use lazy precompiled headers for PCH support.
void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args, InputList &Inputs) const
BuildInputs - Construct the list of inputs and their types from the given arguments.
void setResponseFile(const char *FileName)
Set to pass arguments via a response file when launching the command.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
std::string DyldPrefix
Dynamic loader prefix, if present.
Action * ConstructPhaseAction(Compilation &C, const llvm::opt::ArgList &Args, phases::ID Phase, Action *Input) const
ConstructAction - Construct the appropriate action to do for Phase on the Input, taking in to account...
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.
static bool ScanDirForExecutable(SmallString< 128 > &Dir, ArrayRef< std::string > Names)
bool CleanupFileList(const llvm::opt::ArgStringList &Files, bool IssueErrors=false) const
CleanupFileList - Remove the files in the given list.
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...
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, llvm::StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
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()
void generateCompilationDiagnostics(Compilation &C, const Command &FailingCommand)
generateCompilationDiagnostics - Generate diagnostics information including preprocessed source file(...
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
An unknown OpenMP runtime.
const llvm::opt::InputArgList & getInputArgs() const
input_iterator input_begin()
bool 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...
void handleAutocompletions(StringRef PassedFlags) const
handleAutocompletions - Handle –autocomplete by searching and printing possible flags, descriptions, and its arguments.
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
static Arg * MakeInputArg(DerivedArgList &Args, OptTable &Opts, StringRef Value)
ActionClass getKind() const
const char * getPhaseName(ID Id)
const FunctionProtoType * T
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.
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
static std::string GetTriplePlusArchString(const ToolChain *TC, StringRef BoundArch, Action::OffloadKind OffloadKind)
Return a string that uniquely identifies the result of a job.
void getCompilationPhases(ID Id, llvm::SmallVectorImpl< phases::ID > &Phases)
getCompilationPhases - Get the list of compilation phases ('Phases') to be done for type 'Id'...
void BuildUniversalActions(Compilation &C, const ToolChain &TC, const InputList &BAInputs) const
BuildUniversalActions - Construct the list of actions to perform for the given arguments, which may require a universal build.
llvm::opt::InputArgList ParseArgStrings(ArrayRef< const char *> Args, bool &ContainsError)
ParseArgStrings - Parse the given list of strings into an ArgList.
void setCannotBeCollapsedWithNextDependentAction()
Mark this action as not legal to collapse.
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.
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.
const llvm::opt::ArgStringList & getArguments() const
std::string SysRoot
sysroot, if present
std::string Name
The name the driver was invoked as.
Defines the virtual file system interface vfs::FileSystem.
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
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)
static llvm::Triple computeTargetTriple(const Driver &D, StringRef DefaultTargetTriple, const ArgList &Args, StringRef DarwinArchName="")
Compute target triple from args.
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
bool CleanupFileMap(const ArgStringMap &Files, const JobAction *JA, bool IssueErrors=false) const
CleanupFileMap - Remove the files in the given map.
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
void propagateHostOffloadInfo(unsigned OKinds, const char *OArch)
Append the host offload info of this action and propagate it to its dependences.
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.
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...
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.