46 #include "clang/Config/config.h"
55 #include "llvm/ADT/ArrayRef.h"
56 #include "llvm/ADT/STLExtras.h"
57 #include "llvm/ADT/SmallSet.h"
58 #include "llvm/ADT/StringExtras.h"
59 #include "llvm/ADT/StringSet.h"
60 #include "llvm/ADT/StringSwitch.h"
61 #include "llvm/Option/Arg.h"
62 #include "llvm/Option/ArgList.h"
63 #include "llvm/Option/OptSpecifier.h"
64 #include "llvm/Option/OptTable.h"
65 #include "llvm/Option/Option.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/raw_ostream.h"
80 using namespace clang::driver;
81 using namespace clang;
82 using namespace llvm::opt;
88 Mode(GCCMode), SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
89 LTOMode(
LTOK_None), ClangExecutable(ClangExecutable),
90 SysRoot(DEFAULT_SYSROOT), UseStdLib(
true),
91 DriverTitle(
"clang LLVM compiler"), CCPrintOptionsFilename(nullptr),
92 CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr),
93 CCCPrintBindings(
false), CCPrintHeaders(
false), CCLogDiagnostics(
false),
94 CCGenDiagnostics(
false), DefaultTargetTriple(DefaultTargetTriple),
95 CCCGenericGCCName(
""), CheckInputsExist(
true), CCCUsePCH(
true),
96 GenReproducer(
false), SuppressMissingInputWarning(
false) {
102 Name = llvm::sys::path::filename(ClangExecutable);
103 Dir = llvm::sys::path::parent_path(ClangExecutable);
107 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
109 if (ClangResourceDir !=
"") {
110 llvm::sys::path::append(P, ClangResourceDir);
112 StringRef ClangLibdirSuffix(CLANG_LIBDIR_SUFFIX);
113 P = llvm::sys::path::parent_path(
Dir);
114 llvm::sys::path::append(P, Twine(
"lib") + ClangLibdirSuffix,
"clang",
115 CLANG_VERSION_STRING);
123 StringRef DefaultMode(
Default.second);
124 setDriverModeFromOption(DefaultMode);
126 for (
const char *ArgPtr : Args) {
128 if (ArgPtr ==
nullptr)
130 const StringRef Arg = ArgPtr;
131 setDriverModeFromOption(Arg);
135 void Driver::setDriverModeFromOption(StringRef Opt) {
136 const std::string OptName =
137 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
138 if (!Opt.startswith(OptName))
140 StringRef
Value = Opt.drop_front(OptName.size());
142 const unsigned M = llvm::StringSwitch<unsigned>(
Value)
143 .Case(
"gcc", GCCMode)
144 .Case(
"g++", GXXMode)
145 .Case(
"cpp", CPPMode)
150 Mode =
static_cast<DriverMode
>(M);
152 Diag(diag::err_drv_unsupported_option_argument) << OptName <<
Value;
156 bool &ContainsError) {
157 llvm::PrettyStackTraceString CrashInfo(
"Command line argument parsing");
158 ContainsError =
false;
160 unsigned IncludedFlagsBitmask;
161 unsigned ExcludedFlagsBitmask;
162 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
163 getIncludeExcludeOptionFlagMasks();
165 unsigned MissingArgIndex, MissingArgCount;
167 getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount,
168 IncludedFlagsBitmask, ExcludedFlagsBitmask);
171 if (MissingArgCount) {
172 Diag(diag::err_drv_missing_argument)
173 << Args.getArgString(MissingArgIndex) << MissingArgCount;
180 for (
const Arg *A : Args) {
182 Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
190 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue(
"")) {
191 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
193 diag::warn_drv_empty_joined_argument,
198 for (
const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {
199 auto ID =
IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl
200 : diag::err_drv_unknown_argument;
202 Diags.
Report(
ID) << A->getAsString(Args);
213 phases::ID Driver::getFinalPhase(
const DerivedArgList &DAL,
214 Arg **FinalPhaseArg)
const {
215 Arg *PhaseArg =
nullptr;
219 if (
CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
220 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
221 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
222 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
226 }
else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
230 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
231 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
232 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
233 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
234 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
235 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
236 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
237 options::OPT__analyze_auto)) ||
238 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
242 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
246 }
else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
254 *FinalPhaseArg = PhaseArg;
261 Arg *A =
new Arg(Opts.getOption(options::OPT_INPUT),
Value,
262 Args.getBaseArgs().MakeIndex(Value), Value.data());
263 Args.AddSynthesizedArg(A);
268 DerivedArgList *Driver::TranslateInputArgs(
const InputArgList &Args)
const {
269 DerivedArgList *DAL =
new DerivedArgList(Args);
271 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
272 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
273 for (Arg *A : Args) {
280 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
281 A->getOption().matches(options::OPT_Xlinker)) &&
282 A->containsValue(
"--no-demangle")) {
284 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
287 for (StringRef Val : A->getValues())
288 if (Val !=
"--no-demangle")
289 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val);
297 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
298 (A->getValue(0) == StringRef(
"-MD") ||
299 A->getValue(0) == StringRef(
"-MMD"))) {
301 if (A->getValue(0) == StringRef(
"-MD"))
302 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
304 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
305 if (A->getNumValues() == 2)
306 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
312 if (A->getOption().matches(options::OPT_l)) {
313 StringRef Value = A->getValue();
316 if (!HasNostdlib && !HasNodefaultlib && Value ==
"stdc++") {
317 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx));
322 if (Value ==
"cc_kext") {
323 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext));
329 if (A->getOption().matches(options::OPT__DASH_DASH)) {
331 for (StringRef Val : A->getValues())
340 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false))
341 DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
345 #if defined(HOST_LINK_VERSION)
346 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
347 strlen(HOST_LINK_VERSION) > 0) {
348 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
350 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
362 StringRef DefaultTargetTriple,
364 StringRef DarwinArchName =
"") {
366 if (
const Arg *A = Args.getLastArg(options::OPT_target))
367 DefaultTargetTriple = A->getValue();
372 if (Target.isOSBinFormatMachO()) {
374 if (!DarwinArchName.empty()) {
380 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
381 StringRef ArchName = A->getValue();
388 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
389 options::OPT_mbig_endian)) {
390 if (A->getOption().matches(options::OPT_mlittle_endian)) {
391 llvm::Triple LE = Target.getLittleEndianArchVariant();
392 if (LE.getArch() != llvm::Triple::UnknownArch)
393 Target = std::move(LE);
395 llvm::Triple BE = Target.getBigEndianArchVariant();
396 if (BE.getArch() != llvm::Triple::UnknownArch)
397 Target = std::move(BE);
402 if (Target.getArch() == llvm::Triple::tce ||
403 Target.getOS() == llvm::Triple::Minix)
407 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
408 options::OPT_m32, options::OPT_m16);
410 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
412 if (A->getOption().matches(options::OPT_m64)) {
413 AT = Target.get64BitArchVariant().getArch();
414 if (Target.getEnvironment() == llvm::Triple::GNUX32)
415 Target.setEnvironment(llvm::Triple::GNU);
416 }
else if (A->getOption().matches(options::OPT_mx32) &&
417 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
418 AT = llvm::Triple::x86_64;
419 Target.setEnvironment(llvm::Triple::GNUX32);
420 }
else if (A->getOption().matches(options::OPT_m32)) {
421 AT = Target.get32BitArchVariant().getArch();
422 if (Target.getEnvironment() == llvm::Triple::GNUX32)
423 Target.setEnvironment(llvm::Triple::GNU);
424 }
else if (A->getOption().matches(options::OPT_m16) &&
425 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
426 AT = llvm::Triple::x86;
427 Target.setEnvironment(llvm::Triple::CODE16);
430 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
435 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
436 if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
437 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-miamcu"
440 if (A && !A->getOption().matches(options::OPT_m32))
441 D.
Diag(diag::err_drv_argument_not_allowed_with)
442 <<
"-miamcu" << A->getBaseArg().getAsString(Args);
444 Target.setArch(llvm::Triple::x86);
445 Target.setArchName(
"i586");
446 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
447 Target.setEnvironmentName(
"");
448 Target.setOS(llvm::Triple::ELFIAMCU);
449 Target.setVendor(llvm::Triple::UnknownVendor);
450 Target.setVendorName(
"intel");
458 void Driver::setLTOMode(
const llvm::opt::ArgList &Args) {
460 if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ,
461 options::OPT_fno_lto,
false))
464 StringRef LTOName(
"full");
466 const Arg *A = Args.getLastArg(options::OPT_flto_EQ);
468 LTOName = A->getValue();
470 LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
477 Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
484 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
486 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
488 RuntimeName = A->getValue();
490 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
498 Diag(diag::err_drv_unsupported_option_argument)
499 << A->getOption().getName() << A->getValue();
502 Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
515 if (llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &
I) {
519 const llvm::Triple &HostTriple = HostTC->
getTriple();
520 llvm::Triple CudaTriple(HostTriple.isArch64Bit() ?
"nvptx64-nvidia-cuda"
521 :
"nvptx-nvidia-cuda");
524 auto &CudaTC = ToolChains[CudaTriple.str() +
"/" + HostTriple.str()];
526 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
537 if (Arg *OpenMPTargets =
538 C.
getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
539 if (OpenMPTargets->getNumValues()) {
544 options::OPT_fopenmp, options::OPT_fopenmp_EQ,
545 options::OPT_fno_openmp,
false);
546 if (HasValidOpenMPRuntime) {
548 HasValidOpenMPRuntime =
552 if (HasValidOpenMPRuntime) {
553 llvm::StringMap<const char *> FoundNormalizedTriples;
554 for (
const char *Val : OpenMPTargets->getValues()) {
555 llvm::Triple TT(Val);
556 std::string NormalizedName = TT.normalize();
559 auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
560 if (Duplicate != FoundNormalizedTriples.end()) {
561 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
562 << Val << Duplicate->second;
568 FoundNormalizedTriples[NormalizedName] = Val;
571 if (TT.getArch() == llvm::Triple::UnknownArch)
572 Diag(clang::diag::err_drv_invalid_omp_target) << Val;
580 assert(HostTC &&
"Host toolchain should be always defined.");
582 ToolChains[TT.str() +
"/" + HostTC->
getTriple().str()];
584 CudaTC = llvm::make_unique<toolchains::CudaToolChain>(
593 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
595 Diag(clang::diag::warn_drv_empty_joined_argument)
607 llvm::PrettyStackTraceString CrashInfo(
"Compilation construction");
613 llvm::sys::Process::GetEnv(
"COMPILER_PATH")) {
614 StringRef CompilerPath = *CompilerPathValue;
615 while (!CompilerPath.empty()) {
616 std::pair<StringRef, StringRef> Split =
617 CompilerPath.split(llvm::sys::EnvPathSeparator);
619 CompilerPath = Split.second;
639 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
642 Args.ClaimAllArgs(options::OPT_pipe);
650 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
652 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
653 CCCGenericGCCName = A->getValue();
655 Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth);
657 options::OPT_fno_crash_diagnostics,
658 !!::getenv(
"FORCE_CLANG_DIAGNOSTICS_CRASH"));
663 llvm::Triple T(DefaultTargetTriple);
664 T.setOS(llvm::Triple::Win32);
665 T.setVendor(llvm::Triple::PC);
666 T.setEnvironment(llvm::Triple::MSVC);
667 DefaultTargetTriple = T.str();
669 if (
const Arg *A = Args.getLastArg(options::OPT_target))
670 DefaultTargetTriple = A->getValue();
671 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
673 for (
const Arg *A : Args.filtered(options::OPT_B)) {
677 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
679 if (
const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
681 if (Args.hasArg(options::OPT_nostdlib))
684 if (
const Arg *A = Args.getLastArg(options::OPT_resource_dir))
687 if (
const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
688 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
689 .Case(
"cwd", SaveTempsCwd)
690 .Case(
"obj", SaveTempsObj)
691 .Default(SaveTempsCwd);
697 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
698 StringRef
Name = A->getValue();
699 unsigned Model = llvm::StringSwitch<unsigned>(
Name)
700 .Case(
"off", EmbedNone)
701 .Case(
"all", EmbedBitcode)
702 .Case(
"bitcode", EmbedBitcode)
703 .Case(
"marker", EmbedMarker)
706 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
709 BitcodeEmbed =
static_cast<BitcodeEmbedMode
>(Model);
712 std::unique_ptr<llvm::opt::InputArgList> UArgs =
713 llvm::make_unique<InputArgList>(std::move(Args));
716 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
743 if (CCCPrintPhases) {
753 static void printArgList(raw_ostream &OS,
const llvm::opt::ArgList &Args) {
754 llvm::opt::ArgStringList ASL;
755 for (
const auto *A : Args)
756 A->render(Args, ASL);
758 for (
auto I = ASL.begin(),
E = ASL.end();
I !=
E; ++
I) {
759 if (
I != ASL.begin())
766 bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename,
768 using namespace llvm::sys;
769 assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&
770 "Only knows about .crash files on Darwin");
775 path::home_directory(CrashDiagDir);
776 if (CrashDiagDir.startswith(
"/var/root"))
778 path::append(CrashDiagDir,
"Library/Logs/DiagnosticReports");
786 fs::file_status FileStatus;
787 TimePoint<> LastAccessTime;
791 for (fs::directory_iterator File(CrashDiagDir, EC), FileEnd;
792 File != FileEnd && !EC; File.increment(EC)) {
793 StringRef
FileName = path::filename(File->path());
794 if (!FileName.startswith(
Name))
796 if (fs::status(File->path(), FileStatus))
798 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
799 llvm::MemoryBuffer::getFile(File->path());
804 StringRef Data = CrashFile.get()->getBuffer();
805 if (!Data.startswith(
"Process:"))
808 size_t ParentProcPos = Data.find(
"Parent Process:");
809 if (ParentProcPos == StringRef::npos)
811 size_t LineEnd = Data.find_first_of(
"\n", ParentProcPos);
812 if (LineEnd == StringRef::npos)
814 StringRef ParentProcess = Data.slice(ParentProcPos+15, LineEnd).trim();
815 int OpenBracket = -1, CloseBracket = -1;
816 for (
size_t i = 0, e = ParentProcess.size(); i < e; ++i) {
817 if (ParentProcess[i] ==
'[')
819 if (ParentProcess[i] ==
']')
825 if (OpenBracket < 0 || CloseBracket < 0 ||
826 ParentProcess.slice(OpenBracket + 1, CloseBracket)
827 .getAsInteger(10, CrashPID) || CrashPID != PID) {
837 const auto FileAccessTime = FileStatus.getLastModificationTime();
838 if (FileAccessTime > LastAccessTime) {
839 CrashFilePath.assign(File->path());
840 LastAccessTime = FileAccessTime;
845 if (!CrashFilePath.empty()) {
846 EC = fs::copy_file(CrashFilePath, ReproCrashFilename);
859 const Command &FailingCommand) {
860 if (C.
getArgs().hasArg(options::OPT_fno_crash_diagnostics))
871 Diag(clang::diag::note_drv_command_failed_diag_msg)
872 <<
"PLEASE submit a bug report to " BUG_REPORT_URL
" and include the "
873 "crash backtrace, preprocessed source, and associated run script.";
893 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
894 bool IgnoreInput =
false;
900 }
else if (!strcmp(it->second->getValue(),
"-")) {
901 Diag(clang::diag::note_drv_command_failed_diag_msg)
902 <<
"Error generating preprocessed source(s) - "
903 "ignoring input from stdin.";
908 it = Inputs.erase(it);
915 if (Inputs.empty()) {
916 Diag(clang::diag::note_drv_command_failed_diag_msg)
917 <<
"Error generating preprocessed source(s) - "
918 "no preprocessable inputs.";
924 llvm::StringSet<> ArchNames;
925 for (
const Arg *A : C.
getArgs()) {
926 if (A->getOption().matches(options::OPT_arch)) {
927 StringRef ArchName = A->getValue();
928 ArchNames.insert(ArchName);
931 if (ArchNames.size() > 1) {
932 Diag(clang::diag::note_drv_command_failed_diag_msg)
933 <<
"Error generating preprocessed source(s) - cannot generate "
934 "preprocessed source with multiple -arch options.";
950 Diag(clang::diag::note_drv_command_failed_diag_msg)
951 <<
"Error generating preprocessed source(s).";
960 if (!FailingCommands.empty()) {
964 Diag(clang::diag::note_drv_command_failed_diag_msg)
965 <<
"Error generating preprocessed source(s).";
970 if (TempFiles.empty()) {
971 Diag(clang::diag::note_drv_command_failed_diag_msg)
972 <<
"Error generating preprocessed source(s).";
976 Diag(clang::diag::note_drv_command_failed_diag_msg)
977 <<
"\n********************\n\n"
978 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
979 "Preprocessed source(s) and associated run script(s) are located at:";
983 for (
const char *TempFile : TempFiles) {
984 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
985 if (ReproCrashFilename.empty()) {
986 ReproCrashFilename = TempFile;
987 llvm::sys::path::replace_extension(ReproCrashFilename,
".crash");
989 if (StringRef(TempFile).endswith(
".cache")) {
992 VFS = llvm::sys::path::filename(TempFile);
993 llvm::sys::path::append(VFS,
"vfs",
"vfs.yaml");
1000 std::string Script = CrashInfo.
Filename.rsplit(
'.').first.str() +
".sh";
1002 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::F_Excl);
1004 Diag(clang::diag::note_drv_command_failed_diag_msg)
1005 <<
"Error generating run script: " + Script +
" " + EC.message();
1008 <<
"# Driver args: ";
1010 ScriptOS <<
"# Original command: ";
1011 Cmd.
Print(ScriptOS,
"\n",
true);
1012 Cmd.
Print(ScriptOS,
"\n",
true, &CrashInfo);
1013 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
1017 if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) {
1019 if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) {
1020 Diag(clang::diag::note_drv_command_failed_diag_msg)
1021 << ReproCrashFilename.str();
1023 llvm::sys::path::append(CrashDiagDir,
Name);
1024 CrashDiagDir +=
"_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
1025 Diag(clang::diag::note_drv_command_failed_diag_msg)
1026 <<
"Crash backtrace is located in";
1027 Diag(clang::diag::note_drv_command_failed_diag_msg)
1028 << CrashDiagDir.str();
1029 Diag(clang::diag::note_drv_command_failed_diag_msg)
1030 <<
"(choose the .crash file that corresponds to your crash)";
1034 for (
const auto &A : C.
getArgs().filtered(options::OPT_frewrite_map_file,
1035 options::OPT_frewrite_map_file_EQ))
1036 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
1038 Diag(clang::diag::note_drv_command_failed_diag_msg)
1039 <<
"\n\n********************";
1058 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1069 setUpResponseFiles(C, Job);
1077 if (FailingCommands.empty())
1082 for (
const auto &CmdPair : FailingCommands) {
1083 int Res = CmdPair.first;
1084 const Command *FailingCommand = CmdPair.second;
1108 Diag(clang::diag::err_drv_command_signalled)
1119 unsigned IncludedFlagsBitmask;
1120 unsigned ExcludedFlagsBitmask;
1121 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
1122 getIncludeExcludeOptionFlagMasks();
1126 ExcludedFlagsBitmask |= HelpHidden;
1129 IncludedFlagsBitmask, ExcludedFlagsBitmask);
1140 if (Arg *A = C.
getArgs().getLastArg(options::OPT_mthread_model)) {
1143 OS <<
"Thread model: " << A->getValue();
1165 if (C.
getArgs().hasArg(options::OPT_dumpmachine)) {
1170 if (C.
getArgs().hasArg(options::OPT_dumpversion)) {
1177 llvm::outs() <<
"4.2.1\n";
1181 if (C.
getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
1186 if (C.
getArgs().hasArg(options::OPT_help) ||
1187 C.
getArgs().hasArg(options::OPT__help_hidden)) {
1192 if (C.
getArgs().hasArg(options::OPT__version)) {
1198 if (C.
getArgs().hasArg(options::OPT_v) ||
1199 C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
1201 SuppressMissingInputWarning =
true;
1206 if (C.
getArgs().hasArg(options::OPT_v))
1209 if (C.
getArgs().hasArg(options::OPT_print_resource_dir)) {
1214 if (C.
getArgs().hasArg(options::OPT_print_search_dirs)) {
1215 llvm::outs() <<
"programs: =";
1216 bool separator =
false;
1219 llvm::outs() <<
':';
1220 llvm::outs() << Path;
1223 llvm::outs() <<
"\n";
1230 llvm::outs() <<
':';
1233 llvm::outs() << sysroot << Path.substr(1);
1235 llvm::outs() << Path;
1237 llvm::outs() <<
"\n";
1243 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
1244 llvm::outs() <<
GetFilePath(A->getValue(), TC) <<
"\n";
1248 if (Arg *A = C.
getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
1253 if (Arg *A = C.
getArgs().getLastArg(options::OPT_autocomplete)) {
1256 StringRef PassedFlags = A->getValue();
1257 std::vector<std::string> SuggestedCompletions;
1263 if (PassedFlags[0] ==
'#') {
1265 PassedFlags = PassedFlags.substr(1);
1268 if (PassedFlags.find(
',') == StringRef::npos) {
1272 SuggestedCompletions = Opts->findByPrefix(PassedFlags, DisableFlags);
1278 if (
S.startswith(PassedFlags))
1279 SuggestedCompletions.push_back(
S);
1285 StringRef Option, Arg;
1286 std::tie(Option, Arg) = PassedFlags.split(
',');
1287 SuggestedCompletions = Opts->suggestValueCompletions(Option, Arg);
1294 std::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(),
1295 [](StringRef A, StringRef B) {
return A.compare_lower(B) < 0; });
1297 llvm::outs() << llvm::join(SuggestedCompletions,
"\n") <<
'\n';
1301 if (C.
getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
1308 llvm::outs() <<
GetFilePath(
"libgcc.a", TC) <<
"\n";
1314 if (C.
getArgs().hasArg(options::OPT_print_multi_lib)) {
1320 if (C.
getArgs().hasArg(options::OPT_print_multi_directory)) {
1323 llvm::outs() <<
".\n";
1326 assert(Suffix.front() ==
'/');
1327 llvm::outs() << Suffix.substr(1) <<
"\n";
1339 std::map<Action *, unsigned> &Ids) {
1344 llvm::raw_string_ostream os(str);
1348 os <<
"\"" << IA->getInputArg().getValue() <<
"\"";
1350 os <<
'"' << BIA->getArchName() <<
'"' <<
", {"
1352 }
else if (
OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1353 bool IsFirst =
true;
1354 OA->doOnEachDependence(
1371 os <<
":" << BoundArch;
1381 const char *Prefix =
"{";
1382 for (
Action *PreRequisite : *AL) {
1393 std::string offload_str;
1394 llvm::raw_string_ostream offload_os(offload_str);
1395 if (!isa<OffloadAction>(A)) {
1398 offload_os <<
", (" <<
S;
1405 unsigned Id = Ids.size();
1407 llvm::errs() << Id <<
": " << os.str() <<
", "
1416 std::map<Action *, unsigned> Ids;
1424 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
1425 isa<AssembleJobAction>(A))
1437 DerivedArgList &Args = C.
getArgs();
1439 llvm::PrettyStackTraceString CrashInfo(
"Building universal build actions");
1442 llvm::StringSet<> ArchNames;
1444 for (Arg *A : Args) {
1445 if (A->getOption().matches(options::OPT_arch)) {
1448 llvm::Triple::ArchType Arch =
1450 if (Arch == llvm::Triple::UnknownArch) {
1451 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
1456 if (ArchNames.insert(A->getValue()).second)
1457 Archs.push_back(A->getValue());
1471 for (
Action* Act : SingleActions) {
1479 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
1483 for (
unsigned i = 0, e = Archs.size(); i != e; ++i)
1488 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1489 Actions.append(Inputs.begin(), Inputs.end());
1494 Arg *A = Args.getLastArg(options::OPT_g_Group);
1495 if (A && !A->getOption().matches(options::OPT_g0) &&
1496 !A->getOption().matches(options::OPT_gstabs) &&
1503 if (Act->getType() == types::TY_Image) {
1505 Inputs.push_back(Actions.back());
1512 if (Args.hasArg(options::OPT_verify_debug_info)) {
1513 Action* LastAction = Actions.back();
1516 LastAction, types::TY_Nothing));
1534 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
1535 if (!llvm::sys::path::is_absolute(Path)) {
1537 llvm::sys::path::append(Directory, Value);
1538 Path.assign(Directory);
1542 if (llvm::sys::fs::exists(Twine(Path)))
1546 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1547 llvm::sys::Process::FindInEnvPath(
"LIB", Value))
1550 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1558 D.
Diag(clang::diag::err_drv_no_such_file) << Path;
1568 types::ID InputType = types::TY_Nothing;
1569 Arg *InputTypeArg =
nullptr;
1572 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1573 options::OPT__SLASH_TP)) {
1574 InputTypeArg = TCTP;
1575 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
1580 bool ShowNote =
false;
1581 for (Arg *A : Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) {
1583 Diag(clang::diag::warn_drv_overriding_flag_option)
1584 << Previous->getSpelling() << A->getSpelling();
1590 Diag(clang::diag::note_drv_t_option_is_global);
1593 assert(!Args.hasArg(options::OPT_x) &&
"-x and /TC or /TP is not allowed");
1596 for (Arg *A : Args) {
1597 if (A->getOption().getKind() == Option::InputClass) {
1598 const char *Value = A->getValue();
1602 if (InputType == types::TY_Nothing) {
1605 InputTypeArg->claim();
1608 if (memcmp(Value,
"-", 2) == 0) {
1614 if (!Args.hasArgNoClaim(options::OPT_E) && !
CCCIsCPP())
1615 Diag(
IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1616 : clang::diag::err_drv_unknown_stdin_type);
1623 if (
const char *Ext = strrchr(Value,
'.'))
1630 Ty = types::TY_Object;
1640 Diag(clang::diag::warn_drv_treating_input_as_cxx)
1650 if (Ty != types::TY_Object) {
1651 if (Args.hasArg(options::OPT_ObjC))
1652 Ty = types::TY_ObjC;
1653 else if (Args.hasArg(options::OPT_ObjCXX))
1654 Ty = types::TY_ObjCXX;
1657 assert(InputTypeArg &&
"InputType set w/o InputTypeArg");
1658 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
1661 const char *Ext = strrchr(Value,
'.');
1663 Ty = types::TY_Object;
1667 InputTypeArg->claim();
1672 Inputs.push_back(std::make_pair(Ty, A));
1674 }
else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1675 StringRef Value = A->getValue();
1677 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
1678 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1681 }
else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1682 StringRef Value = A->getValue();
1684 Arg *InputArg =
MakeInputArg(Args, *Opts, A->getValue());
1685 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1691 Inputs.push_back(std::make_pair(types::TY_Object, A));
1693 }
else if (A->getOption().matches(options::OPT_x)) {
1702 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
1703 InputType = types::TY_Object;
1705 }
else if (A->getOption().getID() == options::OPT__SLASH_U) {
1706 assert(A->getNumValues() == 1 &&
"The /U option has one value.");
1707 StringRef Val = A->getValue(0);
1708 if (Val.find_first_of(
"/\\") != StringRef::npos) {
1710 Diag(diag::warn_slash_u_filename) << Val;
1711 Diag(diag::note_use_dashdash);
1715 if (
CCCIsCPP() && Inputs.empty()) {
1719 Inputs.push_back(std::make_pair(types::TY_C, A));
1726 class OffloadingActionBuilder final {
1728 bool IsValid =
false;
1734 std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
1737 class DeviceActionBuilder {
1741 enum ActionBuilderReturnCode {
1760 DerivedArgList &Args;
1769 DeviceActionBuilder(
Compilation &C, DerivedArgList &Args,
1772 : C(C), Args(Args), Inputs(Inputs),
1773 AssociatedOffloadKind(AssociatedOffloadKind) {}
1774 virtual ~DeviceActionBuilder() {}
1779 virtual ActionBuilderReturnCode
1783 return ABRT_Inactive;
1788 virtual ActionBuilderReturnCode addDeviceDepences(
Action *HostAction) {
1789 return ABRT_Inactive;
1794 virtual void appendTopLevelActions(
ActionList &AL) {}
1802 virtual bool initialize() {
return false; }
1805 virtual bool canUseBundlerUnbundler()
const {
return false; }
1809 bool isValid() {
return !ToolChains.empty(); }
1813 return AssociatedOffloadKind;
1819 class CudaActionBuilder final :
public DeviceActionBuilder {
1822 bool CompileHostOnly =
false;
1823 bool CompileDeviceOnly =
false;
1832 Action *CudaFatBinary =
nullptr;
1835 bool IsActive =
false;
1838 CudaActionBuilder(
Compilation &C, DerivedArgList &Args,
1840 : DeviceActionBuilder(C, Args, Inputs,
Action::OFK_Cuda) {}
1842 ActionBuilderReturnCode
1845 PhasesTy &Phases)
override {
1847 return ABRT_Inactive;
1851 if (CudaDeviceActions.empty())
1852 return ABRT_Success;
1854 assert(CudaDeviceActions.size() == GpuArchList.size() &&
1855 "Expecting one action per GPU architecture.");
1856 assert(!CompileHostOnly &&
1857 "Not expecting CUDA actions in host-only compilation.");
1867 for (
unsigned I = 0,
E = GpuArchList.size();
I !=
E; ++
I) {
1870 for (
auto Ph : Phases) {
1875 if (Ph > FinalPhase)
1879 C, Args, Ph, CudaDeviceActions[
I]);
1888 if (!isa<AssembleJobAction>(CudaDeviceActions[I]) ||
1892 Action *AssembleAction = CudaDeviceActions[
I];
1893 assert(AssembleAction->
getType() == types::TY_Object);
1894 assert(AssembleAction->
getInputs().size() == 1);
1897 assert(BackendAction->getType() == types::TY_PP_Asm);
1899 for (
auto &A : {AssembleAction, BackendAction}) {
1903 DeviceActions.push_back(
1909 if (!DeviceActions.empty()) {
1913 if (!CompileDeviceOnly) {
1914 DA.
add(*CudaFatBinary, *ToolChains.front(),
nullptr,
1918 CudaFatBinary =
nullptr;
1923 CudaDeviceActions.clear();
1927 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
1932 return ABRT_Success;
1936 "instructions should only occur "
1937 "before the backend phase!");
1940 for (
Action *&A : CudaDeviceActions)
1943 return ABRT_Success;
1946 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
1953 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
1954 assert(!GpuArchList.empty() &&
1955 "We should have at least one GPU architecture.");
1959 if (IA->getType() != types::TY_CUDA) {
1962 return ABRT_Inactive;
1968 if (CompileHostOnly)
1969 return ABRT_Success;
1972 for (
unsigned I = 0,
E = GpuArchList.size(); I !=
E; ++
I)
1974 IA->getInputArg(), types::TY_CUDA_DEVICE));
1976 return ABRT_Success;
1979 return IsActive ? ABRT_Success : ABRT_Inactive;
1982 void appendTopLevelActions(
ActionList &AL)
override {
1992 if (CudaFatBinary) {
1994 CudaDeviceActions.clear();
1995 CudaFatBinary =
nullptr;
1999 if (CudaDeviceActions.empty())
2005 assert(CudaDeviceActions.size() == GpuArchList.size() &&
2006 "Expecting one action per GPU architecture.");
2007 assert(ToolChains.size() == 1 &&
2008 "Expecting to have a sing CUDA toolchain.");
2009 for (
unsigned I = 0,
E = GpuArchList.size(); I !=
E; ++
I)
2010 AddTopLevel(CudaDeviceActions[I], GpuArchList[I]);
2012 CudaDeviceActions.clear();
2015 bool initialize()
override {
2021 assert(HostTC &&
"No toolchain for host compilation.");
2032 Arg *PartialCompilationArg = Args.getLastArg(
2033 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
2034 options::OPT_cuda_compile_host_device);
2035 CompileHostOnly = PartialCompilationArg &&
2036 PartialCompilationArg->getOption().matches(
2037 options::OPT_cuda_host_only);
2038 CompileDeviceOnly = PartialCompilationArg &&
2039 PartialCompilationArg->getOption().matches(
2040 options::OPT_cuda_device_only);
2043 std::set<CudaArch> GpuArchs;
2045 for (Arg *A : Args) {
2046 if (!(A->getOption().matches(options::OPT_cuda_gpu_arch_EQ) ||
2047 A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ)))
2051 const StringRef ArchStr = A->getValue();
2052 if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ) &&
2059 C.
getDriver().
Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
2061 }
else if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
2062 GpuArchs.insert(Arch);
2063 else if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ))
2064 GpuArchs.erase(Arch);
2066 llvm_unreachable(
"Unexpected option.");
2071 GpuArchList.push_back(Arch);
2076 if (GpuArchList.empty())
2085 class OpenMPActionBuilder final :
public DeviceActionBuilder {
2093 OpenMPActionBuilder(
Compilation &C, DerivedArgList &Args,
2095 : DeviceActionBuilder(C, Args, Inputs,
Action::OFK_OpenMP) {}
2097 ActionBuilderReturnCode
2100 PhasesTy &Phases)
override {
2103 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2104 "Number of OpenMP actions and toolchains do not match.");
2109 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2110 "Toolchains and linker inputs sizes do not match.");
2111 auto LI = DeviceLinkerInputs.begin();
2112 for (
auto *A : OpenMPDeviceActions) {
2119 OpenMPDeviceActions.clear();
2120 return ABRT_Success;
2124 for (
Action *&A : OpenMPDeviceActions)
2127 return ABRT_Success;
2130 ActionBuilderReturnCode addDeviceDepences(
Action *HostAction)
override {
2133 if (
auto *IA = dyn_cast<InputAction>(HostAction)) {
2134 OpenMPDeviceActions.clear();
2135 for (
unsigned I = 0; I < ToolChains.size(); ++
I)
2136 OpenMPDeviceActions.push_back(
2138 return ABRT_Success;
2142 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
2143 OpenMPDeviceActions.clear();
2144 for (
unsigned I = 0; I < ToolChains.size(); ++
I) {
2145 OpenMPDeviceActions.push_back(UA);
2146 UA->registerDependentActionInfo(
2149 return ABRT_Success;
2156 if (isa<CompileJobAction>(HostAction)) {
2158 assert(ToolChains.size() == OpenMPDeviceActions.size() &&
2159 "Toolchains and device action sizes do not match.");
2163 auto TC = ToolChains.begin();
2164 for (
Action *&A : OpenMPDeviceActions) {
2165 assert(isa<CompileJobAction>(A));
2172 return ABRT_Success;
2175 void appendTopLevelActions(
ActionList &AL)
override {
2176 if (OpenMPDeviceActions.empty())
2180 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
2181 "Number of OpenMP actions and toolchains do not match.");
2184 auto TI = ToolChains.begin();
2185 for (
auto *A : OpenMPDeviceActions) {
2192 OpenMPDeviceActions.clear();
2196 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
2197 "Toolchains and linker inputs sizes do not match.");
2200 auto TC = ToolChains.begin();
2201 for (
auto &LI : DeviceLinkerInputs) {
2202 auto *DeviceLinkAction =
2204 DA.
add(*DeviceLinkAction, **TC,
nullptr,
2210 bool initialize()
override {
2214 for (
auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE;
2216 ToolChains.push_back(TI->second);
2218 DeviceLinkerInputs.resize(ToolChains.size());
2222 bool canUseBundlerUnbundler()
const override {
2239 OffloadingActionBuilder(
Compilation &C, DerivedArgList &Args,
2247 SpecializedBuilders.push_back(
new CudaActionBuilder(C, Args, Inputs));
2250 SpecializedBuilders.push_back(
new OpenMPActionBuilder(C, Args, Inputs));
2258 unsigned ValidBuilders = 0u;
2259 unsigned ValidBuildersSupportingBundling = 0u;
2260 for (
auto *SB : SpecializedBuilders) {
2261 IsValid = IsValid && !SB->initialize();
2264 if (SB->isValid()) {
2266 if (SB->canUseBundlerUnbundler())
2267 ++ValidBuildersSupportingBundling;
2271 ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling;
2274 ~OffloadingActionBuilder() {
2275 for (
auto *SB : SpecializedBuilders)
2284 addDeviceDependencesToHostAction(
Action *HostAction,
const Arg *InputArg,
2286 DeviceActionBuilder::PhasesTy &Phases) {
2290 if (SpecializedBuilders.empty())
2293 assert(HostAction &&
"Invalid host action!");
2298 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2299 unsigned InactiveBuilders = 0u;
2300 unsigned IgnoringBuilders = 0u;
2301 for (
auto *SB : SpecializedBuilders) {
2302 if (!SB->isValid()) {
2308 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
2313 if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host)
2318 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2319 OffloadKind |= SB->getAssociatedOffloadKind();
2324 if (IgnoringBuilders &&
2325 SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders))
2342 bool addHostDependenceToDeviceActions(
Action *&HostAction,
2343 const Arg *InputArg) {
2353 if (CanUseBundler && isa<InputAction>(HostAction) &&
2354 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
2356 auto UnbundlingHostAction =
2361 HostAction = UnbundlingHostAction;
2364 assert(HostAction &&
"Invalid host action!");
2367 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2368 for (
auto *SB : SpecializedBuilders) {
2372 auto RetCode = SB->addDeviceDepences(HostAction);
2376 assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&
2377 "Host dependence not expected to be ignored.!");
2381 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2382 OffloadKind |= SB->getAssociatedOffloadKind();
2392 const Arg *InputArg) {
2395 for (
auto *SB : SpecializedBuilders) {
2398 SB->appendTopLevelActions(OffloadAL);
2403 if (CanUseBundler && !OffloadAL.empty()) {
2405 OffloadAL.push_back(HostAction);
2409 assert(HostAction == AL.back() &&
"Host action not in the list??");
2411 AL.back() = HostAction;
2413 AL.append(OffloadAL.begin(), OffloadAL.end());
2418 HostAction->propagateHostOffloadInfo(InputArgToOffloadKindMap[InputArg],
2430 for (
auto *SB : SpecializedBuilders) {
2434 SB->appendLinkDependences(DDeps);
2438 unsigned ActiveOffloadKinds = 0u;
2439 for (
auto &I : InputArgToOffloadKindMap)
2440 ActiveOffloadKinds |= I.second;
2457 nullptr, ActiveOffloadKinds);
2465 llvm::PrettyStackTraceString CrashInfo(
"Building compilation actions");
2467 if (!SuppressMissingInputWarning && Inputs.empty()) {
2468 Diag(clang::diag::err_drv_no_input_files);
2473 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
2476 if (Args.hasArg(options::OPT_emit_llvm))
2477 Diag(clang::diag::err_drv_emit_llvm_link);
2479 !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower(
"lld"))
2480 Diag(clang::diag::err_drv_lto_without_lld);
2485 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
2486 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
2489 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
2490 StringRef V = A->getValue();
2491 if (Inputs.size() > 1 && !V.empty() &&
2492 !llvm::sys::path::is_separator(V.back())) {
2494 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
2495 << A->getSpelling() << V;
2496 Args.eraseArg(options::OPT__SLASH_Fo);
2501 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
2502 StringRef V = A->getValue();
2503 if (Inputs.size() > 1 && !V.empty() &&
2504 !llvm::sys::path::is_separator(V.back())) {
2506 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
2507 << A->getSpelling() << V;
2508 Args.eraseArg(options::OPT__SLASH_Fa);
2513 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
2514 if (A->getValue()[0] ==
'\0') {
2516 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
2517 Args.eraseArg(options::OPT__SLASH_o);
2525 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
2526 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
2527 if (YcArg && YcArg->getValue()[0] ==
'\0') {
2528 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YcArg->getSpelling();
2529 Args.eraseArg(options::OPT__SLASH_Yc);
2532 if (YuArg && YuArg->getValue()[0] ==
'\0') {
2533 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
2534 Args.eraseArg(options::OPT__SLASH_Yu);
2537 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
2538 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
2539 Args.eraseArg(options::OPT__SLASH_Yc);
2540 Args.eraseArg(options::OPT__SLASH_Yu);
2541 YcArg = YuArg =
nullptr;
2543 if (YcArg || YuArg) {
2544 StringRef Val = YcArg ? YcArg->getValue() : YuArg->getValue();
2545 bool FoundMatchingInclude =
false;
2546 for (
const Arg *Inc : Args.filtered(options::OPT_include)) {
2548 if (Inc->getValue() == Val)
2549 FoundMatchingInclude =
true;
2551 if (!FoundMatchingInclude) {
2552 Diag(clang::diag::warn_drv_ycyu_no_fi_arg_clang_cl)
2553 << (YcArg ? YcArg : YuArg)->getSpelling();
2554 Args.eraseArg(options::OPT__SLASH_Yc);
2555 Args.eraseArg(options::OPT__SLASH_Yu);
2556 YcArg = YuArg =
nullptr;
2559 if (YcArg && Inputs.size() > 1) {
2560 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
2561 Args.eraseArg(options::OPT__SLASH_Yc);
2564 if (Args.hasArg(options::OPT__SLASH_Y_)) {
2567 Args.eraseArg(options::OPT__SLASH_Fp);
2568 Args.eraseArg(options::OPT__SLASH_Yc);
2569 Args.eraseArg(options::OPT__SLASH_Yu);
2570 YcArg = YuArg =
nullptr;
2574 OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
2580 for (
auto &I : Inputs) {
2582 const Arg *InputArg = I.second;
2590 if (InitialPhase > FinalPhase) {
2595 if (Args.hasArg(options::OPT_Qunused_arguments))
2601 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
2602 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase);
2608 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
2609 << InputArg->getAsString(Args) << !!FinalPhaseArg
2610 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
2612 Diag(clang::diag::warn_drv_input_file_unused)
2613 << InputArg->getAsString(Args) <<
getPhaseName(InitialPhase)
2615 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() :
"");
2625 Arg *PchInputArg =
MakeInputArg(Args, *Opts, YcArg->getValue());
2633 Actions.push_back(ClangClPch);
2645 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
2653 if (Phase > FinalPhase)
2657 Current = OffloadBuilder.addDeviceDependencesToHostAction(
2658 Current, InputArg, Phase, FinalPhase, PL);
2664 assert((i + 1) == e &&
"linking must be final compilation step.");
2665 LinkerInputs.push_back(Current);
2674 if (NewCurrent == Current)
2677 Current = NewCurrent;
2681 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
2684 if (Current->
getType() == types::TY_Nothing)
2690 Actions.push_back(Current);
2693 OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg);
2697 if (!LinkerInputs.empty()) {
2699 LA = OffloadBuilder.processHostLinkAction(LA);
2700 Actions.push_back(LA);
2706 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
2707 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
2711 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
2715 Args.ClaimAllArgs(options::OPT_cuda_host_only);
2716 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
2721 llvm::PrettyStackTraceString CrashInfo(
"Constructing phase actions");
2732 llvm_unreachable(
"link action invalid here.");
2736 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
2737 OutputTy = types::TY_Dependencies;
2740 if (!Args.hasFlag(options::OPT_frewrite_includes,
2741 options::OPT_fno_rewrite_includes,
false) &&
2742 !Args.hasFlag(options::OPT_frewrite_imports,
2743 options::OPT_fno_rewrite_imports,
false) &&
2747 "Cannot preprocess this input type!");
2754 "Cannot precompile this input type!");
2755 if (Args.hasArg(options::OPT_fsyntax_only)) {
2757 OutputTy = types::TY_Nothing;
2762 if (Args.hasArg(options::OPT_fsyntax_only))
2764 if (Args.hasArg(options::OPT_rewrite_objc))
2766 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
2768 types::TY_RewrittenLegacyObjC);
2769 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
2771 if (Args.hasArg(options::OPT__migrate))
2773 if (Args.hasArg(options::OPT_emit_ast))
2775 if (Args.hasArg(options::OPT_module_file_info))
2777 if (Args.hasArg(options::OPT_verify_pch))
2784 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
2787 if (Args.hasArg(options::OPT_emit_llvm)) {
2789 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
2798 llvm_unreachable(
"invalid phase in ConstructPhaseAction");
2802 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
2804 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
2809 unsigned NumOutputs = 0;
2811 if (A->
getType() != types::TY_Nothing)
2814 if (NumOutputs > 1) {
2815 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
2816 FinalOutput =
nullptr;
2821 llvm::StringSet<> ArchNames;
2823 for (
const Arg *A : C.
getArgs())
2824 if (A->getOption().matches(options::OPT_arch))
2825 ArchNames.insert(A->getValue());
2828 std::map<std::pair<const Action *, std::string>,
InputInfo> CachedResults;
2836 const char *LinkingOutput =
nullptr;
2837 if (isa<LipoJobAction>(A)) {
2839 LinkingOutput = FinalOutput->getValue();
2847 ArchNames.size() > 1,
2848 LinkingOutput, CachedResults,
2855 C.
getArgs().hasArg(options::OPT_Qunused_arguments))
2859 (void)C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH);
2862 (void)C.
getArgs().hasArg(options::OPT_driver_mode);
2863 (void)C.
getArgs().hasArg(options::OPT_rsp_quoting);
2869 if (!A->isClaimed()) {
2875 const Option &Opt = A->getOption();
2876 if (Opt.getKind() == Option::FlagClass) {
2877 bool DuplicateClaimed =
false;
2879 for (
const Arg *AA : C.
getArgs().filtered(&Opt)) {
2880 if (AA->isClaimed()) {
2881 DuplicateClaimed =
true;
2886 if (DuplicateClaimed)
2892 if (!
IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
2893 Diag(clang::diag::warn_drv_unused_argument)
2894 << A->getAsString(C.
getArgs());
2902 class ToolSelector final {
2913 bool IsHostSelector;
2924 bool CanBeCollapsed =
true) {
2926 if (Inputs.size() != 1)
2929 Action *CurAction = *Inputs.begin();
2930 if (CanBeCollapsed &&
2936 if (
auto *OA = dyn_cast<OffloadAction>(CurAction)) {
2940 if (!IsHostSelector) {
2941 if (OA->hasSingleDeviceDependence(
true)) {
2943 OA->getSingleDeviceDependence(
true);
2944 if (CanBeCollapsed &&
2947 SavedOffloadAction.push_back(OA);
2950 }
else if (OA->hasHostDependence()) {
2951 CurAction = OA->getHostDependence();
2952 if (CanBeCollapsed &&
2955 SavedOffloadAction.push_back(OA);
2965 bool canCollapseAssembleAction()
const {
2966 return TC.useIntegratedAs() && !SaveTemps &&
2967 !C.
getArgs().hasArg(options::OPT_via_file_asm) &&
2968 !C.
getArgs().hasArg(options::OPT__SLASH_FA) &&
2969 !C.
getArgs().hasArg(options::OPT__SLASH_Fa);
2973 bool canCollapsePreprocessorAction()
const {
2974 return !C.
getArgs().hasArg(options::OPT_no_integrated_cpp) &&
2975 !C.
getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
2976 !C.
getArgs().hasArg(options::OPT_rewrite_objc);
2981 struct JobActionInfo final {
2991 static void AppendCollapsedOffloadAction(
ActionList &CollapsedOffloadAction,
2993 unsigned ElementNum) {
2994 assert(ElementNum <= ActionInfo.size() &&
"Invalid number of elements.");
2995 for (
unsigned I = 0; I < ElementNum; ++
I)
2996 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
2997 ActionInfo[
I].SavedOffloadAction.end());
3013 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
3018 if (!AJ || !BJ || !CJ)
3022 const Tool *T = TC.SelectTool(*CJ);
3029 const Tool *BT = TC.SelectTool(*BJ);
3037 Inputs = &CJ->getInputs();
3038 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3045 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
3054 auto *CJ = getPrevDependentAction(BJ->getInputs(), CompileJobOffloadActions,
3056 if (!AJ || !BJ || !CJ)
3059 assert(isa<CompileJobAction>(CJ) &&
3060 "Expecting compile job preceding backend job.");
3063 const Tool *T = TC.SelectTool(*CJ);
3070 Inputs = &BJ->getInputs();
3071 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3078 if (ActionInfo.size() < 2 || !canCollapsePreprocessorAction())
3086 const Tool *T = TC.SelectTool(*CJ);
3093 Inputs = &CJ->getInputs();
3094 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
3103 void combineWithPreprocessor(
const Tool *T,
const ActionList *&Inputs,
3110 auto *PJ = getPrevDependentAction(*Inputs, PreprocessJobOffloadActions);
3111 if (!PJ || !isa<PreprocessJobAction>(PJ))
3116 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
3117 PreprocessJobOffloadActions.end());
3118 Inputs = &PJ->getInputs();
3123 const Compilation &C,
bool SaveTemps,
bool EmbedBitcode)
3124 : TC(TC), C(C), BaseAction(BaseAction), SaveTemps(SaveTemps),
3125 EmbedBitcode(EmbedBitcode) {
3126 assert(BaseAction &&
"Invalid base action.");
3143 ActionChain.back().JA = BaseAction;
3144 while (ActionChain.back().JA) {
3145 const Action *CurAction = ActionChain.back().JA;
3148 ActionChain.resize(ActionChain.size() + 1);
3149 JobActionInfo &AI = ActionChain.back();
3153 getPrevDependentAction(CurAction->
getInputs(), AI.SavedOffloadAction);
3157 ActionChain.pop_back();
3165 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
3166 CollapsedOffloadAction);
3168 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
3170 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
3176 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
3188 StringRef BoundArch,
3190 std::string TriplePlusArch = TC->
getTriple().normalize();
3191 if (!BoundArch.empty()) {
3192 TriplePlusArch +=
"-";
3193 TriplePlusArch += BoundArch;
3195 TriplePlusArch +=
"-";
3197 return TriplePlusArch;
3202 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3203 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3205 std::pair<const Action *, std::string> ActionTC = {
3207 auto CachedResult = CachedResults.find(ActionTC);
3208 if (CachedResult != CachedResults.end()) {
3209 return CachedResult->second;
3212 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
3213 CachedResults, TargetDeviceOffloadKind);
3214 CachedResults[ActionTC] = Result;
3218 InputInfo Driver::BuildJobsForActionNoCache(
3220 bool AtTopLevel,
bool MultipleArchs,
const char *LinkingOutput,
3221 std::map<std::pair<const Action *, std::string>,
InputInfo> &CachedResults,
3223 llvm::PrettyStackTraceString CrashInfo(
"Building compilation jobs");
3226 bool BuildingForOffloadDevice = TargetDeviceOffloadKind !=
Action::OFK_None;
3252 if (OA->hasSingleDeviceDependence()) {
3254 OA->doOnEachDeviceDependence([&](
Action *DepA,
const ToolChain *DepTC,
3255 const char *DepBoundArch) {
3258 !!DepBoundArch, LinkingOutput,
3268 OA->doOnEachDependence(
3269 BuildingForOffloadDevice,
3272 C, DepA, DepTC, DepBoundArch,
false,
3273 !!DepBoundArch, LinkingOutput, CachedResults,
3277 A = BuildingForOffloadDevice
3278 ? OA->getSingleDeviceDependence(
true)
3279 : OA->getHostDependence();
3282 if (
const InputAction *IA = dyn_cast<InputAction>(A)) {
3285 const Arg &
Input = IA->getInputArg();
3287 if (Input.getOption().matches(options::OPT_INPUT)) {
3288 const char *
Name = Input.getValue();
3298 if (!ArchName.empty())
3299 TC = &getToolChain(C.
getArgs(),
3306 MultipleArchs, LinkingOutput, CachedResults,
3307 TargetDeviceOffloadKind);
3313 const JobAction *JA = cast<JobAction>(A);
3318 const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions);
3325 for (
const auto *OA : CollapsedOffloadActions)
3326 cast<OffloadAction>(OA)->doOnEachDependence(
3327 BuildingForOffloadDevice,
3330 C, DepA, DepTC, DepBoundArch,
false,
3331 !!DepBoundArch, LinkingOutput, CachedResults,
3337 for (
const Action *Input : *Inputs) {
3341 bool SubJobAtTopLevel =
3342 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
3344 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
3349 const char *BaseInput = InputInfos[0].getBaseInput();
3353 if (JA->
getType() == types::TY_dSYM)
3354 BaseInput = InputInfos[0].getFilename();
3357 if (!OffloadDependencesInputInfo.empty())
3358 InputInfos.append(OffloadDependencesInputInfo.begin(),
3359 OffloadDependencesInputInfo.end());
3362 llvm::Triple EffectiveTriple;
3364 const ArgList &Args =
3366 if (InputInfos.size() != 1) {
3370 EffectiveTriple = llvm::Triple(
3378 if (
auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) {
3382 for (
auto &UI : UA->getDependentActionsInfo()) {
3384 "Unbundling with no offloading??");
3391 UI.DependentOffloadKind,
3392 UI.DependentToolChain->getTriple().normalize(),
3396 false, MultipleArchs,
3400 UnbundlingResults.push_back(CurI);
3405 UI.DependentToolChain, UI.DependentBoundArch,
3406 UI.DependentOffloadKind)}] = CurI;
3411 std::pair<const Action *, std::string> ActionTC = {
3413 assert(CachedResults.find(ActionTC) != CachedResults.end() &&
3414 "Result does not exist??");
3415 Result = CachedResults[ActionTC];
3416 }
else if (JA->
getType() == types::TY_Nothing)
3426 AtTopLevel, MultipleArchs,
3433 <<
" - \"" << T->
getName() <<
"\", inputs: [";
3434 for (
unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
3435 llvm::errs() << InputInfos[i].getAsString();
3437 llvm::errs() <<
", ";
3439 if (UnbundlingResults.empty())
3440 llvm::errs() <<
"], output: " << Result.getAsString() <<
"\n";
3442 llvm::errs() <<
"], outputs: [";
3443 for (
unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) {
3444 llvm::errs() << UnbundlingResults[i].getAsString();
3446 llvm::errs() <<
", ";
3448 llvm::errs() <<
"] \n";
3451 if (UnbundlingResults.empty())
3453 C, *JA, Result, InputInfos,
3458 C, *JA, UnbundlingResults, InputInfos,
3467 return Target.isOSWindows() ?
"a.exe" :
"a.out";
3479 if (ArgValue.empty()) {
3481 Filename = BaseName;
3482 }
else if (llvm::sys::path::is_separator(Filename.back())) {
3484 llvm::sys::path::append(Filename, BaseName);
3487 if (!llvm::sys::path::has_extension(ArgValue)) {
3491 if (FileType == types::TY_Image &&
3492 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
3497 llvm::sys::path::replace_extension(Filename, Extension);
3500 return Args.MakeArgString(Filename.c_str());
3504 const char *BaseInput,
3505 StringRef BoundArch,
bool AtTopLevel,
3507 StringRef OffloadingPrefix)
const {
3508 llvm::PrettyStackTraceString CrashInfo(
"Computing output path");
3510 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
3511 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
3516 if (C.
getArgs().hasArg(options::OPT__SLASH_P)) {
3517 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
3518 StringRef BaseName = llvm::sys::path::filename(BaseInput);
3520 if (Arg *A = C.
getArgs().getLastArg(options::OPT__SLASH_Fi))
3521 NameArg = A->getValue();
3529 (isa<PreprocessJobAction>(JA) || JA.
getType() == types::TY_ModuleFile))
3533 if (JA.
getType() == types::TY_PP_Asm &&
3534 (C.
getArgs().hasArg(options::OPT__SLASH_FA) ||
3535 C.
getArgs().hasArg(options::OPT__SLASH_Fa))) {
3537 StringRef BaseName = llvm::sys::path::filename(BaseInput);
3538 StringRef FaValue = C.
getArgs().getLastArgValue(options::OPT__SLASH_Fa);
3546 !C.
getArgs().hasArg(options::OPT__SLASH_Fo)) ||
3548 StringRef
Name = llvm::sys::path::filename(BaseInput);
3549 std::pair<StringRef, StringRef> Split = Name.split(
'.');
3559 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
3560 BaseName = BasePath;
3562 BaseName = llvm::sys::path::filename(BasePath);
3565 const char *NamedOutput;
3567 if ((JA.
getType() == types::TY_Object || JA.
getType() == types::TY_LTO_BC) &&
3568 C.
getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
3572 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
3576 }
else if (JA.
getType() == types::TY_Image &&
3577 C.
getArgs().hasArg(options::OPT__SLASH_Fe,
3578 options::OPT__SLASH_o)) {
3582 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
3586 }
else if (JA.
getType() == types::TY_Image) {
3593 Output += OffloadingPrefix;
3594 if (MultipleArchs && !BoundArch.empty()) {
3596 Output.append(BoundArch);
3598 NamedOutput = C.
getArgs().MakeArgString(Output.c_str());
3604 assert(Suffix &&
"All types used for output should have a suffix.");
3606 std::string::size_type
End = std::string::npos;
3608 End = BaseName.rfind(
'.');
3610 Suffixed += OffloadingPrefix;
3611 if (MultipleArchs && !BoundArch.empty()) {
3613 Suffixed.append(BoundArch);
3618 if (!AtTopLevel && C.
getArgs().hasArg(options::OPT_emit_llvm) &&
3619 JA.
getType() == types::TY_LLVM_BC)
3623 NamedOutput = C.
getArgs().MakeArgString(Suffixed.c_str());
3628 JA.
getType() != types::TY_PCH) {
3629 Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o);
3631 llvm::sys::path::remove_filename(TempPath);
3632 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
3633 llvm::sys::path::append(TempPath, OutputFileName);
3634 NamedOutput = C.
getArgs().MakeArgString(TempPath.c_str());
3640 bool SameFile =
false;
3642 llvm::sys::fs::current_path(Result);
3643 llvm::sys::path::append(Result, BaseName);
3644 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
3647 StringRef
Name = llvm::sys::path::filename(BaseInput);
3648 std::pair<StringRef, StringRef> Split = Name.split(
'.');
3657 llvm::sys::path::remove_filename(BasePath);
3658 if (BasePath.empty())
3659 BasePath = NamedOutput;
3661 llvm::sys::path::append(BasePath, NamedOutput);
3675 llvm::sys::path::append(
P, Name);
3676 if (llvm::sys::fs::exists(Twine(
P)))
3681 llvm::sys::path::append(P, Name);
3682 if (llvm::sys::fs::exists(Twine(P)))
3689 llvm::sys::path::append(P, Name);
3690 if (llvm::sys::fs::exists(Twine(P)))
3697 void Driver::generatePrefixedToolNames(
3701 Names.emplace_back((DefaultTargetTriple +
"-" + Tool).str());
3702 Names.emplace_back(Tool);
3705 std::string LLVMDefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
3706 if (LLVMDefaultTargetTriple != DefaultTargetTriple)
3707 Names.emplace_back((LLVMDefaultTargetTriple +
"-" + Tool).str());
3712 for (
const auto &
Name : Names) {
3713 llvm::sys::path::append(Dir,
Name);
3714 if (llvm::sys::fs::can_execute(Twine(Dir)))
3716 llvm::sys::path::remove_filename(Dir);
3723 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
3728 if (llvm::sys::fs::is_directory(PrefixDir)) {
3734 if (llvm::sys::fs::can_execute(Twine(P)))
3740 for (
const auto &Path : List) {
3747 for (
const auto &TargetSpecificExecutable : TargetSpecificExecutables)
3748 if (llvm::ErrorOr<std::string>
P =
3749 llvm::sys::findProgramByName(TargetSpecificExecutable))
3757 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
3759 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
3768 if (Arg *FpArg = C.
getArgs().getLastArg(options::OPT__SLASH_Fp)) {
3772 Output = FpArg->getValue();
3776 if (!llvm::sys::path::has_extension(Output))
3780 llvm::sys::path::replace_extension(Output,
".pch");
3782 return Output.str();
3785 const ToolChain &Driver::getToolChain(
const ArgList &Args,
3786 const llvm::Triple &Target)
const {
3788 auto &TC = ToolChains[Target.str()];
3790 switch (Target.getOS()) {
3791 case llvm::Triple::Haiku:
3792 TC = llvm::make_unique<toolchains::Haiku>(*
this, Target, Args);
3794 case llvm::Triple::Ananas:
3795 TC = llvm::make_unique<toolchains::Ananas>(*
this, Target, Args);
3797 case llvm::Triple::CloudABI:
3798 TC = llvm::make_unique<toolchains::CloudABI>(*
this, Target, Args);
3800 case llvm::Triple::Darwin:
3801 case llvm::Triple::MacOSX:
3802 case llvm::Triple::IOS:
3803 case llvm::Triple::TvOS:
3804 case llvm::Triple::WatchOS:
3805 TC = llvm::make_unique<toolchains::DarwinClang>(*
this, Target, Args);
3807 case llvm::Triple::DragonFly:
3808 TC = llvm::make_unique<toolchains::DragonFly>(*
this, Target, Args);
3810 case llvm::Triple::OpenBSD:
3811 TC = llvm::make_unique<toolchains::OpenBSD>(*
this, Target, Args);
3813 case llvm::Triple::Bitrig:
3814 TC = llvm::make_unique<toolchains::Bitrig>(*
this, Target, Args);
3816 case llvm::Triple::NetBSD:
3817 TC = llvm::make_unique<toolchains::NetBSD>(*
this, Target, Args);
3819 case llvm::Triple::FreeBSD:
3820 TC = llvm::make_unique<toolchains::FreeBSD>(*
this, Target, Args);
3822 case llvm::Triple::Minix:
3823 TC = llvm::make_unique<toolchains::Minix>(*
this, Target, Args);
3825 case llvm::Triple::Linux:
3826 case llvm::Triple::ELFIAMCU:
3827 if (Target.getArch() == llvm::Triple::hexagon)
3828 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
3830 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
3831 !Target.hasEnvironment())
3832 TC = llvm::make_unique<toolchains::MipsLLVMToolChain>(*
this, Target,
3835 TC = llvm::make_unique<toolchains::Linux>(*
this, Target, Args);
3837 case llvm::Triple::NaCl:
3838 TC = llvm::make_unique<toolchains::NaClToolChain>(*
this, Target, Args);
3840 case llvm::Triple::Fuchsia:
3841 TC = llvm::make_unique<toolchains::Fuchsia>(*
this, Target, Args);
3843 case llvm::Triple::Solaris:
3844 TC = llvm::make_unique<toolchains::Solaris>(*
this, Target, Args);
3846 case llvm::Triple::AMDHSA:
3847 TC = llvm::make_unique<toolchains::AMDGPUToolChain>(*
this, Target, Args);
3849 case llvm::Triple::Win32:
3850 switch (Target.getEnvironment()) {
3852 if (Target.isOSBinFormatELF())
3853 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
3854 else if (Target.isOSBinFormatMachO())
3855 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
3857 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
3859 case llvm::Triple::GNU:
3860 TC = llvm::make_unique<toolchains::MinGW>(*
this, Target, Args);
3862 case llvm::Triple::Itanium:
3863 TC = llvm::make_unique<toolchains::CrossWindowsToolChain>(*
this, Target,
3866 case llvm::Triple::MSVC:
3867 case llvm::Triple::UnknownEnvironment:
3868 TC = llvm::make_unique<toolchains::MSVCToolChain>(*
this, Target, Args);
3872 case llvm::Triple::PS4:
3873 TC = llvm::make_unique<toolchains::PS4CPU>(*
this, Target, Args);
3875 case llvm::Triple::Contiki:
3876 TC = llvm::make_unique<toolchains::Contiki>(*
this, Target, Args);
3881 switch (Target.getArch()) {
3882 case llvm::Triple::tce:
3883 TC = llvm::make_unique<toolchains::TCEToolChain>(*
this, Target, Args);
3885 case llvm::Triple::tcele:
3886 TC = llvm::make_unique<toolchains::TCELEToolChain>(*
this, Target, Args);
3888 case llvm::Triple::hexagon:
3889 TC = llvm::make_unique<toolchains::HexagonToolChain>(*
this, Target,
3892 case llvm::Triple::lanai:
3893 TC = llvm::make_unique<toolchains::LanaiToolChain>(*
this, Target, Args);
3895 case llvm::Triple::xcore:
3896 TC = llvm::make_unique<toolchains::XCoreToolChain>(*
this, Target, Args);
3898 case llvm::Triple::wasm32:
3899 case llvm::Triple::wasm64:
3900 TC = llvm::make_unique<toolchains::WebAssembly>(*
this, Target, Args);
3902 case llvm::Triple::avr:
3903 TC = llvm::make_unique<toolchains::AVRToolChain>(*
this, Target, Args);
3906 if (Target.getVendor() == llvm::Triple::Myriad)
3907 TC = llvm::make_unique<toolchains::MyriadToolChain>(*
this, Target,
3910 TC = llvm::make_unique<toolchains::BareMetal>(*
this, Target, Args);
3911 else if (Target.isOSBinFormatELF())
3912 TC = llvm::make_unique<toolchains::Generic_ELF>(*
this, Target, Args);
3913 else if (Target.isOSBinFormatMachO())
3914 TC = llvm::make_unique<toolchains::MachO>(*
this, Target, Args);
3916 TC = llvm::make_unique<toolchains::Generic_GCC>(*
this, Target, Args);
3931 if (JA.
size() != 1 ||
3936 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
3937 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
3949 unsigned &Micro,
bool &HadExtra) {
3952 Major = Minor = Micro = 0;
3956 if (Str.consumeInteger(10, Major))
3963 Str = Str.drop_front(1);
3965 if (Str.consumeInteger(10, Minor))
3971 Str = Str.drop_front(1);
3973 if (Str.consumeInteger(10, Micro))
3991 unsigned CurDigit = 0;
3992 while (CurDigit < Digits.size()) {
3994 if (Str.consumeInteger(10, Digit))
3996 Digits[CurDigit] = Digit;
4001 Str = Str.drop_front(1);
4009 std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks()
const {
4010 unsigned IncludedFlagsBitmask = 0;
4013 if (Mode == CLMode) {
4021 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
4025 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group,
false);
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
const ActionList & getActions() const
Get each of the individual arrays.
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...
const Driver & getDriver() const
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.
const char * CudaArchToString(CudaArch A)
const ArgStringMap & getResultFiles() const
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
bool canLipoType(ID Id)
canLipoType - Is this type acceptable as the output of a universal build (currently, just the Nothing, Image, and Object types).
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...
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 * getExecutable() const
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 setResponseFile(const char *FileName)
Set to pass arguments via a response file when launching the command.
bool hasErrorOccurred() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
const llvm::opt::OptTable & getOpts() const
std::string DyldPrefix
Dynamic loader prefix, if present.
static StringRef getCategoryNameFromID(unsigned CategoryID)
Given a category ID, return the name of the category.
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
DiagnosticBuilder Diag(unsigned DiagID) const
bool hasOffloadToolChain() const
Return true if an offloading tool chain of a given kind exists.
CudaArch StringToCudaArch(llvm::StringRef S)
Compilation * BuildCompilation(ArrayRef< const char * > Args)
BuildCompilation - Construct a compilation object for a command line argument vector.
Type used to communicate device actions.
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.
const Tool & getCreator() const
getCreator - Return the Tool which caused the creation of this job.
RAII class that determines when any errors have occurred between the time the instance was created an...
types::ID getType() const
void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch, OffloadKind Kind)
Register information about a dependent action.
bool ShouldUseClangCompiler(const JobAction &JA) const
ShouldUseClangCompiler - Should the clang compiler be used to handle this action. ...
T * MakeAction(Args &&...Arg)
Creates a new Action owned by this Compilation.
float __ovld __cnfn normalize(float p)
Returns a vector in the same direction as p but with a length of 1.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
bool embedBitcodeInObject() const
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)
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...
llvm::opt::InputArgList ParseArgStrings(ArrayRef< const char * > Args, bool &ContainsError)
ParseArgStrings - Parse the given list of strings into an ArgList.
static bool ScanDirForExecutable(SmallString< 128 > &Dir, ArrayRef< std::string > Names)
void PrintHelp(bool ShowHidden) const
PrintHelp - Print the help text.
OffloadKind getOffloadingDeviceKind() const
void PrintActions(const Compilation &C) const
PrintActions - Print the list of actions.
std::string Dir
The path the driver executable was in, as invoked from the command line.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
ID lookupCXXTypeForCType(ID Id)
lookupCXXTypeForCType - Lookup CXX input type that corresponds to given C type (used for clang++ emul...
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
Type used to communicate host actions.
ActionClass getKind() const
unsigned getOffloadingHostActiveKinds() const
virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const
static unsigned getNumberOfCategories()
Return the number of diagnostic categories.
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...
bool isCollapsingWithNextDependentActionLegal() const
Return true if this function can be collapsed with others.
std::string getOffloadingKindPrefix() const
Return a string containing the offload kind of the action.
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.
const llvm::opt::DerivedArgList & getArgs() const
void BuildActions(Compilation &C, llvm::opt::DerivedArgList &Args, const InputList &Inputs, ActionList &Actions) const
BuildActions - Construct the list of actions to perform for the given arguments, which are only done ...
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
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 Action & getSource() const
getSource - Return the Action which caused the creation of this job.
detail::InMemoryDirectory::const_iterator I
void PrintVersion(const Compilation &C, raw_ostream &OS) const
PrintVersion - Print the driver version.
input_iterator input_begin()
bool isSaveTempsEnabled() const
void ParseDriverMode(StringRef ProgramName, ArrayRef< const char * > Args)
ParseDriverMode - Look for and handle the driver mode option in Args.
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.
bool getCheckInputsExist() 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.
static Arg * MakeInputArg(DerivedArgList &Args, OptTable &Opts, StringRef Value)
const char * getPhaseName(ID Id)
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
Defines version macros and version-related utility functions for Clang.
bool CleanupFileList(const llvm::opt::ArgStringList &Files, bool IssueErrors=false) const
CleanupFileList - Remove the files in the given list.
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
const char * getOffloadingArch() const
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'...
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...
void setCannotBeCollapsedWithNextDependentAction()
Mark this action as not legal to collapse.
static void PrintDiagnosticCategories(raw_ostream &OS)
PrintDiagnosticCategories - Implement the –print-diagnostic-categories option.
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...
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
static void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote)
Print a command argument, and optionally quote it.
bool UseStdLib
If the standard library is used.
bool CleanupFileMap(const ArgStringMap &Files, const JobAction *JA, bool IssueErrors=false) const
CleanupFileMap - Remove the files in the given map.
static unsigned PrintActions1(const Compilation &C, Action *A, std::map< Action *, unsigned > &Ids)
Encodes a location in the source.
void BuildJobs(Compilation &C) const
BuildJobs - Bind actions to concrete tools and translate arguments to form the list of jobs to run...
const_offload_toolchains_range getOffloadToolChains() const
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 isSaveTempsObj() const
const char * addResultFile(const char *Name, const JobAction *JA)
addResultFile - Add a file to remove on failure, and returns its argument.
static std::vector< std::string > getDiagnosticFlags()
Get the string of all diagnostic flags.
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 llvm::opt::ArgStringList & getArguments() const
const ToolChain & getDefaultToolChain() const
void setIgnoreAllWarnings(bool Val)
When set to true, any unmapped warnings are ignored.
const char * getDefaultImageName() const
Returns the default name for linked images (e.g., "a.out").
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)
unsigned CCCPrintBindings
Only print tool bindings, don't build any jobs.
const ArgStringMap & getFailureResultFiles() const
const char * getClassName() 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.
detail::InMemoryDirectory::const_iterator E
ActionList & getActions()
std::string ClangExecutable
The original path to the clang executable.
std::string GetFilePath(StringRef Name, const ToolChain &TC) const
GetFilePath - Lookup Name in the list of file search paths.
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.
void ExecuteJobs(const JobList &Jobs, SmallVectorImpl< std::pair< int, const Command * >> &FailingCommands) const
ExecuteJob - Execute a single job.
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.
Compilation - A set of tasks to perform for a single driver invocation.
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.
const llvm::opt::InputArgList & getInputArgs() const
void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
StringRef getSysRoot() const
Returns the sysroot path.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
void propagateHostOffloadInfo(unsigned OKinds, const char *OArch)
Append the host offload info of this action and propagate it to its dependences.
const llvm::opt::ArgStringList & getTempFiles() const
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.
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
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 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.
void initCompilationForDiagnostics()
initCompilationForDiagnostics - Remove stale state and suppress output so compilation can be reexecut...
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
bool isSrcFile(ID Id)
isSrcFile - Is this a source file, i.e.
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
std::string ResourceDir
The path to the compiler resource directory.