32 #include "llvm/ADT/StringExtras.h" 33 #include "llvm/Config/llvm-config.h" 34 #include "llvm/Option/ArgList.h" 35 #include "llvm/Support/CodeGen.h" 36 #include "llvm/Support/Compression.h" 37 #include "llvm/Support/FileSystem.h" 38 #include "llvm/Support/Path.h" 39 #include "llvm/Support/Process.h" 40 #include "llvm/Support/TargetParser.h" 41 #include "llvm/Support/YAMLParser.h" 49 using namespace clang;
54 Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
55 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
56 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
57 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
58 << A->getBaseArg().getAsString(Args)
59 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
66 if (Args.hasArg(options::OPT_static))
68 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
69 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
94 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
99 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
115 Res.push_back(Target[i]);
124 llvm::function_ref<
void(
const ToolChain &)> Work) {
126 Work(RegularToolChain);
141 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
156 const Arg &A,
size_t &Position) {
157 const char RefinementStepToken =
':';
158 Position = In.find(RefinementStepToken);
159 if (Position != StringRef::npos) {
160 StringRef Option = A.getOption().getName();
161 StringRef RefStep = In.substr(Position + 1);
169 if (RefStep.size() != 1) {
170 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
173 char RefStepChar = RefStep[0];
174 if (RefStepChar < '0' || RefStepChar >
'9') {
175 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
184 ArgStringList &OutStrings) {
185 StringRef DisabledPrefixIn =
"!";
186 StringRef DisabledPrefixOut =
"!";
187 StringRef EnabledPrefixOut =
"";
188 StringRef Out =
"-mrecip=";
190 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
194 unsigned NumOptions = A->getNumValues();
195 if (NumOptions == 0) {
197 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
202 if (NumOptions == 1) {
203 StringRef Val = A->getValue(0);
207 StringRef ValBase = Val.slice(0, RefStepLoc);
208 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
209 OutStrings.push_back(Args.MakeArgString(Out + Val));
218 llvm::StringMap<bool> OptionStrings;
219 OptionStrings.insert(std::make_pair(
"divd",
false));
220 OptionStrings.insert(std::make_pair(
"divf",
false));
221 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
222 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
223 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
224 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
225 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
226 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
228 for (
unsigned i = 0; i != NumOptions; ++i) {
229 StringRef Val = A->getValue(i);
231 bool IsDisabled = Val.startswith(DisabledPrefixIn);
240 StringRef ValBase = Val.slice(0, RefStep);
241 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
242 if (OptionIter == OptionStrings.end()) {
244 OptionIter = OptionStrings.find(ValBase.str() +
'f');
245 if (OptionIter == OptionStrings.end()) {
247 D.
Diag(diag::err_drv_unknown_argument) << Val;
253 if (OptionStrings[ValBase.str() +
'd']) {
254 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
259 if (OptionIter->second ==
true) {
261 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
266 OptionIter->second =
true;
269 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
270 OptionStrings[ValBase.str() +
'd'] =
true;
273 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
274 Out = Args.MakeArgString(Out + Prefix + Val);
275 if (i != NumOptions - 1)
276 Out = Args.MakeArgString(Out +
",");
279 OutStrings.push_back(Args.MakeArgString(Out));
285 ArgStringList &CmdArgs) {
286 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
290 StringRef
Value = A->getValue();
291 if (Value ==
"none") {
292 CmdArgs.push_back(
"-mprefer-vector-width=none");
295 if (Value.getAsInteger(10, Width)) {
296 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
299 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + Value));
304 std::vector<StringRef> &Features) {
309 const ArgList &Args, ArgStringList &CmdArgs,
312 std::vector<StringRef> Features;
313 switch (Triple.getArch()) {
316 case llvm::Triple::mips:
317 case llvm::Triple::mipsel:
318 case llvm::Triple::mips64:
319 case llvm::Triple::mips64el:
323 case llvm::Triple::arm:
324 case llvm::Triple::armeb:
325 case llvm::Triple::thumb:
326 case llvm::Triple::thumbeb:
330 case llvm::Triple::ppc:
331 case llvm::Triple::ppc64:
332 case llvm::Triple::ppc64le:
335 case llvm::Triple::riscv32:
336 case llvm::Triple::riscv64:
339 case llvm::Triple::systemz:
342 case llvm::Triple::aarch64:
343 case llvm::Triple::aarch64_be:
346 case llvm::Triple::x86:
347 case llvm::Triple::x86_64:
350 case llvm::Triple::hexagon:
353 case llvm::Triple::wasm32:
354 case llvm::Triple::wasm64:
357 case llvm::Triple::sparc:
358 case llvm::Triple::sparcel:
359 case llvm::Triple::sparcv9:
362 case llvm::Triple::r600:
363 case llvm::Triple::amdgcn:
369 llvm::StringMap<unsigned> LastOpt;
370 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
371 StringRef Name = Features[I];
372 assert(Name[0] ==
'-' || Name[0] ==
'+');
373 LastOpt[Name.drop_front(1)] = I;
376 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
378 StringRef Name = Features[I];
379 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
380 assert(LastI != LastOpt.end());
381 unsigned Last = LastI->second;
385 CmdArgs.push_back(
"-target-feature");
386 CmdArgs.push_back(Name.data());
392 const llvm::Triple &Triple) {
399 if (!Triple.isMacOSX())
402 return (!Triple.isMacOSXVersionLT(10, 5) &&
403 (Triple.getArch() == llvm::Triple::x86_64 ||
404 Triple.getArch() == llvm::Triple::arm));
414 ArgStringList &CmdArgs) {
415 const llvm::Triple &Triple = TC.
getTriple();
420 Args.ClaimAllArgs(options::OPT_fexceptions);
421 Args.ClaimAllArgs(options::OPT_fno_exceptions);
422 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
423 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
424 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
425 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
430 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
436 Args.hasFlag(options::OPT_fobjc_exceptions,
437 options::OPT_fno_objc_exceptions,
true)) {
438 CmdArgs.push_back(
"-fobjc-exceptions");
445 bool CXXExceptionsEnabled =
446 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
447 Arg *ExceptionArg = Args.getLastArg(
448 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
449 options::OPT_fexceptions, options::OPT_fno_exceptions);
451 CXXExceptionsEnabled =
452 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
453 ExceptionArg->getOption().matches(options::OPT_fexceptions);
455 if (CXXExceptionsEnabled) {
456 CmdArgs.push_back(
"-fcxx-exceptions");
463 CmdArgs.push_back(
"-fexceptions");
473 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
479 bool UseDwarfDirectory =
480 Args.hasFlag(options::OPT_fdwarf_directory_asm,
482 return !UseDwarfDirectory;
488 assert(A.getOption().matches(options::OPT_gN_Group) &&
489 "Not a -g option that specifies a debug-info level");
490 if (A.getOption().matches(options::OPT_g0) ||
491 A.getOption().matches(options::OPT_ggdb0))
493 if (A.getOption().matches(options::OPT_gline_tables_only) ||
494 A.getOption().matches(options::OPT_ggdb1))
500 switch (Triple.getArch()){
503 case llvm::Triple::arm:
504 case llvm::Triple::thumb:
507 return Triple.isOSDarwin();
512 const llvm::Triple &Triple) {
513 switch (Triple.getArch()) {
514 case llvm::Triple::xcore:
515 case llvm::Triple::wasm32:
516 case llvm::Triple::wasm64:
520 case llvm::Triple::riscv32:
521 case llvm::Triple::riscv64:
527 if (Triple.getOS() == llvm::Triple::NetBSD) {
531 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI) {
532 switch (Triple.getArch()) {
534 case llvm::Triple::mips64:
535 case llvm::Triple::mips64el:
536 case llvm::Triple::mips:
537 case llvm::Triple::mipsel:
538 case llvm::Triple::ppc:
539 case llvm::Triple::ppc64:
540 case llvm::Triple::ppc64le:
541 case llvm::Triple::systemz:
542 case llvm::Triple::x86:
543 case llvm::Triple::x86_64:
550 if (Triple.isOSWindows()) {
551 switch (Triple.getArch()) {
552 case llvm::Triple::x86:
554 case llvm::Triple::x86_64:
555 return Triple.isOSBinFormatMachO();
556 case llvm::Triple::arm:
557 case llvm::Triple::thumb:
571 const llvm::Triple &Triple) {
572 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
573 options::OPT_fomit_frame_pointer))
574 return A->getOption().matches(options::OPT_fno_omit_frame_pointer) ||
577 if (Args.hasArg(options::OPT_pg))
584 const llvm::Triple &Triple) {
585 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
586 options::OPT_momit_leaf_frame_pointer))
587 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
589 if (Args.hasArg(options::OPT_pg))
592 if (Triple.isPS4CPU())
601 if (!llvm::sys::fs::current_path(cwd)) {
602 CmdArgs.push_back(
"-fdebug-compilation-dir");
603 CmdArgs.push_back(Args.MakeArgString(cwd));
609 for (
const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
610 StringRef Map = A->getValue();
611 if (Map.find(
'=') == StringRef::npos)
612 D.
Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map;
614 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
622 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
623 if (A->getOption().matches(options::OPT_O4) ||
624 A->getOption().matches(options::OPT_Ofast))
627 if (A->getOption().matches(options::OPT_O0))
630 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
633 StringRef S(A->getValue());
641 unsigned OptLevel = 0;
642 if (S.getAsInteger(10, OptLevel))
653 ArgStringList &CmdArgs) {
656 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
659 CmdArgs.push_back(
"-x");
660 if (Args.hasArg(options::OPT_rewrite_objc))
666 const char *ClangType;
668 case types::TY_CXXModule:
671 case types::TY_PP_CXXModule:
672 ClangType =
"c++-cpp-output";
678 CmdArgs.push_back(ClangType);
684 const char *Username = getenv(
"LOGNAME");
686 const char *Username = getenv(
"USERNAME");
691 for (
const char *
P = Username; *
P; ++
P, ++Len) {
698 if (Username && Len > 0) {
699 Result.append(Username, Username + Len);
706 std::string UID = llvm::utostr(getuid());
709 std::string UID =
"9999";
711 Result.append(UID.begin(), UID.end());
715 const InputInfo &Output,
const ArgList &Args,
716 ArgStringList &CmdArgs) {
718 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
719 options::OPT_fprofile_generate_EQ,
720 options::OPT_fno_profile_generate);
721 if (PGOGenerateArg &&
722 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
723 PGOGenerateArg =
nullptr;
725 auto *ProfileGenerateArg = Args.getLastArg(
726 options::OPT_fprofile_instr_generate,
727 options::OPT_fprofile_instr_generate_EQ,
728 options::OPT_fno_profile_instr_generate);
729 if (ProfileGenerateArg &&
730 ProfileGenerateArg->getOption().matches(
731 options::OPT_fno_profile_instr_generate))
732 ProfileGenerateArg =
nullptr;
734 if (PGOGenerateArg && ProfileGenerateArg)
735 D.
Diag(diag::err_drv_argument_not_allowed_with)
736 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
740 if (PGOGenerateArg && ProfileUseArg)
741 D.
Diag(diag::err_drv_argument_not_allowed_with)
742 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
744 if (ProfileGenerateArg && ProfileUseArg)
745 D.
Diag(diag::err_drv_argument_not_allowed_with)
746 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
748 if (ProfileGenerateArg) {
749 if (ProfileGenerateArg->getOption().matches(
750 options::OPT_fprofile_instr_generate_EQ))
751 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
752 ProfileGenerateArg->getValue()));
754 CmdArgs.push_back(
"-fprofile-instrument=clang");
757 if (PGOGenerateArg) {
758 CmdArgs.push_back(
"-fprofile-instrument=llvm");
759 if (PGOGenerateArg->getOption().matches(
760 options::OPT_fprofile_generate_EQ)) {
762 llvm::sys::path::append(Path,
"default_%m.profraw");
764 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
769 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
770 CmdArgs.push_back(Args.MakeArgString(
771 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
772 else if ((ProfileUseArg->getOption().matches(
773 options::OPT_fprofile_use_EQ) ||
774 ProfileUseArg->getOption().matches(
775 options::OPT_fprofile_instr_use))) {
777 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
778 if (Path.empty() || llvm::sys::fs::is_directory(Path))
779 llvm::sys::path::append(Path,
"default.profdata");
781 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
785 if (Args.hasArg(options::OPT_ftest_coverage) ||
786 Args.hasArg(options::OPT_coverage))
787 CmdArgs.push_back(
"-femit-coverage-notes");
788 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
790 Args.hasArg(options::OPT_coverage))
791 CmdArgs.push_back(
"-femit-coverage-data");
793 if (Args.hasFlag(options::OPT_fcoverage_mapping,
794 options::OPT_fno_coverage_mapping,
false)) {
795 if (!ProfileGenerateArg)
796 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
797 <<
"-fcoverage-mapping" 798 <<
"-fprofile-instr-generate";
800 CmdArgs.push_back(
"-fcoverage-mapping");
803 if (C.
getArgs().hasArg(options::OPT_c) ||
804 C.
getArgs().hasArg(options::OPT_S)) {
806 CmdArgs.push_back(
"-coverage-notes-file");
808 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
809 OutputFilename = FinalOutput->getValue();
811 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
813 if (llvm::sys::path::is_relative(CoverageFilename)) {
815 if (!llvm::sys::fs::current_path(Pwd)) {
816 llvm::sys::path::append(Pwd, CoverageFilename);
817 CoverageFilename.swap(Pwd);
820 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
821 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
827 if (Args.hasArg(options::OPT_fprofile_arcs) ||
828 Args.hasArg(options::OPT_coverage)) {
829 CmdArgs.push_back(
"-coverage-data-file");
830 if (Arg *FProfileDir = Args.getLastArg(options::OPT_fprofile_dir)) {
831 CoverageFilename = FProfileDir->getValue();
832 llvm::sys::path::append(CoverageFilename, OutputFilename);
834 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
835 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
843 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
846 for (
const auto &AI : A->
inputs())
856 bool RelaxDefault =
true;
858 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
859 RelaxDefault = A->getOption().matches(options::OPT_O0);
862 RelaxDefault =
false;
871 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
879 return llvm::StringSwitch<unsigned>(ArgValue)
880 .Case(
"-gdwarf-2", 2)
881 .Case(
"-gdwarf-3", 3)
882 .Case(
"-gdwarf-4", 4)
883 .Case(
"-gdwarf-5", 5)
889 unsigned DwarfVersion,
890 llvm::DebuggerKind DebuggerTuning) {
891 switch (DebugInfoKind) {
893 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
896 CmdArgs.push_back(
"-debug-info-kind=limited");
899 CmdArgs.push_back(
"-debug-info-kind=standalone");
904 if (DwarfVersion > 0)
906 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
907 switch (DebuggerTuning) {
908 case llvm::DebuggerKind::GDB:
909 CmdArgs.push_back(
"-debugger-tuning=gdb");
911 case llvm::DebuggerKind::LLDB:
912 CmdArgs.push_back(
"-debugger-tuning=lldb");
914 case llvm::DebuggerKind::SCE:
915 CmdArgs.push_back(
"-debugger-tuning=sce");
924 assert(A &&
"Expected non-nullptr argument.");
927 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
933 ArgStringList &CmdArgs,
936 const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ);
940 if (A->getOption().getID() == options::OPT_gz) {
941 if (llvm::zlib::isAvailable())
942 CmdArgs.push_back(
"-compress-debug-sections");
944 D.
Diag(diag::warn_debug_compression_unavailable);
948 StringRef
Value = A->getValue();
949 if (Value ==
"none") {
950 CmdArgs.push_back(
"-compress-debug-sections=none");
951 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
952 if (llvm::zlib::isAvailable()) {
954 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
956 D.
Diag(diag::warn_debug_compression_unavailable);
959 D.
Diag(diag::err_drv_unsupported_option_argument)
960 << A->getOption().getName() <<
Value;
967 case llvm::Reloc::Static:
969 case llvm::Reloc::PIC_:
971 case llvm::Reloc::DynamicNoPIC:
972 return "dynamic-no-pic";
973 case llvm::Reloc::ROPI:
975 case llvm::Reloc::RWPI:
977 case llvm::Reloc::ROPI_RWPI:
980 llvm_unreachable(
"Unknown Reloc::Model kind");
984 const Driver &D,
const ArgList &Args,
985 ArgStringList &CmdArgs,
989 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
993 Args.AddLastArg(CmdArgs, options::OPT_C);
994 Args.AddLastArg(CmdArgs, options::OPT_CC);
997 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
998 (A = Args.getLastArg(options::OPT_MD)) ||
999 (A = Args.getLastArg(options::OPT_MMD))) {
1001 const char *DepFile;
1002 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1003 DepFile = MF->getValue();
1005 }
else if (Output.
getType() == types::TY_Dependencies) {
1007 }
else if (A->getOption().matches(options::OPT_M) ||
1008 A->getOption().matches(options::OPT_MM)) {
1011 DepFile = getDependencyFileName(Args, Inputs);
1014 CmdArgs.push_back(
"-dependency-file");
1015 CmdArgs.push_back(DepFile);
1018 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
1019 const char *DepTarget;
1023 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1024 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1025 DepTarget = OutputOpt->getValue();
1031 llvm::sys::path::replace_extension(P,
"o");
1032 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1035 if (!A->getOption().matches(options::OPT_MD) && !A->getOption().matches(options::OPT_MMD)) {
1036 CmdArgs.push_back(
"-w");
1038 CmdArgs.push_back(
"-MT");
1041 CmdArgs.push_back(Args.MakeArgString(Quoted));
1044 if (A->getOption().matches(options::OPT_M) ||
1045 A->getOption().matches(options::OPT_MD))
1046 CmdArgs.push_back(
"-sys-header-deps");
1047 if ((isa<PrecompileJobAction>(JA) &&
1048 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1049 Args.hasArg(options::OPT_fmodule_file_deps))
1050 CmdArgs.push_back(
"-module-file-deps");
1053 if (Args.hasArg(options::OPT_MG)) {
1054 if (!A || A->getOption().matches(options::OPT_MD) ||
1055 A->getOption().matches(options::OPT_MMD))
1056 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1057 CmdArgs.push_back(
"-MG");
1060 Args.AddLastArg(CmdArgs, options::OPT_MP);
1061 Args.AddLastArg(CmdArgs, options::OPT_MV);
1064 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1067 if (A->getOption().matches(options::OPT_MQ)) {
1068 CmdArgs.push_back(
"-MT");
1071 CmdArgs.push_back(Args.MakeArgString(Quoted));
1075 A->render(Args, CmdArgs);
1084 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1092 if (getToolChain().getDriver().IsCLMode()) {
1093 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1094 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1097 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1099 if (YcArg || YuArg) {
1100 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1101 if (!isa<PrecompileJobAction>(JA)) {
1102 CmdArgs.push_back(
"-include-pch");
1103 CmdArgs.push_back(Args.MakeArgString(D.
GetClPchPath(C, ThroughHeader)));
1106 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1110 bool RenderedImplicitInclude =
false;
1111 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1112 if (A->getOption().matches(options::OPT_include)) {
1114 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1115 RenderedImplicitInclude =
true;
1120 bool FoundPTH =
false;
1121 bool FoundPCH =
false;
1127 llvm::sys::path::replace_extension(P,
"pch");
1128 if (llvm::sys::fs::exists(P))
1133 llvm::sys::path::replace_extension(P,
"pth");
1134 if (llvm::sys::fs::exists(P))
1138 if (!FoundPCH && !FoundPTH) {
1139 llvm::sys::path::replace_extension(P,
"gch");
1140 if (llvm::sys::fs::exists(P)) {
1146 if (FoundPCH || FoundPTH) {
1147 if (IsFirstImplicitInclude) {
1150 CmdArgs.push_back(
"-include-pch");
1152 CmdArgs.push_back(
"-include-pth");
1153 CmdArgs.push_back(Args.MakeArgString(P));
1157 D.
Diag(diag::warn_drv_pch_not_first_include) << P
1158 << A->getAsString(Args);
1161 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1172 A->render(Args, CmdArgs);
1175 Args.AddAllArgs(CmdArgs,
1176 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1177 options::OPT_F, options::OPT_index_header_map});
1185 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1186 options::OPT_Xpreprocessor);
1189 if (Arg *A = Args.getLastArg(options::OPT_I_))
1190 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1195 if (sysroot !=
"") {
1196 if (!Args.hasArg(options::OPT_isysroot)) {
1197 CmdArgs.push_back(
"-isysroot");
1198 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
1215 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1224 [&Args, &CmdArgs](
const ToolChain &TC) {
1231 [&Args, &CmdArgs](
const ToolChain &TC) {
1236 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1242 switch (Triple.getArch()) {
1246 case llvm::Triple::aarch64:
1247 case llvm::Triple::aarch64_be:
1248 case llvm::Triple::arm:
1249 case llvm::Triple::armeb:
1250 case llvm::Triple::thumb:
1251 case llvm::Triple::thumbeb:
1252 if (Triple.isOSDarwin() || Triple.isOSWindows())
1256 case llvm::Triple::ppc:
1257 case llvm::Triple::ppc64:
1258 if (Triple.isOSDarwin())
1262 case llvm::Triple::hexagon:
1263 case llvm::Triple::ppc64le:
1264 case llvm::Triple::riscv32:
1265 case llvm::Triple::riscv64:
1266 case llvm::Triple::systemz:
1267 case llvm::Triple::xcore:
1273 switch (Triple.getArch()) {
1275 if (Triple.isOSFuchsia())
1279 case llvm::Triple::xcore:
1280 case llvm::Triple::wasm32:
1281 case llvm::Triple::wasm64:
1286 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1287 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1291 const char *ABIName =
nullptr;
1292 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1293 ABIName = A->getValue();
1295 std::string CPU =
getCPUName(Args, Triple,
false);
1296 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1299 CmdArgs.push_back(
"-target-abi");
1300 CmdArgs.push_back(ABIName);
1307 CmdArgs.push_back(
"-msoft-float");
1308 CmdArgs.push_back(
"-mfloat-abi");
1309 CmdArgs.push_back(
"soft");
1312 CmdArgs.push_back(
"-mfloat-abi");
1313 CmdArgs.push_back(
"soft");
1317 CmdArgs.push_back(
"-mfloat-abi");
1318 CmdArgs.push_back(
"hard");
1322 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1323 options::OPT_mno_global_merge)) {
1324 CmdArgs.push_back(
"-mllvm");
1325 if (A->getOption().matches(options::OPT_mno_global_merge))
1326 CmdArgs.push_back(
"-arm-global-merge=false");
1328 CmdArgs.push_back(
"-arm-global-merge=true");
1331 if (!Args.hasFlag(options::OPT_mimplicit_float,
1332 options::OPT_mno_implicit_float,
true))
1333 CmdArgs.push_back(
"-no-implicit-float");
1336 void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1337 const ArgList &Args,
bool KernelOrKext,
1338 ArgStringList &CmdArgs)
const {
1349 case llvm::Triple::arm:
1350 case llvm::Triple::armeb:
1351 case llvm::Triple::thumb:
1352 case llvm::Triple::thumbeb:
1354 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1355 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1358 case llvm::Triple::aarch64:
1359 case llvm::Triple::aarch64_be:
1360 AddAArch64TargetArgs(Args, CmdArgs);
1361 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1364 case llvm::Triple::mips:
1365 case llvm::Triple::mipsel:
1366 case llvm::Triple::mips64:
1367 case llvm::Triple::mips64el:
1368 AddMIPSTargetArgs(Args, CmdArgs);
1371 case llvm::Triple::ppc:
1372 case llvm::Triple::ppc64:
1373 case llvm::Triple::ppc64le:
1374 AddPPCTargetArgs(Args, CmdArgs);
1377 case llvm::Triple::riscv32:
1378 case llvm::Triple::riscv64:
1379 AddRISCVTargetArgs(Args, CmdArgs);
1382 case llvm::Triple::sparc:
1383 case llvm::Triple::sparcel:
1384 case llvm::Triple::sparcv9:
1385 AddSparcTargetArgs(Args, CmdArgs);
1388 case llvm::Triple::systemz:
1389 AddSystemZTargetArgs(Args, CmdArgs);
1392 case llvm::Triple::x86:
1393 case llvm::Triple::x86_64:
1394 AddX86TargetArgs(Args, CmdArgs);
1397 case llvm::Triple::lanai:
1398 AddLanaiTargetArgs(Args, CmdArgs);
1401 case llvm::Triple::hexagon:
1402 AddHexagonTargetArgs(Args, CmdArgs);
1405 case llvm::Triple::wasm32:
1406 case llvm::Triple::wasm64:
1407 AddWebAssemblyTargetArgs(Args, CmdArgs);
1412 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1413 ArgStringList &CmdArgs)
const {
1414 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1416 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1417 Args.hasArg(options::OPT_mkernel) ||
1418 Args.hasArg(options::OPT_fapple_kext))
1419 CmdArgs.push_back(
"-disable-red-zone");
1421 if (!Args.hasFlag(options::OPT_mimplicit_float,
1422 options::OPT_mno_implicit_float,
true))
1423 CmdArgs.push_back(
"-no-implicit-float");
1425 const char *ABIName =
nullptr;
1426 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1427 ABIName = A->getValue();
1428 else if (Triple.isOSDarwin())
1429 ABIName =
"darwinpcs";
1433 CmdArgs.push_back(
"-target-abi");
1434 CmdArgs.push_back(ABIName);
1436 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1437 options::OPT_mno_fix_cortex_a53_835769)) {
1438 CmdArgs.push_back(
"-mllvm");
1439 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1440 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1442 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1443 }
else if (Triple.isAndroid()) {
1445 CmdArgs.push_back(
"-mllvm");
1446 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1450 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1451 options::OPT_mno_global_merge)) {
1452 CmdArgs.push_back(
"-mllvm");
1453 if (A->getOption().matches(options::OPT_mno_global_merge))
1454 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1456 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1460 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1461 ArgStringList &CmdArgs)
const {
1462 const Driver &D = getToolChain().getDriver();
1465 const llvm::Triple &Triple = getToolChain().getTriple();
1468 CmdArgs.push_back(
"-target-abi");
1469 CmdArgs.push_back(ABIName.data());
1474 CmdArgs.push_back(
"-msoft-float");
1475 CmdArgs.push_back(
"-mfloat-abi");
1476 CmdArgs.push_back(
"soft");
1480 CmdArgs.push_back(
"-mfloat-abi");
1481 CmdArgs.push_back(
"hard");
1484 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1485 if (A->getOption().matches(options::OPT_mxgot)) {
1486 CmdArgs.push_back(
"-mllvm");
1487 CmdArgs.push_back(
"-mxgot");
1491 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1492 options::OPT_mno_ldc1_sdc1)) {
1493 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1494 CmdArgs.push_back(
"-mllvm");
1495 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1499 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1500 options::OPT_mno_check_zero_division)) {
1501 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1502 CmdArgs.push_back(
"-mllvm");
1503 CmdArgs.push_back(
"-mno-check-zero-division");
1507 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1508 StringRef
v = A->getValue();
1509 CmdArgs.push_back(
"-mllvm");
1510 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1514 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1516 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1529 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1531 llvm::Reloc::Model RelocationModel;
1534 std::tie(RelocationModel, PICLevel, IsPIE) =
1537 NoABICalls = NoABICalls ||
1538 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1540 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1542 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1543 CmdArgs.push_back(
"-mllvm");
1544 CmdArgs.push_back(
"-mgpopt");
1546 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1547 options::OPT_mno_local_sdata);
1548 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1549 options::OPT_mno_extern_sdata);
1550 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1551 options::OPT_mno_embedded_data);
1553 CmdArgs.push_back(
"-mllvm");
1554 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1555 CmdArgs.push_back(
"-mlocal-sdata=1");
1557 CmdArgs.push_back(
"-mlocal-sdata=0");
1559 LocalSData->claim();
1563 CmdArgs.push_back(
"-mllvm");
1564 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1565 CmdArgs.push_back(
"-mextern-sdata=1");
1567 CmdArgs.push_back(
"-mextern-sdata=0");
1569 ExternSData->claim();
1573 CmdArgs.push_back(
"-mllvm");
1574 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1575 CmdArgs.push_back(
"-membedded-data=1");
1577 CmdArgs.push_back(
"-membedded-data=0");
1579 EmbeddedData->claim();
1582 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1583 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1588 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1589 StringRef Val = StringRef(A->getValue());
1591 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1592 CmdArgs.push_back(
"-mllvm");
1593 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1595 D.
Diag(diag::err_drv_unsupported_option_argument)
1596 << A->getOption().getName() << Val;
1598 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1602 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1603 ArgStringList &CmdArgs)
const {
1605 const char *ABIName =
nullptr;
1606 if (getToolChain().getTriple().isOSLinux())
1607 switch (getToolChain().getArch()) {
1608 case llvm::Triple::ppc64: {
1612 bool HasQPX =
false;
1613 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1614 HasQPX = A->getValue() == StringRef(
"a2q");
1615 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1617 ABIName =
"elfv1-qpx";
1624 case llvm::Triple::ppc64le:
1631 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1635 if (StringRef(A->getValue()) !=
"altivec")
1636 ABIName = A->getValue();
1643 CmdArgs.push_back(
"-msoft-float");
1644 CmdArgs.push_back(
"-mfloat-abi");
1645 CmdArgs.push_back(
"soft");
1649 CmdArgs.push_back(
"-mfloat-abi");
1650 CmdArgs.push_back(
"hard");
1654 CmdArgs.push_back(
"-target-abi");
1655 CmdArgs.push_back(ABIName);
1659 void Clang::AddRISCVTargetArgs(
const ArgList &Args,
1660 ArgStringList &CmdArgs)
const {
1663 const char *ABIName =
nullptr;
1664 const llvm::Triple &Triple = getToolChain().getTriple();
1665 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1666 ABIName = A->getValue();
1667 else if (Triple.getArch() == llvm::Triple::riscv32)
1669 else if (Triple.getArch() == llvm::Triple::riscv64)
1672 llvm_unreachable(
"Unexpected triple!");
1674 CmdArgs.push_back(
"-target-abi");
1675 CmdArgs.push_back(ABIName);
1678 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1679 ArgStringList &CmdArgs)
const {
1685 CmdArgs.push_back(
"-msoft-float");
1686 CmdArgs.push_back(
"-mfloat-abi");
1687 CmdArgs.push_back(
"soft");
1691 CmdArgs.push_back(
"-mfloat-abi");
1692 CmdArgs.push_back(
"hard");
1696 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
1697 ArgStringList &CmdArgs)
const {
1698 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false))
1699 CmdArgs.push_back(
"-mbackchain");
1702 void Clang::AddX86TargetArgs(
const ArgList &Args,
1703 ArgStringList &CmdArgs)
const {
1704 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1705 Args.hasArg(options::OPT_mkernel) ||
1706 Args.hasArg(options::OPT_fapple_kext))
1707 CmdArgs.push_back(
"-disable-red-zone");
1711 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1712 Args.hasArg(options::OPT_fapple_kext));
1713 if (Arg *A = Args.getLastArg(
1714 options::OPT_msoft_float, options::OPT_mno_soft_float,
1715 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
1716 const Option &O = A->getOption();
1717 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1718 O.matches(options::OPT_msoft_float));
1720 if (NoImplicitFloat)
1721 CmdArgs.push_back(
"-no-implicit-float");
1723 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1724 StringRef
Value = A->getValue();
1725 if (Value ==
"intel" || Value ==
"att") {
1726 CmdArgs.push_back(
"-mllvm");
1727 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
1729 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1730 << A->getOption().getName() <<
Value;
1732 }
else if (getToolChain().getDriver().IsCLMode()) {
1733 CmdArgs.push_back(
"-mllvm");
1734 CmdArgs.push_back(
"-x86-asm-syntax=intel");
1738 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
1739 CmdArgs.push_back(
"-mfloat-abi");
1740 CmdArgs.push_back(
"soft");
1741 CmdArgs.push_back(
"-mstack-alignment=4");
1745 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
1746 ArgStringList &CmdArgs)
const {
1747 CmdArgs.push_back(
"-mqdsp6-compat");
1748 CmdArgs.push_back(
"-Wreturn-type");
1751 CmdArgs.push_back(
"-mllvm");
1752 CmdArgs.push_back(Args.MakeArgString(
"-hexagon-small-data-threshold=" +
1753 Twine(G.getValue())));
1756 if (!Args.hasArg(options::OPT_fno_short_enums))
1757 CmdArgs.push_back(
"-fshort-enums");
1758 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1759 CmdArgs.push_back(
"-mllvm");
1760 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
1762 CmdArgs.push_back(
"-mllvm");
1763 CmdArgs.push_back(
"-machine-sink-split=0");
1766 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
1767 ArgStringList &CmdArgs)
const {
1768 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1769 StringRef CPUName = A->getValue();
1771 CmdArgs.push_back(
"-target-cpu");
1772 CmdArgs.push_back(Args.MakeArgString(CPUName));
1774 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1775 StringRef
Value = A->getValue();
1779 if (Value.getAsInteger(10, Mregparm)) {
1780 if (Mregparm != 4) {
1781 getToolChain().getDriver().Diag(
1782 diag::err_drv_unsupported_option_argument)
1783 << A->getOption().getName() <<
Value;
1789 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
1790 ArgStringList &CmdArgs)
const {
1792 if (!Args.hasArg(options::OPT_fvisibility_EQ,
1793 options::OPT_fvisibility_ms_compat)) {
1794 CmdArgs.push_back(
"-fvisibility");
1795 CmdArgs.push_back(
"hidden");
1801 const InputInfo &Input,
const ArgList &Args)
const {
1803 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH))
1806 using llvm::yaml::escape;
1807 const Driver &D = getToolChain().getDriver();
1809 if (!CompilationDatabase) {
1811 auto File = llvm::make_unique<llvm::raw_fd_ostream>(
Filename, EC, llvm::sys::fs::F_Text);
1813 D.
Diag(clang::diag::err_drv_compilationdatabase) << Filename
1817 CompilationDatabase = std::move(File);
1819 auto &CDB = *CompilationDatabase;
1821 if (llvm::sys::fs::current_path(Buf))
1823 CDB <<
"{ \"directory\": \"" << escape(Buf) <<
"\"";
1824 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
1825 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
1829 CDB <<
", \"" << escape(Buf) <<
"\"";
1830 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
1833 CDB <<
", \"" << escape(Buf) <<
"\"";
1835 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
1836 for (
auto &A: Args) {
1837 auto &O = A->getOption();
1839 if (O.getID() == options::OPT_x)
1842 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
1845 if (O.getKind() == Option::InputClass)
1849 A->render(Args, ASL);
1851 CDB <<
", \"" << escape(it) <<
"\"";
1855 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
1859 const ArgList &Args,
1860 ArgStringList &CmdArgs,
1863 CmdArgs.push_back(
"-mrelax-all");
1867 bool DefaultIncrementalLinkerCompatible =
1869 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
1870 options::OPT_mno_incremental_linker_compatible,
1871 DefaultIncrementalLinkerCompatible))
1872 CmdArgs.push_back(
"-mincremental-linker-compatible");
1875 case llvm::Triple::arm:
1876 case llvm::Triple::armeb:
1877 case llvm::Triple::thumb:
1878 case llvm::Triple::thumbeb:
1879 if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) {
1880 StringRef
Value = A->getValue();
1881 if (Value ==
"always" || Value ==
"never" || Value ==
"arm" ||
1883 CmdArgs.push_back(
"-mllvm");
1884 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" + Value));
1886 D.
Diag(diag::err_drv_unsupported_option_argument)
1887 << A->getOption().getName() <<
Value;
1900 bool TakeNextArg =
false;
1903 const char *MipsTargetFeature =
nullptr;
1905 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
1908 for (StringRef
Value : A->getValues()) {
1910 CmdArgs.push_back(
Value.data());
1911 TakeNextArg =
false;
1916 Value ==
"-mbig-obj")
1922 case llvm::Triple::thumb:
1923 case llvm::Triple::thumbeb:
1924 case llvm::Triple::arm:
1925 case llvm::Triple::armeb:
1926 if (
Value ==
"-mthumb")
1931 case llvm::Triple::mips:
1932 case llvm::Triple::mipsel:
1933 case llvm::Triple::mips64:
1934 case llvm::Triple::mips64el:
1935 if (
Value ==
"--trap") {
1936 CmdArgs.push_back(
"-target-feature");
1937 CmdArgs.push_back(
"+use-tcc-in-div");
1940 if (
Value ==
"--break") {
1941 CmdArgs.push_back(
"-target-feature");
1942 CmdArgs.push_back(
"-use-tcc-in-div");
1945 if (
Value.startswith(
"-msoft-float")) {
1946 CmdArgs.push_back(
"-target-feature");
1947 CmdArgs.push_back(
"+soft-float");
1950 if (
Value.startswith(
"-mhard-float")) {
1951 CmdArgs.push_back(
"-target-feature");
1952 CmdArgs.push_back(
"-soft-float");
1956 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
1957 .Case(
"-mips1",
"+mips1")
1958 .Case(
"-mips2",
"+mips2")
1959 .Case(
"-mips3",
"+mips3")
1960 .Case(
"-mips4",
"+mips4")
1961 .Case(
"-mips5",
"+mips5")
1962 .Case(
"-mips32",
"+mips32")
1963 .Case(
"-mips32r2",
"+mips32r2")
1964 .Case(
"-mips32r3",
"+mips32r3")
1965 .Case(
"-mips32r5",
"+mips32r5")
1966 .Case(
"-mips32r6",
"+mips32r6")
1967 .Case(
"-mips64",
"+mips64")
1968 .Case(
"-mips64r2",
"+mips64r2")
1969 .Case(
"-mips64r3",
"+mips64r3")
1970 .Case(
"-mips64r5",
"+mips64r5")
1971 .Case(
"-mips64r6",
"+mips64r6")
1973 if (MipsTargetFeature)
1977 if (
Value ==
"-force_cpusubtype_ALL") {
1979 }
else if (
Value ==
"-L") {
1980 CmdArgs.push_back(
"-msave-temp-labels");
1981 }
else if (
Value ==
"--fatal-warnings") {
1982 CmdArgs.push_back(
"-massembler-fatal-warnings");
1983 }
else if (
Value ==
"--noexecstack") {
1984 CmdArgs.push_back(
"-mnoexecstack");
1985 }
else if (
Value.startswith(
"-compress-debug-sections") ||
1986 Value.startswith(
"--compress-debug-sections") ||
1987 Value ==
"-nocompress-debug-sections" ||
1988 Value ==
"--nocompress-debug-sections") {
1989 CmdArgs.push_back(
Value.data());
1990 }
else if (
Value ==
"-mrelax-relocations=yes" ||
1991 Value ==
"--mrelax-relocations=yes") {
1992 UseRelaxRelocations =
true;
1993 }
else if (
Value ==
"-mrelax-relocations=no" ||
1994 Value ==
"--mrelax-relocations=no") {
1995 UseRelaxRelocations =
false;
1996 }
else if (
Value.startswith(
"-I")) {
1997 CmdArgs.push_back(
Value.data());
2002 }
else if (
Value.startswith(
"-gdwarf-")) {
2005 if (DwarfVersion == 0) {
2006 CmdArgs.push_back(
Value.data());
2010 DwarfVersion, llvm::DebuggerKind::Default);
2012 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2013 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2015 }
else if (
Value ==
"-defsym") {
2016 if (A->getNumValues() != 2) {
2017 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2020 const char *S = A->getValue(1);
2021 auto Pair = StringRef(S).split(
'=');
2022 auto Sym = Pair.first;
2023 auto SVal = Pair.second;
2025 if (Sym.empty() || SVal.empty()) {
2026 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2030 if (SVal.getAsInteger(0, IVal)) {
2031 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2034 CmdArgs.push_back(
Value.data());
2037 D.
Diag(diag::err_drv_unsupported_option_argument)
2038 << A->getOption().getName() <<
Value;
2042 if (UseRelaxRelocations)
2043 CmdArgs.push_back(
"--mrelax-relocations");
2044 if (MipsTargetFeature !=
nullptr) {
2045 CmdArgs.push_back(
"-target-feature");
2046 CmdArgs.push_back(MipsTargetFeature);
2051 bool OFastEnabled,
const ArgList &Args,
2052 ArgStringList &CmdArgs) {
2058 bool HonorINFs =
true;
2059 bool HonorNaNs =
true;
2062 bool AssociativeMath =
false;
2063 bool ReciprocalMath =
false;
2064 bool SignedZeros =
true;
2065 bool TrappingMath =
true;
2066 StringRef DenormalFPMath =
"";
2067 StringRef FPContract =
"";
2069 for (
const Arg *A : Args) {
2070 switch (A->getOption().getID()) {
2075 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2076 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2077 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2078 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2079 case options::OPT_fmath_errno: MathErrno =
true;
break;
2080 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2081 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2082 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2083 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2084 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2085 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2086 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2087 case options::OPT_ftrapping_math: TrappingMath =
true;
break;
2088 case options::OPT_fno_trapping_math: TrappingMath =
false;
break;
2090 case options::OPT_fdenormal_fp_math_EQ:
2091 DenormalFPMath = A->getValue();
2095 case options::OPT_ffp_contract: {
2096 StringRef Val = A->getValue();
2097 if (Val ==
"fast" || Val ==
"on" || Val ==
"off")
2100 D.
Diag(diag::err_drv_unsupported_option_argument)
2101 << A->getOption().getName() << Val;
2105 case options::OPT_ffinite_math_only:
2109 case options::OPT_fno_finite_math_only:
2114 case options::OPT_funsafe_math_optimizations:
2115 AssociativeMath =
true;
2116 ReciprocalMath =
true;
2117 SignedZeros =
false;
2118 TrappingMath =
false;
2120 case options::OPT_fno_unsafe_math_optimizations:
2121 AssociativeMath =
false;
2122 ReciprocalMath =
false;
2124 TrappingMath =
true;
2126 DenormalFPMath =
"";
2129 case options::OPT_Ofast:
2134 case options::OPT_ffast_math:
2138 AssociativeMath =
true;
2139 ReciprocalMath =
true;
2140 SignedZeros =
false;
2141 TrappingMath =
false;
2143 FPContract =
"fast";
2145 case options::OPT_fno_fast_math:
2152 AssociativeMath =
false;
2153 ReciprocalMath =
false;
2155 TrappingMath =
true;
2157 DenormalFPMath =
"";
2167 CmdArgs.push_back(
"-menable-no-infs");
2170 CmdArgs.push_back(
"-menable-no-nans");
2173 CmdArgs.push_back(
"-fmath-errno");
2175 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2177 CmdArgs.push_back(
"-menable-unsafe-fp-math");
2180 CmdArgs.push_back(
"-fno-signed-zeros");
2182 if (AssociativeMath && !SignedZeros && !TrappingMath)
2183 CmdArgs.push_back(
"-mreassociate");
2186 CmdArgs.push_back(
"-freciprocal-math");
2189 CmdArgs.push_back(
"-fno-trapping-math");
2191 if (!DenormalFPMath.empty())
2193 Args.MakeArgString(
"-fdenormal-fp-math=" + DenormalFPMath));
2195 if (!FPContract.empty())
2196 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
2203 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
2204 ReciprocalMath && !SignedZeros && !TrappingMath)
2205 CmdArgs.push_back(
"-ffast-math");
2208 if (!HonorINFs && !HonorNaNs)
2209 CmdArgs.push_back(
"-ffinite-math-only");
2211 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2212 CmdArgs.push_back(
"-mfpmath");
2213 CmdArgs.push_back(A->getValue());
2217 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
2218 options::OPT_fstrict_float_cast_overflow,
false))
2219 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
2223 const llvm::Triple &Triple,
2226 CmdArgs.push_back(
"-analyzer-store=region");
2229 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
2231 CmdArgs.push_back(
"-analyzer-eagerly-assume");
2234 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2235 CmdArgs.push_back(
"-analyzer-checker=core");
2236 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
2238 if (!Triple.isWindowsMSVCEnvironment()) {
2239 CmdArgs.push_back(
"-analyzer-checker=unix");
2242 CmdArgs.push_back(
"-analyzer-checker=unix.API");
2243 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
2244 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
2245 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
2246 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
2247 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
2251 if (Triple.isPS4CPU()) {
2252 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
2253 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
2256 if (Triple.isOSDarwin())
2257 CmdArgs.push_back(
"-analyzer-checker=osx");
2259 CmdArgs.push_back(
"-analyzer-checker=deadcode");
2262 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
2264 if (!Triple.isPS4CPU()) {
2265 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
2266 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
2267 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
2268 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
2269 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
2270 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
2274 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
2275 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
2279 CmdArgs.push_back(
"-analyzer-output");
2280 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2281 CmdArgs.push_back(A->getValue());
2283 CmdArgs.push_back(
"plist");
2288 CmdArgs.push_back(
"-w");
2291 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2295 ArgStringList &CmdArgs,
bool KernelOrKext) {
2300 if (EffectiveTriple.isNVPTX())
2304 unsigned StackProtectorLevel = 0;
2305 unsigned DefaultStackProtectorLevel =
2308 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2309 options::OPT_fstack_protector_all,
2310 options::OPT_fstack_protector_strong,
2311 options::OPT_fstack_protector)) {
2312 if (A->getOption().matches(options::OPT_fstack_protector))
2313 StackProtectorLevel =
2315 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
2317 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2320 StackProtectorLevel = DefaultStackProtectorLevel;
2323 if (StackProtectorLevel) {
2324 CmdArgs.push_back(
"-stack-protector");
2325 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2329 for (
const Arg *A : Args.filtered(options::OPT__param)) {
2330 StringRef Str(A->getValue());
2331 if (Str.startswith(
"ssp-buffer-size=")) {
2332 if (StackProtectorLevel) {
2333 CmdArgs.push_back(
"-stack-protector-buffer-size");
2335 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
2343 const unsigned ForwardedArguments[] = {
2344 options::OPT_cl_opt_disable,
2345 options::OPT_cl_strict_aliasing,
2346 options::OPT_cl_single_precision_constant,
2347 options::OPT_cl_finite_math_only,
2348 options::OPT_cl_kernel_arg_info,
2349 options::OPT_cl_unsafe_math_optimizations,
2350 options::OPT_cl_fast_relaxed_math,
2351 options::OPT_cl_mad_enable,
2352 options::OPT_cl_no_signed_zeros,
2353 options::OPT_cl_denorms_are_zero,
2354 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
2355 options::OPT_cl_uniform_work_group_size
2358 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
2359 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
2360 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
2363 for (
const auto &Arg : ForwardedArguments)
2364 if (
const auto *A = Args.getLastArg(Arg))
2365 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
2369 ArgStringList &CmdArgs) {
2370 bool ARCMTEnabled =
false;
2371 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2372 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2373 options::OPT_ccc_arcmt_modify,
2374 options::OPT_ccc_arcmt_migrate)) {
2375 ARCMTEnabled =
true;
2376 switch (A->getOption().getID()) {
2377 default: llvm_unreachable(
"missed a case");
2378 case options::OPT_ccc_arcmt_check:
2379 CmdArgs.push_back(
"-arcmt-check");
2381 case options::OPT_ccc_arcmt_modify:
2382 CmdArgs.push_back(
"-arcmt-modify");
2384 case options::OPT_ccc_arcmt_migrate:
2385 CmdArgs.push_back(
"-arcmt-migrate");
2386 CmdArgs.push_back(
"-mt-migrate-directory");
2387 CmdArgs.push_back(A->getValue());
2389 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2390 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2395 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2396 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2397 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2400 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2402 D.
Diag(diag::err_drv_argument_not_allowed_with)
2403 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
2405 CmdArgs.push_back(
"-mt-migrate-directory");
2406 CmdArgs.push_back(A->getValue());
2408 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2409 options::OPT_objcmt_migrate_subscripting,
2410 options::OPT_objcmt_migrate_property)) {
2412 CmdArgs.push_back(
"-objcmt-migrate-literals");
2413 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
2414 CmdArgs.push_back(
"-objcmt-migrate-property");
2416 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2417 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2418 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2421 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2422 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2423 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2424 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2425 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2426 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2427 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
2428 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2429 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2430 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2431 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2432 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2433 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2434 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2435 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
2436 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
2441 const ArgList &Args, ArgStringList &CmdArgs) {
2444 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
2445 !Args.hasArg(options::OPT_mkernel));
2447 CmdArgs.push_back(
"-fno-builtin");
2450 if (Args.hasArg(options::OPT_ffreestanding))
2451 UseBuiltins =
false;
2454 for (
const auto &Arg : Args) {
2455 const Option &O = Arg->getOption();
2456 if (!O.matches(options::OPT_fno_builtin_))
2466 StringRef FuncName = Arg->getValue();
2467 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
2473 if (TC.
getArch() == llvm::Triple::le32)
2474 CmdArgs.push_back(
"-fno-math-builtin");
2478 llvm::sys::path::system_temp_directory(
false, Result);
2479 llvm::sys::path::append(Result,
"org.llvm.clang.");
2481 llvm::sys::path::append(Result,
"ModuleCache");
2485 const ArgList &Args,
const InputInfo &Input,
2487 ArgStringList &CmdArgs,
bool &HaveModules) {
2491 bool HaveClangModules =
false;
2492 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
2493 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2494 options::OPT_fno_cxx_modules,
true);
2496 CmdArgs.push_back(
"-fmodules");
2497 HaveClangModules =
true;
2501 HaveModules = HaveClangModules;
2502 if (Args.hasArg(options::OPT_fmodules_ts)) {
2503 CmdArgs.push_back(
"-fmodules-ts");
2509 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
2510 options::OPT_fno_implicit_module_maps, HaveClangModules))
2511 CmdArgs.push_back(
"-fimplicit-module-maps");
2514 if (Args.hasFlag(options::OPT_fmodules_decluse,
2515 options::OPT_fno_modules_decluse,
false))
2516 CmdArgs.push_back(
"-fmodules-decluse");
2520 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
2521 options::OPT_fno_modules_strict_decluse,
false))
2522 CmdArgs.push_back(
"-fmodules-strict-decluse");
2525 bool ImplicitModules =
false;
2526 if (!Args.hasFlag(options::OPT_fimplicit_modules,
2527 options::OPT_fno_implicit_modules, HaveClangModules)) {
2529 CmdArgs.push_back(
"-fno-implicit-modules");
2530 }
else if (HaveModules) {
2531 ImplicitModules =
true;
2535 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
2536 Path = A->getValue();
2542 llvm::sys::path::replace_extension(Path,
".cache");
2543 llvm::sys::path::append(Path,
"modules");
2544 }
else if (Path.empty()) {
2549 const char Arg[] =
"-fmodules-cache-path=";
2550 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
2551 CmdArgs.push_back(Args.MakeArgString(Path));
2556 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
2557 CmdArgs.push_back(Args.MakeArgString(
2558 std::string(
"-fprebuilt-module-path=") + A->getValue()));
2565 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
2569 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
2573 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
2575 llvm::sys::path::append(BuiltinModuleMap,
"include");
2576 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
2577 if (llvm::sys::fs::exists(BuiltinModuleMap))
2579 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
2587 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
2589 Args.ClaimAllArgs(options::OPT_fmodule_file);
2595 llvm::sys::path::replace_extension(VFSDir,
".cache");
2599 llvm::sys::path::append(VFSDir,
"vfs");
2600 CmdArgs.push_back(
"-module-dependency-dir");
2601 CmdArgs.push_back(Args.MakeArgString(VFSDir));
2604 if (HaveClangModules)
2605 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
2608 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
2609 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
2610 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
2612 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
2614 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
2615 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
2616 D.
Diag(diag::err_drv_argument_not_allowed_with)
2617 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
2619 llvm::sys::fs::file_status Status;
2620 if (llvm::sys::fs::status(A->getValue(), Status))
2621 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
2623 Args.MakeArgString(
"-fbuild-session-timestamp=" +
2624 Twine((uint64_t)Status.getLastModificationTime()
2629 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
2630 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
2631 options::OPT_fbuild_session_file))
2632 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
2634 Args.AddLastArg(CmdArgs,
2635 options::OPT_fmodules_validate_once_per_build_session);
2638 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
2639 options::OPT_fno_modules_validate_system_headers,
2641 CmdArgs.push_back(
"-fmodules-validate-system-headers");
2643 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
2647 ArgStringList &CmdArgs) {
2649 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
2650 options::OPT_fno_signed_char,
2651 options::OPT_funsigned_char,
2652 options::OPT_fno_unsigned_char)) {
2653 if (A->getOption().matches(options::OPT_funsigned_char) ||
2654 A->getOption().matches(options::OPT_fno_signed_char)) {
2655 CmdArgs.push_back(
"-fno-signed-char");
2658 CmdArgs.push_back(
"-fno-signed-char");
2661 if (Args.hasFlag(options::OPT_fchar8__t, options::OPT_fno_char8__t,
false))
2662 CmdArgs.push_back(
"-fchar8_t");
2664 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
2665 options::OPT_fno_short_wchar)) {
2666 if (A->getOption().matches(options::OPT_fshort_wchar)) {
2667 CmdArgs.push_back(
"-fwchar-type=short");
2668 CmdArgs.push_back(
"-fno-signed-wchar");
2670 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
2671 CmdArgs.push_back(
"-fwchar-type=int");
2672 if (IsARM && !(T.isOSWindows() || T.getOS() == llvm::Triple::NetBSD ||
2673 T.getOS() == llvm::Triple::OpenBSD))
2674 CmdArgs.push_back(
"-fno-signed-wchar");
2676 CmdArgs.push_back(
"-fsigned-wchar");
2682 const llvm::Triple &T,
const ArgList &Args,
2684 const InputInfo &Input, ArgStringList &CmdArgs) {
2685 const llvm::Triple::ArchType Arch = TC.
getArch();
2691 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2692 options::OPT_fno_objc_legacy_dispatch,
2695 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
2697 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
2703 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
2704 !T.isMacOSXVersionLT(10, 7) &&
2706 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
2713 CmdArgs.push_back(
"-fobjc-arc");
2720 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
2722 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
2727 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2728 options::OPT_fno_objc_arc_exceptions,
2730 CmdArgs.push_back(
"-fobjc-arc-exceptions");
2735 if (Args.hasArg(options::OPT_fno_objc_arc)) {
2736 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
2737 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
2742 if (InferCovariantReturns)
2743 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
2748 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
2752 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
2753 D.
Diag(diag::err_objc_weak_unsupported);
2755 WeakArg->render(Args, CmdArgs);
2761 ArgStringList &CmdArgs) {
2762 bool CaretDefault =
true;
2763 bool ColumnDefault =
true;
2765 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
2766 options::OPT__SLASH_diagnostics_column,
2767 options::OPT__SLASH_diagnostics_caret)) {
2768 switch (A->getOption().getID()) {
2769 case options::OPT__SLASH_diagnostics_caret:
2770 CaretDefault =
true;
2771 ColumnDefault =
true;
2773 case options::OPT__SLASH_diagnostics_column:
2774 CaretDefault =
false;
2775 ColumnDefault =
true;
2777 case options::OPT__SLASH_diagnostics_classic:
2778 CaretDefault =
false;
2779 ColumnDefault =
false;
2785 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2786 options::OPT_fno_caret_diagnostics, CaretDefault))
2787 CmdArgs.push_back(
"-fno-caret-diagnostics");
2790 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
2791 options::OPT_fno_diagnostics_fixit_info))
2792 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
2795 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
2796 options::OPT_fno_diagnostics_show_option))
2797 CmdArgs.push_back(
"-fdiagnostics-show-option");
2800 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2801 CmdArgs.push_back(
"-fdiagnostics-show-category");
2802 CmdArgs.push_back(A->getValue());
2805 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
2806 options::OPT_fno_diagnostics_show_hotness,
false))
2807 CmdArgs.push_back(
"-fdiagnostics-show-hotness");
2810 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2812 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
2813 CmdArgs.push_back(Args.MakeArgString(Opt));
2816 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2817 CmdArgs.push_back(
"-fdiagnostics-format");
2818 CmdArgs.push_back(A->getValue());
2821 if (
const Arg *A = Args.getLastArg(
2822 options::OPT_fdiagnostics_show_note_include_stack,
2823 options::OPT_fno_diagnostics_show_note_include_stack)) {
2824 const Option &O = A->getOption();
2825 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
2826 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
2828 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
2835 for (
const Arg *A : Args) {
2836 const Option &O = A->getOption();
2837 if (!O.matches(options::OPT_fcolor_diagnostics) &&
2838 !O.matches(options::OPT_fdiagnostics_color) &&
2839 !O.matches(options::OPT_fno_color_diagnostics) &&
2840 !O.matches(options::OPT_fno_diagnostics_color) &&
2841 !O.matches(options::OPT_fdiagnostics_color_EQ))
2844 if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2845 StringRef
Value(A->getValue());
2847 D.
Diag(diag::err_drv_clang_unsupported)
2848 << (
"-fdiagnostics-color=" +
Value).str();
2854 CmdArgs.push_back(
"-fcolor-diagnostics");
2856 if (Args.hasArg(options::OPT_fansi_escape_codes))
2857 CmdArgs.push_back(
"-fansi-escape-codes");
2859 if (!Args.hasFlag(options::OPT_fshow_source_location,
2860 options::OPT_fno_show_source_location))
2861 CmdArgs.push_back(
"-fno-show-source-location");
2863 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
2864 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
2866 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
2868 CmdArgs.push_back(
"-fno-show-column");
2870 if (!Args.hasFlag(options::OPT_fspell_checking,
2871 options::OPT_fno_spell_checking))
2872 CmdArgs.push_back(
"-fno-spell-checking");
2876 const llvm::Triple &T,
const ArgList &Args,
2877 bool EmitCodeView,
bool IsWindowsMSVC,
2878 ArgStringList &CmdArgs,
2880 const Arg *&SplitDWARFArg) {
2881 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
2882 options::OPT_fno_debug_info_for_profiling,
false) &&
2884 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
2885 CmdArgs.push_back(
"-fdebug-info-for-profiling");
2896 unsigned DWARFVersion = 0;
2899 bool SplitDWARFInlining =
2900 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
2901 options::OPT_fno_split_dwarf_inlining,
true);
2903 Args.ClaimAllArgs(options::OPT_g_Group);
2905 SplitDWARFArg = Args.getLastArg(options::OPT_gsplit_dwarf);
2908 SplitDWARFArg =
nullptr;
2909 SplitDWARFInlining =
false;
2912 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2915 if (A->getOption().matches(options::OPT_gN_Group)) {
2925 if (SplitDWARFArg) {
2926 if (A->getIndex() > SplitDWARFArg->getIndex()) {
2929 SplitDWARFInlining))
2930 SplitDWARFArg =
nullptr;
2931 }
else if (SplitDWARFInlining)
2945 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
2947 if (A->getOption().matches(options::OPT_glldb))
2948 DebuggerTuning = llvm::DebuggerKind::LLDB;
2949 else if (A->getOption().matches(options::OPT_gsce))
2950 DebuggerTuning = llvm::DebuggerKind::SCE;
2952 DebuggerTuning = llvm::DebuggerKind::GDB;
2958 Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
2959 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
2966 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview)) {
2970 CmdArgs.push_back(
"-gcodeview");
2975 if (!EmitCodeView && DWARFVersion == 0 &&
2981 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2988 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
2990 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
2992 DebuggerTuning != llvm::DebuggerKind::SCE))
2993 CmdArgs.push_back(
"-dwarf-column-info");
2997 if (
const Arg *A = Args.getLastArg(options::OPT_gmodules))
3001 CmdArgs.push_back(
"-dwarf-ext-refs");
3002 CmdArgs.push_back(
"-fmodule-format=obj");
3009 if (T.isOSLinux()) {
3010 if (!SplitDWARFInlining)
3011 CmdArgs.push_back(
"-fno-split-dwarf-inlining");
3013 if (SplitDWARFArg) {
3016 CmdArgs.push_back(
"-enable-split-dwarf");
3025 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
3026 options::OPT_fno_standalone_debug,
3028 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
3033 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
3039 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
3040 if (DWARFVersion < 5)
3041 D.Diag(diag::err_drv_argument_only_allowed_with)
3042 << A->getAsString(Args) <<
"-gdwarf-5";
3044 CmdArgs.push_back(
"-gembed-source");
3051 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
3055 CmdArgs.push_back(
"-debug-info-macro");
3058 if (Args.hasFlag(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
3062 CmdArgs.push_back(
"-ggnu-pubnames");
3067 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
3068 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
3071 CmdArgs.push_back(
"-mllvm");
3072 CmdArgs.push_back(
"-generate-arange-section");
3075 if (Args.hasFlag(options::OPT_fdebug_types_section,
3076 options::OPT_fno_debug_types_section,
false)) {
3077 if (!T.isOSBinFormatELF()) {
3078 D.Diag(diag::err_drv_unsupported_opt_for_target)
3079 << Args.getLastArg(options::OPT_fdebug_types_section)
3083 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
3085 CmdArgs.push_back(
"-mllvm");
3086 CmdArgs.push_back(
"-generate-type-units");
3092 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3093 CmdArgs.push_back(
"-debug-forward-template-params");
3097 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3098 CmdArgs.push_back(
"-dwarf-explicit-import");
3105 const ArgList &Args,
const char *LinkingOutput)
const {
3106 const llvm::Triple &RawTriple = getToolChain().getTriple();
3107 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
3108 const std::string &TripleStr = Triple.getTriple();
3111 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3112 const Driver &D = getToolChain().getDriver();
3113 ArgStringList CmdArgs;
3116 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
3125 assert((IsCuda || IsHIP || (IsOpenMPDevice && Inputs.size() == 2) ||
3126 Inputs.size() == 1) &&
3127 "Unable to handle multiple inputs.");
3129 const llvm::Triple *AuxTriple =
3130 IsCuda ? getToolChain().getAuxTriple() :
nullptr;
3132 bool IsWindowsGNU = RawTriple.isWindowsGNUEnvironment();
3133 bool IsWindowsCygnus = RawTriple.isWindowsCygwinEnvironment();
3134 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
3135 bool IsIAMCU = RawTriple.isOSIAMCU();
3140 if (IsCuda || IsHIP) {
3141 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
3142 IsWindowsGNU |= AuxTriple && AuxTriple->isWindowsGNUEnvironment();
3143 IsWindowsCygnus |= AuxTriple && AuxTriple->isWindowsCygwinEnvironment();
3148 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
3153 CmdArgs.push_back(
"-cc1");
3156 CmdArgs.push_back(
"-triple");
3157 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3159 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
3160 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
3161 Args.ClaimAllArgs(options::OPT_MJ);
3164 if (IsCuda || IsHIP) {
3167 std::string NormalizedTriple;
3180 CmdArgs.push_back(
"-aux-triple");
3181 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3184 if (IsOpenMPDevice) {
3186 std::string NormalizedTriple =
3190 CmdArgs.push_back(
"-aux-triple");
3191 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3194 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3195 Triple.getArch() == llvm::Triple::thumb)) {
3196 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
3198 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
3200 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
3207 getToolChain().addClangWarningOptions(CmdArgs);
3210 RewriteKind rewriteKind = RK_None;
3212 if (isa<AnalyzeJobAction>(JA)) {
3213 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
3214 CmdArgs.push_back(
"-analyze");
3215 }
else if (isa<MigrateJobAction>(JA)) {
3216 CmdArgs.push_back(
"-migrate");
3217 }
else if (isa<PreprocessJobAction>(JA)) {
3218 if (Output.
getType() == types::TY_Dependencies)
3219 CmdArgs.push_back(
"-Eonly");
3221 CmdArgs.push_back(
"-E");
3222 if (Args.hasArg(options::OPT_rewrite_objc) &&
3223 !Args.hasArg(options::OPT_g_Group))
3224 CmdArgs.push_back(
"-P");
3226 }
else if (isa<AssembleJobAction>(JA)) {
3227 CmdArgs.push_back(
"-emit-obj");
3232 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
3233 }
else if (isa<PrecompileJobAction>(JA)) {
3237 if (JA.
getType() == types::TY_Nothing)
3238 CmdArgs.push_back(
"-fsyntax-only");
3239 else if (JA.
getType() == types::TY_ModuleFile)
3240 CmdArgs.push_back(
"-emit-module-interface");
3242 CmdArgs.push_back(
"-emit-pch");
3244 CmdArgs.push_back(
"-emit-pth");
3245 }
else if (isa<VerifyPCHJobAction>(JA)) {
3246 CmdArgs.push_back(
"-verify-pch");
3248 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3249 "Invalid action for clang tool.");
3250 if (JA.
getType() == types::TY_Nothing) {
3251 CmdArgs.push_back(
"-fsyntax-only");
3252 }
else if (JA.
getType() == types::TY_LLVM_IR ||
3253 JA.
getType() == types::TY_LTO_IR) {
3254 CmdArgs.push_back(
"-emit-llvm");
3255 }
else if (JA.
getType() == types::TY_LLVM_BC ||
3256 JA.
getType() == types::TY_LTO_BC) {
3257 CmdArgs.push_back(
"-emit-llvm-bc");
3258 }
else if (JA.
getType() == types::TY_PP_Asm) {
3259 CmdArgs.push_back(
"-S");
3260 }
else if (JA.
getType() == types::TY_AST) {
3261 CmdArgs.push_back(
"-emit-pch");
3262 }
else if (JA.
getType() == types::TY_ModuleFile) {
3263 CmdArgs.push_back(
"-module-file-info");
3264 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
3265 CmdArgs.push_back(
"-rewrite-objc");
3266 rewriteKind = RK_NonFragile;
3267 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
3268 CmdArgs.push_back(
"-rewrite-objc");
3269 rewriteKind = RK_Fragile;
3271 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
3278 if (JA.
getType() == types::TY_LLVM_BC)
3279 CmdArgs.push_back(
"-emit-llvm-uselists");
3285 if (D.
isUsingLTO() && !isDeviceOffloadAction) {
3286 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
3291 if (!(RawTriple.isOSDarwin() || RawTriple.isPS4()) ||
3293 CmdArgs.push_back(
"-flto-unit");
3297 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
3299 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3301 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
3304 if (Args.getLastArg(options::OPT_save_temps_EQ))
3305 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
3309 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
3311 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
3313 CmdArgs.push_back(
"-disable-llvm-passes");
3316 CmdArgs.push_back(
"-fembed-bitcode=marker");
3322 CmdArgs.push_back(
"-disable-free");
3325 const bool IsAssertBuild =
false;
3327 const bool IsAssertBuild =
true;
3332 CmdArgs.push_back(
"-disable-llvm-verifier");
3335 if (Args.hasFlag(options::OPT_fdiscard_value_names,
3336 options::OPT_fno_discard_value_names, !IsAssertBuild))
3337 CmdArgs.push_back(
"-discard-value-names");
3341 CmdArgs.push_back(
"-main-file-name");
3342 CmdArgs.push_back(getBaseInputName(Args, Input));
3346 if (Args.hasArg(options::OPT_static))
3347 CmdArgs.push_back(
"-static-define");
3349 if (isa<AnalyzeJobAction>(JA))
3355 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
3356 if (FunctionAlignment) {
3357 CmdArgs.push_back(
"-function-alignment");
3358 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
3361 llvm::Reloc::Model RelocationModel;
3364 std::tie(RelocationModel, PICLevel, IsPIE) =
3369 if ((RelocationModel == llvm::Reloc::ROPI ||
3370 RelocationModel == llvm::Reloc::ROPI_RWPI) &&
3372 !Args.hasArg(options::OPT_fallow_unsupported))
3373 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
3376 CmdArgs.push_back(
"-mrelocation-model");
3377 CmdArgs.push_back(RMName);
3380 CmdArgs.push_back(
"-pic-level");
3381 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
3383 CmdArgs.push_back(
"-pic-is-pie");
3386 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3387 CmdArgs.push_back(
"-meabi");
3388 CmdArgs.push_back(A->getValue());
3391 CmdArgs.push_back(
"-mthread-model");
3392 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
3393 if (!getToolChain().isThreadModelSupported(A->getValue()))
3394 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
3395 << A->getValue() << A->getAsString(Args);
3396 CmdArgs.push_back(A->getValue());
3399 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3401 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3403 if (Args.hasFlag(options::OPT_fmerge_all_constants,
3404 options::OPT_fno_merge_all_constants,
false))
3405 CmdArgs.push_back(
"-fmerge-all-constants");
3407 if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks,
3408 options::OPT_fdelete_null_pointer_checks,
false))
3409 CmdArgs.push_back(
"-fno-delete-null-pointer-checks");
3413 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3414 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
3415 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3416 options::OPT_frewrite_map_file_EQ)) {
3417 StringRef Map = A->getValue();
3418 if (!llvm::sys::fs::exists(Map)) {
3419 D.
Diag(diag::err_drv_no_such_file) << Map;
3421 CmdArgs.push_back(
"-frewrite-map-file");
3422 CmdArgs.push_back(A->getValue());
3428 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3429 StringRef
v = A->getValue();
3430 CmdArgs.push_back(
"-mllvm");
3431 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
3435 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
3437 CmdArgs.push_back(
"-fno-jump-tables");
3439 if (Args.hasFlag(options::OPT_fprofile_sample_accurate,
3440 options::OPT_fno_profile_sample_accurate,
false))
3441 CmdArgs.push_back(
"-fprofile-sample-accurate");
3443 if (!Args.hasFlag(options::OPT_fpreserve_as_comments,
3444 options::OPT_fno_preserve_as_comments,
true))
3445 CmdArgs.push_back(
"-fno-preserve-as-comments");
3447 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3448 CmdArgs.push_back(
"-mregparm");
3449 CmdArgs.push_back(A->getValue());
3452 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3453 options::OPT_freg_struct_return)) {
3454 if (getToolChain().getArch() != llvm::Triple::x86) {
3455 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3456 << A->getSpelling() << RawTriple.str();
3457 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3458 CmdArgs.push_back(
"-fpcc-struct-return");
3460 assert(A->getOption().matches(options::OPT_freg_struct_return));
3461 CmdArgs.push_back(
"-freg-struct-return");
3465 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
3466 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
3469 CmdArgs.push_back(
"-mdisable-fp-elim");
3470 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3471 options::OPT_fno_zero_initialized_in_bss))
3472 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
3477 OptSpecifier StrictAliasingAliasOption =
3478 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
3481 bool TBAAOnByDefault = !D.
IsCLMode();
3482 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
3483 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
3484 CmdArgs.push_back(
"-relaxed-aliasing");
3485 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3486 options::OPT_fno_struct_path_tbaa))
3487 CmdArgs.push_back(
"-no-struct-path-tbaa");
3488 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3490 CmdArgs.push_back(
"-fstrict-enums");
3491 if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
3493 CmdArgs.push_back(
"-fno-strict-return");
3494 if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
3495 options::OPT_fno_allow_editor_placeholders,
false))
3496 CmdArgs.push_back(
"-fallow-editor-placeholders");
3497 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
3498 options::OPT_fno_strict_vtable_pointers,
3500 CmdArgs.push_back(
"-fstrict-vtable-pointers");
3501 if (Args.hasFlag(options::OPT_fforce_emit_vtables,
3502 options::OPT_fno_force_emit_vtables,
3504 CmdArgs.push_back(
"-fforce-emit-vtables");
3505 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3506 options::OPT_fno_optimize_sibling_calls))
3507 CmdArgs.push_back(
"-mdisable-tail-calls");
3508 if (Args.hasFlag(options::OPT_fno_escaping_block_tail_calls,
3509 options::OPT_fescaping_block_tail_calls,
false))
3510 CmdArgs.push_back(
"-fno-escaping-block-tail-calls");
3512 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
3513 options::OPT_fno_fine_grained_bitfield_accesses);
3516 if (Args.hasArg(options::OPT_fsplit_stack))
3517 CmdArgs.push_back(
"-split-stacks");
3523 bool IsIntegratedAssemblerDefault =
3524 getToolChain().IsIntegratedAssemblerDefault();
3525 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
3526 IsIntegratedAssemblerDefault) ||
3527 Args.hasArg(options::OPT_dA))
3528 CmdArgs.push_back(
"-masm-verbose");
3530 if (!getToolChain().useIntegratedAs())
3531 CmdArgs.push_back(
"-no-integrated-as");
3533 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3534 CmdArgs.push_back(
"-mdebug-pass");
3535 CmdArgs.push_back(
"Structure");
3537 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3538 CmdArgs.push_back(
"-mdebug-pass");
3539 CmdArgs.push_back(
"Arguments");
3545 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
3546 CmdArgs.push_back(
"-mconstructor-aliases");
3550 if (KernelOrKext && RawTriple.isOSDarwin())
3551 CmdArgs.push_back(
"-fforbid-guard-variables");
3553 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
3555 CmdArgs.push_back(
"-mms-bitfields");
3558 if (Args.hasFlag(options::OPT_mpie_copy_relocations,
3559 options::OPT_mno_pie_copy_relocations,
3561 CmdArgs.push_back(
"-mpie-copy-relocations");
3564 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
3565 CmdArgs.push_back(
"-fno-plt");
3572 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
3575 CmdArgs.push_back(
"-ffreestanding");
3580 bool AsynchronousUnwindTables =
3581 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3582 options::OPT_fno_asynchronous_unwind_tables,
3583 (getToolChain().IsUnwindTablesDefault(Args) ||
3584 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3586 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3587 AsynchronousUnwindTables))
3588 CmdArgs.push_back(
"-munwind-tables");
3590 getToolChain().addClangTargetOptions(Args, CmdArgs,
3593 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3594 CmdArgs.push_back(
"-mlimit-float-precision");
3595 CmdArgs.push_back(A->getValue());
3599 (void)Args.hasArg(options::OPT_mtune_EQ);
3601 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
3602 CmdArgs.push_back(
"-mcode-model");
3603 CmdArgs.push_back(A->getValue());
3607 std::string CPU =
getCPUName(Args, Triple,
false);
3609 CmdArgs.push_back(
"-target-cpu");
3610 CmdArgs.push_back(Args.MakeArgString(CPU));
3613 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
3617 bool EmitCodeView =
false;
3622 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
3624 EmitCodeView = Args.hasArg(options::OPT_gcodeview);
3626 const Arg *SplitDWARFArg =
nullptr;
3628 IsWindowsMSVC, CmdArgs, DebugInfoKind, SplitDWARFArg);
3632 bool SplitDWARF = SplitDWARFArg && RawTriple.isOSLinux() &&
3633 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
3634 isa<BackendJobAction>(JA));
3635 const char *SplitDWARFOut;
3637 CmdArgs.push_back(
"-split-dwarf-file");
3639 CmdArgs.push_back(SplitDWARFOut);
3643 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3644 CmdArgs.push_back(
"-target-linker-version");
3645 CmdArgs.push_back(A->getValue());
3649 CmdArgs.push_back(
"-momit-leaf-frame-pointer");
3653 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3655 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
3656 getToolChain().getArch() == llvm::Triple::x86) {
3657 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3658 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
3659 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
3660 << Unsupported->getOption().getName();
3663 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
3664 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
3665 << Unsupported->getOption().getName()
3666 <<
"please use -maltivec and include altivec.h explicitly";
3667 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
3668 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
3669 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
3672 Args.AddAllArgs(CmdArgs, options::OPT_v);
3673 Args.AddLastArg(CmdArgs, options::OPT_H);
3675 CmdArgs.push_back(
"-header-include-file");
3679 Args.AddLastArg(CmdArgs, options::OPT_P);
3680 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
3683 CmdArgs.push_back(
"-diagnostic-log-file");
3690 if (Args.hasFlag(options::OPT_ffunction_sections,
3691 options::OPT_fno_function_sections, UseSeparateSections)) {
3692 CmdArgs.push_back(
"-ffunction-sections");
3695 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
3696 UseSeparateSections)) {
3697 CmdArgs.push_back(
"-fdata-sections");
3700 if (!Args.hasFlag(options::OPT_funique_section_names,
3701 options::OPT_fno_unique_section_names,
true))
3702 CmdArgs.push_back(
"-fno-unique-section-names");
3704 if (
auto *A = Args.getLastArg(
3705 options::OPT_finstrument_functions,
3706 options::OPT_finstrument_functions_after_inlining,
3707 options::OPT_finstrument_function_entry_bare))
3708 A->render(Args, CmdArgs);
3713 if (!Triple.isNVPTX())
3716 if (
auto *ABICompatArg = Args.getLastArg(options::OPT_fclang_abi_compat_EQ))
3717 ABICompatArg->render(Args, CmdArgs);
3720 if (RawTriple.isPS4CPU()) {
3726 if (Args.hasArg(options::OPT_nostdinc)) {
3727 CmdArgs.push_back(
"-nostdsysteminc");
3728 CmdArgs.push_back(
"-nobuiltininc");
3730 if (Args.hasArg(options::OPT_nostdlibinc))
3731 CmdArgs.push_back(
"-nostdsysteminc");
3732 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3733 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3737 CmdArgs.push_back(
"-resource-dir");
3740 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3749 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
3755 Args.ClaimAllArgs(options::OPT_D);
3758 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3759 if (A->getOption().matches(options::OPT_O4)) {
3760 CmdArgs.push_back(
"-O3");
3761 D.
Diag(diag::warn_O4_is_O3);
3763 A->render(Args, CmdArgs);
3769 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3770 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
3775 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
3776 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
3782 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
3784 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
3785 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
3786 CmdArgs.push_back(
"-pedantic");
3787 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
3788 Args.AddLastArg(CmdArgs, options::OPT_w);
3791 if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
3793 Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
3800 bool ImplyVCPPCXXVer =
false;
3801 if (Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3802 if (
Std->getOption().matches(options::OPT_ansi))
3804 CmdArgs.push_back(
"-std=c++98");
3806 CmdArgs.push_back(
"-std=c89");
3808 Std->render(Args, CmdArgs);
3811 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3812 options::OPT_ftrigraphs,
3813 options::OPT_fno_trigraphs))
3815 A->render(Args, CmdArgs);
3824 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
3826 else if (IsWindowsMSVC)
3827 ImplyVCPPCXXVer =
true;
3829 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3830 options::OPT_fno_trigraphs);
3846 Args.getLastArg(options::OPT_Wwrite_strings,
3847 options::OPT_Wno_write_strings, options::OPT_w);
3849 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
3850 CmdArgs.push_back(
"-fconst-strings");
3857 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3859 CmdArgs.push_back(
"-fdeprecated-macro");
3863 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3864 if (Asm->getOption().matches(options::OPT_fasm))
3865 CmdArgs.push_back(
"-fgnu-keywords");
3867 CmdArgs.push_back(
"-fno-gnu-keywords");
3871 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
3874 CmdArgs.push_back(
"-fno-autolink");
3881 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3882 options::OPT_ftemplate_depth_EQ)) {
3883 CmdArgs.push_back(
"-ftemplate-depth");
3884 CmdArgs.push_back(A->getValue());
3887 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3888 CmdArgs.push_back(
"-foperator-arrow-depth");
3889 CmdArgs.push_back(A->getValue());
3892 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3893 CmdArgs.push_back(
"-fconstexpr-depth");
3894 CmdArgs.push_back(A->getValue());
3897 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3898 CmdArgs.push_back(
"-fconstexpr-steps");
3899 CmdArgs.push_back(A->getValue());
3902 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3903 CmdArgs.push_back(
"-fbracket-depth");
3904 CmdArgs.push_back(A->getValue());
3907 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3908 options::OPT_Wlarge_by_value_copy_def)) {
3909 if (A->getNumValues()) {
3910 StringRef
bytes = A->getValue();
3911 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
3913 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
3916 if (Args.hasArg(options::OPT_relocatable_pch))
3917 CmdArgs.push_back(
"-relocatable-pch");
3919 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3920 CmdArgs.push_back(
"-fconstant-string-class");
3921 CmdArgs.push_back(A->getValue());
3924 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3925 CmdArgs.push_back(
"-ftabstop");
3926 CmdArgs.push_back(A->getValue());
3929 if (Args.hasFlag(options::OPT_fstack_size_section,
3930 options::OPT_fno_stack_size_section, RawTriple.isPS4()))
3931 CmdArgs.push_back(
"-fstack-size-section");
3933 CmdArgs.push_back(
"-ferror-limit");
3934 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
3935 CmdArgs.push_back(A->getValue());
3937 CmdArgs.push_back(
"19");
3939 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3940 CmdArgs.push_back(
"-fmacro-backtrace-limit");
3941 CmdArgs.push_back(A->getValue());
3944 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3945 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
3946 CmdArgs.push_back(A->getValue());
3949 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3950 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
3951 CmdArgs.push_back(A->getValue());
3954 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3955 CmdArgs.push_back(
"-fspell-checking-limit");
3956 CmdArgs.push_back(A->getValue());
3960 CmdArgs.push_back(
"-fmessage-length");
3961 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
3962 CmdArgs.push_back(A->getValue());
3966 unsigned N = llvm::sys::Process::StandardErrColumns();
3967 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
3971 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3972 options::OPT_fvisibility_ms_compat)) {
3973 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3974 CmdArgs.push_back(
"-fvisibility");
3975 CmdArgs.push_back(A->getValue());
3977 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3978 CmdArgs.push_back(
"-fvisibility");
3979 CmdArgs.push_back(
"hidden");
3980 CmdArgs.push_back(
"-ftype-visibility");
3981 CmdArgs.push_back(
"default");
3985 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
3987 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3990 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
3991 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
3992 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
3993 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3994 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls,
3995 options::OPT_fno_emulated_tls);
3998 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
3999 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4001 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4002 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
4006 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4007 options::OPT_fno_openmp,
false) &&
4014 CmdArgs.push_back(
"-fopenmp");
4019 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
4020 options::OPT_fnoopenmp_use_tls,
true))
4021 CmdArgs.push_back(
"-fnoopenmp-use-tls");
4022 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
4023 options::OPT_fno_openmp_simd);
4024 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
4028 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_cuda_mode,
4029 options::OPT_fno_openmp_cuda_mode);
4041 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
4042 options::OPT_fno_openmp_simd);
4043 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
4046 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
4047 Sanitize.
addArgs(getToolChain(), Args, CmdArgs, InputType);
4049 const XRayArgs &XRay = getToolChain().getXRayArgs();
4050 XRay.
addArgs(getToolChain(), Args, CmdArgs, InputType);
4052 if (getToolChain().SupportsProfiling())
4053 Args.AddLastArg(CmdArgs, options::OPT_pg);
4055 if (getToolChain().SupportsProfiling())
4056 Args.AddLastArg(CmdArgs, options::OPT_mfentry);
4059 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4060 options::OPT_fno_lax_vector_conversions))
4061 CmdArgs.push_back(
"-fno-lax-vector-conversions");
4063 if (Args.getLastArg(options::OPT_fapple_kext) ||
4064 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
4065 CmdArgs.push_back(
"-fapple-kext");
4067 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
4068 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
4069 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
4070 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4071 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
4073 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4074 CmdArgs.push_back(
"-ftrapv-handler");
4075 CmdArgs.push_back(A->getValue());
4078 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
4082 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
4083 if (A->getOption().matches(options::OPT_fwrapv))
4084 CmdArgs.push_back(
"-fwrapv");
4085 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4086 options::OPT_fno_strict_overflow)) {
4087 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4088 CmdArgs.push_back(
"-fwrapv");
4091 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4092 options::OPT_fno_reroll_loops))
4093 if (A->getOption().matches(options::OPT_freroll_loops))
4094 CmdArgs.push_back(
"-freroll-loops");
4096 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
4097 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4098 options::OPT_fno_unroll_loops);
4100 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4105 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4107 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
4109 if (Args.hasArg(options::OPT_mstack_alignment)) {
4110 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4111 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
4114 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4115 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4118 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
4120 CmdArgs.push_back(
"-mstack-probe-size=0");
4123 if (!Args.hasFlag(options::OPT_mstack_arg_probe,
4124 options::OPT_mno_stack_arg_probe,
true))
4125 CmdArgs.push_back(Args.MakeArgString(
"-mno-stack-arg-probe"));
4127 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4128 options::OPT_mno_restrict_it)) {
4129 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4130 CmdArgs.push_back(
"-mllvm");
4131 CmdArgs.push_back(
"-arm-restrict-it");
4133 CmdArgs.push_back(
"-mllvm");
4134 CmdArgs.push_back(
"-arm-no-restrict-it");
4136 }
else if (Triple.isOSWindows() &&
4137 (Triple.getArch() == llvm::Triple::arm ||
4138 Triple.getArch() == llvm::Triple::thumb)) {
4140 CmdArgs.push_back(
"-mllvm");
4141 CmdArgs.push_back(
"-arm-restrict-it");
4147 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
4149 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
4155 StringRef fname = A->getValue();
4156 if (!llvm::sys::fs::exists(fname))
4157 D.
Diag(diag::err_drv_no_such_file) << fname;
4159 A->render(Args, CmdArgs);
4164 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4165 options::OPT_fno_assume_sane_operator_new))
4166 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4169 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
4170 getToolChain().IsBlocksDefault()) ||
4171 (Args.hasArg(options::OPT_fgnu_runtime) &&
4172 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4173 !Args.hasArg(options::OPT_fno_blocks))) {
4174 CmdArgs.push_back(
"-fblocks");
4176 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4177 !getToolChain().hasBlocksRuntime())
4178 CmdArgs.push_back(
"-fblocks-runtime-optional");
4182 if (getToolChain().IsEncodeExtendedBlockSignatureDefault())
4183 CmdArgs.push_back(
"-fencode-extended-block-signature");
4185 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
4188 CmdArgs.push_back(
"-fcoroutines-ts");
4191 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
4192 options::OPT_fno_double_square_bracket_attributes);
4194 bool HaveModules =
false;
4198 if (Args.hasFlag(options::OPT_fno_access_control,
4199 options::OPT_faccess_control,
false))
4200 CmdArgs.push_back(
"-fno-access-control");
4203 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4204 options::OPT_felide_constructors,
false))
4205 CmdArgs.push_back(
"-fno-elide-constructors");
4211 CmdArgs.push_back(
"-fno-rtti");
4214 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4215 getToolChain().getArch() == llvm::Triple::hexagon))
4216 CmdArgs.push_back(
"-fshort-enums");
4222 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
4223 !RawTriple.isOSWindows() &&
4224 RawTriple.getOS() != llvm::Triple::Solaris &&
4225 getToolChain().getArch() != llvm::Triple::hexagon &&
4226 getToolChain().getArch() != llvm::Triple::xcore &&
4227 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
4228 RawTriple.hasEnvironment())) ||
4230 CmdArgs.push_back(
"-fno-use-cxa-atexit");
4232 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
4233 options::OPT_fno_register_global_dtors_with_atexit,
4234 RawTriple.isOSDarwin() && !KernelOrKext))
4235 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
4238 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
4240 CmdArgs.push_back(
"-fms-extensions");
4243 if (Args.hasFlag(options::OPT_fuse_line_directives,
4244 options::OPT_fno_use_line_directives,
false))
4245 CmdArgs.push_back(
"-fuse-line-directives");
4248 if (Args.hasFlag(options::OPT_fms_compatibility,
4249 options::OPT_fno_ms_compatibility,
4251 Args.hasFlag(options::OPT_fms_extensions,
4252 options::OPT_fno_ms_extensions,
true))))
4253 CmdArgs.push_back(
"-fms-compatibility");
4255 VersionTuple MSVT = getToolChain().computeMSVCVersion(&D, Args);
4258 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
4260 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4261 if (ImplyVCPPCXXVer) {
4262 StringRef LanguageStandard;
4263 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
4264 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
4265 .Case(
"c++14",
"-std=c++14")
4266 .Case(
"c++17",
"-std=c++17")
4267 .Case(
"c++latest",
"-std=c++2a")
4269 if (LanguageStandard.empty())
4270 D.
Diag(clang::diag::warn_drv_unused_argument)
4271 << StdArg->getAsString(Args);
4274 if (LanguageStandard.empty()) {
4275 if (IsMSVC2015Compatible)
4276 LanguageStandard =
"-std=c++14";
4278 LanguageStandard =
"-std=c++11";
4281 CmdArgs.push_back(LanguageStandard.data());
4285 if (Args.hasFlag(options::OPT_fborland_extensions,
4286 options::OPT_fno_borland_extensions,
false))
4287 CmdArgs.push_back(
"-fborland-extensions");
4290 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
4292 CmdArgs.push_back(
"-fdeclspec");
4293 else if (Args.hasArg(options::OPT_fno_declspec))
4294 CmdArgs.push_back(
"-fno-declspec");
4298 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4299 options::OPT_fno_threadsafe_statics,
4300 !IsWindowsMSVC || IsMSVC2015Compatible))
4301 CmdArgs.push_back(
"-fno-threadsafe-statics");
4307 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
4308 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
4309 CmdArgs.push_back(
"-fdelayed-template-parsing");
4313 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
4314 options::OPT_fno_gnu_keywords))
4315 A->render(Args, CmdArgs);
4317 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
4319 CmdArgs.push_back(
"-fgnu89-inline");
4321 if (Args.hasArg(options::OPT_fno_inline))
4322 CmdArgs.push_back(
"-fno-inline");
4324 if (Arg* InlineArg = Args.getLastArg(options::OPT_finline_functions,
4325 options::OPT_finline_hint_functions,
4326 options::OPT_fno_inline_functions))
4327 InlineArg->render(Args, CmdArgs);
4329 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager,
4330 options::OPT_fno_experimental_new_pass_manager);
4332 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
4334 rewriteKind != RK_None, Input, CmdArgs);
4336 if (Args.hasFlag(options::OPT_fapplication_extension,
4337 options::OPT_fno_application_extension,
false))
4338 CmdArgs.push_back(
"-fapplication-extension");
4346 Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
4347 options::OPT_fseh_exceptions,
4348 options::OPT_fdwarf_exceptions);
4350 const Option &Opt = A->getOption();
4351 if (Opt.matches(options::OPT_fsjlj_exceptions))
4352 CmdArgs.push_back(
"-fsjlj-exceptions");
4353 if (Opt.matches(options::OPT_fseh_exceptions))
4354 CmdArgs.push_back(
"-fseh-exceptions");
4355 if (Opt.matches(options::OPT_fdwarf_exceptions))
4356 CmdArgs.push_back(
"-fdwarf-exceptions");
4358 switch (getToolChain().GetExceptionModel(Args)) {
4361 case llvm::ExceptionHandling::DwarfCFI:
4362 CmdArgs.push_back(
"-fdwarf-exceptions");
4364 case llvm::ExceptionHandling::SjLj:
4365 CmdArgs.push_back(
"-fsjlj-exceptions");
4367 case llvm::ExceptionHandling::WinEH:
4368 CmdArgs.push_back(
"-fseh-exceptions");
4374 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4375 options::OPT_fno_assume_sane_operator_new))
4376 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4381 if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
4382 options::OPT_fno_relaxed_template_template_args,
false))
4383 CmdArgs.push_back(
"-frelaxed-template-template-args");
4387 if (Args.hasFlag(options::OPT_fsized_deallocation,
4388 options::OPT_fno_sized_deallocation,
false))
4389 CmdArgs.push_back(
"-fsized-deallocation");
4393 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
4394 options::OPT_fno_aligned_allocation,
4395 options::OPT_faligned_new_EQ)) {
4396 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
4397 CmdArgs.push_back(
"-fno-aligned-allocation");
4399 CmdArgs.push_back(
"-faligned-allocation");
4404 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
4405 options::OPT_faligned_new_EQ))
4407 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
4411 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4412 options::OPT_fno_constant_cfstrings) ||
4413 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4414 options::OPT_mno_constant_cfstrings))
4415 CmdArgs.push_back(
"-fno-constant-cfstrings");
4418 if (Args.hasFlag(options::OPT_fpascal_strings,
4419 options::OPT_fno_pascal_strings,
false))
4420 CmdArgs.push_back(
"-fpascal-strings");
4424 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
4425 std::string PackStructStr =
"-fpack-struct=";
4426 PackStructStr += A->getValue();
4427 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
4428 }
else if (Args.hasFlag(options::OPT_fpack_struct,
4429 options::OPT_fno_pack_struct,
false)) {
4430 CmdArgs.push_back(
"-fpack-struct=1");
4434 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4435 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4436 if (!SkipMaxTypeAlign) {
4437 std::string MaxTypeAlignStr =
"-fmax-type-align=";
4438 MaxTypeAlignStr += A->getValue();
4439 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4441 }
else if (RawTriple.isOSDarwin()) {
4442 if (!SkipMaxTypeAlign) {
4443 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
4444 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4448 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
4449 CmdArgs.push_back(
"-Qn");
4453 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
4455 CmdArgs.push_back(
"-fno-common");
4459 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
4460 options::OPT_funsigned_bitfields))
4461 D.
Diag(diag::warn_drv_clang_unsupported)
4462 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4465 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
4466 D.
Diag(diag::err_drv_clang_unsupported)
4467 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4470 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4471 StringRef value = inputCharset->getValue();
4472 if (!value.equals_lower(
"utf-8"))
4473 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4478 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4479 StringRef value = execCharset->getValue();
4480 if (!value.equals_lower(
"utf-8"))
4481 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4488 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4490 CmdArgs.push_back(
"-fasm-blocks");
4493 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4494 options::OPT_fno_gnu_inline_asm,
true))
4495 CmdArgs.push_back(
"-fno-gnu-inline-asm");
4501 OptSpecifier VectorizeAliasOption =
4502 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
4503 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4504 options::OPT_fno_vectorize, EnableVec))
4505 CmdArgs.push_back(
"-vectorize-loops");
4509 OptSpecifier SLPVectAliasOption =
4510 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
4511 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4512 options::OPT_fno_slp_vectorize, EnableSLPVec))
4513 CmdArgs.push_back(
"-vectorize-slp");
4517 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4518 A->render(Args, CmdArgs);
4520 if (Arg *A = Args.getLastArg(
4521 options::OPT_fsanitize_undefined_strip_path_components_EQ))
4522 A->render(Args, CmdArgs);
4526 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4527 options::OPT_fno_dollars_in_identifiers)) {
4528 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
4529 CmdArgs.push_back(
"-fdollars-in-identifiers");
4531 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
4536 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4537 options::OPT_fno_unit_at_a_time)) {
4538 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
4539 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4542 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4543 options::OPT_fno_apple_pragma_pack,
false))
4544 CmdArgs.push_back(
"-fapple-pragma-pack");
4546 if (Args.hasFlag(options::OPT_fsave_optimization_record,
4547 options::OPT_foptimization_record_file_EQ,
4548 options::OPT_fno_save_optimization_record,
false)) {
4549 CmdArgs.push_back(
"-opt-record-file");
4551 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
4553 CmdArgs.push_back(A->getValue());
4557 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
4558 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
4559 F = FinalOutput->getValue();
4564 F = llvm::sys::path::stem(Input.getBaseInput());
4571 llvm::sys::path::replace_extension(F,
"");
4573 Triple.normalize());
4579 llvm::sys::path::replace_extension(F,
"opt.yaml");
4580 CmdArgs.push_back(Args.MakeArgString(F));
4584 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
4585 options::OPT_fno_rewrite_imports,
false);
4587 CmdArgs.push_back(
"-frewrite-imports");
4593 if (Args.hasFlag(options::OPT_frewrite_includes,
4594 options::OPT_fno_rewrite_includes,
false) ||
4596 CmdArgs.push_back(
"-frewrite-includes");
4599 if (Arg *A = Args.getLastArg(options::OPT_traditional,
4600 options::OPT_traditional_cpp)) {
4601 if (isa<PreprocessJobAction>(JA))
4602 CmdArgs.push_back(
"-traditional-cpp");
4604 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
4607 Args.AddLastArg(CmdArgs, options::OPT_dM);
4608 Args.AddLastArg(CmdArgs, options::OPT_dD);
4611 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4612 CmdArgs.push_back(
"-serialize-diagnostic-file");
4613 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
4616 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4617 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
4620 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
4622 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
4625 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
4626 CmdArgs.push_back(
"-load");
4627 CmdArgs.push_back(A->getValue());
4633 if (!StatsFile.empty())
4634 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
4641 !isa<PreprocessJobAction>(JA)) {
4642 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
4644 if (StringRef(Arg->getValue()) !=
"-finclude-default-header")
4645 CmdArgs.push_back(Arg->getValue());
4649 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
4651 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
4657 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
4658 CmdArgs.push_back(
"-disable-llvm-optzns");
4660 A->render(Args, CmdArgs);
4674 isa<CompileJobAction>(JA))
4675 CmdArgs.push_back(
"-disable-llvm-passes");
4677 if (Output.
getType() == types::TY_Dependencies) {
4680 CmdArgs.push_back(
"-o");
4683 assert(Output.
isNothing() &&
"Invalid output.");
4688 if (Input.isFilename())
4689 CmdArgs.push_back(Input.getFilename());
4691 Input.getInputArg().renderAsInput(Args, CmdArgs);
4693 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4702 if (getToolChain().UseDwarfDebugFlags() ||
4703 Args.hasFlag(options::OPT_grecord_gcc_switches,
4704 options::OPT_gno_record_gcc_switches,
false)) {
4705 ArgStringList OriginalArgs;
4706 for (
const auto &Arg : Args)
4707 Arg->render(Args, OriginalArgs);
4711 for (
const char *OriginalArg : OriginalArgs) {
4715 Flags += EscapedArg;
4717 CmdArgs.push_back(
"-dwarf-debug-flags");
4718 CmdArgs.push_back(Args.MakeArgString(Flags));
4724 if (Inputs.size() > 1) {
4725 assert(Inputs.size() == 2 &&
"More than one GPU binary!");
4726 CmdArgs.push_back(
"-fcuda-include-gpubinary");
4727 CmdArgs.push_back(Inputs[1].getFilename());
4730 if (Args.hasFlag(options::OPT_fcuda_rdc, options::OPT_fno_cuda_rdc,
false))
4731 CmdArgs.push_back(
"-fcuda-rdc");
4732 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
4733 options::OPT_fno_cuda_short_ptr,
false))
4734 CmdArgs.push_back(
"-fcuda-short-ptr");
4742 if (IsOpenMPDevice) {
4743 CmdArgs.push_back(
"-fopenmp-is-device");
4744 if (Inputs.size() == 2) {
4745 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
4746 CmdArgs.push_back(Args.MakeArgString(Inputs.back().getFilename()));
4755 Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ);
4756 assert(Tgts && Tgts->getNumValues() &&
4757 "OpenMP offloading has to have targets specified.");
4758 for (
unsigned i = 0; i < Tgts->getNumValues(); ++i) {
4763 llvm::Triple T(Tgts->getValue(i));
4764 TargetInfo += T.getTriple();
4766 CmdArgs.push_back(Args.MakeArgString(TargetInfo.str()));
4769 bool WholeProgramVTables =
4770 Args.hasFlag(options::OPT_fwhole_program_vtables,
4771 options::OPT_fno_whole_program_vtables,
false);
4772 if (WholeProgramVTables) {
4774 D.
Diag(diag::err_drv_argument_only_allowed_with)
4775 <<
"-fwhole-program-vtables" 4777 CmdArgs.push_back(
"-fwhole-program-vtables");
4780 if (Arg *A = Args.getLastArg(options::OPT_fexperimental_isel,
4781 options::OPT_fno_experimental_isel)) {
4782 CmdArgs.push_back(
"-mllvm");
4783 if (A->getOption().matches(options::OPT_fexperimental_isel)) {
4784 CmdArgs.push_back(
"-global-isel=1");
4789 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
4790 bool IsOptLevelSupported =
false;
4792 Arg *A = Args.getLastArg(options::OPT_O_Group);
4793 if (Triple.getArch() == llvm::Triple::aarch64) {
4794 if (!A || A->getOption().matches(options::OPT_O0))
4795 IsOptLevelSupported =
true;
4797 if (!IsArchSupported || !IsOptLevelSupported) {
4798 CmdArgs.push_back(
"-mllvm");
4799 CmdArgs.push_back(
"-global-isel-abort=2");
4801 if (!IsArchSupported)
4802 D.
Diag(diag::warn_drv_experimental_isel_incomplete) << Triple.getArchName();
4804 D.
Diag(diag::warn_drv_experimental_isel_incomplete_opt);
4807 CmdArgs.push_back(
"-global-isel=0");
4811 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
4812 options::OPT_fno_force_enable_int128)) {
4813 if (A->getOption().matches(options::OPT_fforce_enable_int128))
4814 CmdArgs.push_back(
"-fforce-enable-int128");
4817 if (Args.hasFlag(options::OPT_fcomplete_member_pointers,
4818 options::OPT_fno_complete_member_pointers,
false))
4819 CmdArgs.push_back(
"-fcomplete-member-pointers");
4821 if (Arg *A = Args.getLastArg(options::OPT_moutline,
4822 options::OPT_mno_outline)) {
4823 if (A->getOption().matches(options::OPT_moutline)) {
4827 if (Triple.getArch() != llvm::Triple::aarch64) {
4828 D.
Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
4830 CmdArgs.push_back(
"-mllvm");
4831 CmdArgs.push_back(
"-enable-machine-outliner");
4835 CmdArgs.push_back(
"-mllvm");
4836 CmdArgs.push_back(
"-enable-machine-outliner=never");
4840 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
4841 getToolChain().getTriple().isOSBinFormatELF() &&
4842 getToolChain().useIntegratedAs()))
4843 CmdArgs.push_back(
"-faddrsig");
4846 if (Args.hasArg(options::OPT__SLASH_fallback) &&
4847 Output.
getType() == types::TY_Object &&
4848 (InputType == types::TY_C || InputType == types::TY_CXX)) {
4850 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4851 C.
addCommand(llvm::make_unique<FallbackCommand>(
4852 JA, *
this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
4853 }
else if (Args.hasArg(options::OPT__SLASH_fallback) &&
4854 isa<PrecompileJobAction>(JA)) {
4857 C.
addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *
this, Exec,
4860 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
4863 if (Arg *A = Args.getLastArg(options::OPT_pg))
4864 if (Args.hasArg(options::OPT_fomit_frame_pointer))
4865 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer" 4866 << A->getAsString(Args);
4873 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
4877 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4878 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
4881 Args.ClaimAllArgs(options::OPT_emit_llvm);
4888 :
Tool(
"clang",
"clang frontend", TC, RF_Full) {}
4895 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
4896 ArgStringList &cmdArgs,
4897 RewriteKind rewriteKind)
const {
4900 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
4901 options::OPT_fobjc_runtime_EQ);
4906 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4908 StringRef value = runtimeArg->getValue();
4914 (runtime.
getVersion() >= VersionTuple(2, 0)))
4917 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
4921 runtimeArg->render(args, cmdArgs);
4930 unsigned objcABIVersion = 1;
4932 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
4933 StringRef value = abiArg->getValue();
4936 else if (value ==
"2")
4938 else if (value ==
"3")
4944 bool nonFragileABIIsDefault =
4945 (rewriteKind == RK_NonFragile ||
4946 (rewriteKind == RK_None &&
4948 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4949 options::OPT_fno_objc_nonfragile_abi,
4950 nonFragileABIIsDefault)) {
4952 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 4953 unsigned nonFragileABIVersion = 1;
4955 unsigned nonFragileABIVersion = 2;
4959 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
4960 StringRef value = abiArg->getValue();
4962 nonFragileABIVersion = 1;
4963 else if (value ==
"2")
4964 nonFragileABIVersion = 2;
4970 objcABIVersion = 1 + nonFragileABIVersion;
4978 bool isNonFragile = objcABIVersion != 1;
4984 switch (rewriteKind) {
4997 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5009 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
5019 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
5024 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
5032 bool Asynch =
false;
5033 bool NoUnwindC =
false;
5047 std::vector<std::string> EHArgs =
5048 Args.getAllArgValues(options::OPT__SLASH_EH);
5049 for (
auto EHVal : EHArgs) {
5050 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
5068 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
5074 if (EHArgs.empty() &&
5075 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
5078 EH.NoUnwindC =
true;
5084 void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
5085 ArgStringList &CmdArgs,
5087 bool *EmitCodeView)
const {
5088 unsigned RTOptionID = options::OPT__SLASH_MT;
5090 if (Args.hasArg(options::OPT__SLASH_LDd))
5093 RTOptionID = options::OPT__SLASH_MTd;
5095 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
5096 RTOptionID = A->getOption().getID();
5098 StringRef FlagForCRT;
5099 switch (RTOptionID) {
5100 case options::OPT__SLASH_MD:
5101 if (Args.hasArg(options::OPT__SLASH_LDd))
5102 CmdArgs.push_back(
"-D_DEBUG");
5103 CmdArgs.push_back(
"-D_MT");
5104 CmdArgs.push_back(
"-D_DLL");
5105 FlagForCRT =
"--dependent-lib=msvcrt";
5107 case options::OPT__SLASH_MDd:
5108 CmdArgs.push_back(
"-D_DEBUG");
5109 CmdArgs.push_back(
"-D_MT");
5110 CmdArgs.push_back(
"-D_DLL");
5111 FlagForCRT =
"--dependent-lib=msvcrtd";
5113 case options::OPT__SLASH_MT:
5114 if (Args.hasArg(options::OPT__SLASH_LDd))
5115 CmdArgs.push_back(
"-D_DEBUG");
5116 CmdArgs.push_back(
"-D_MT");
5117 CmdArgs.push_back(
"-flto-visibility-public-std");
5118 FlagForCRT =
"--dependent-lib=libcmt";
5120 case options::OPT__SLASH_MTd:
5121 CmdArgs.push_back(
"-D_DEBUG");
5122 CmdArgs.push_back(
"-D_MT");
5123 CmdArgs.push_back(
"-flto-visibility-public-std");
5124 FlagForCRT =
"--dependent-lib=libcmtd";
5127 llvm_unreachable(
"Unexpected option ID.");
5130 if (Args.hasArg(options::OPT__SLASH_Zl)) {
5131 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
5133 CmdArgs.push_back(FlagForCRT.data());
5138 CmdArgs.push_back(
"--dependent-lib=oldnames");
5141 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5142 A->render(Args, CmdArgs);
5145 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5147 CmdArgs.push_back(
"-fno-rtti-data");
5151 if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
5153 CmdArgs.push_back(
"-stack-protector");
5158 if (Arg *DebugInfoArg =
5159 Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
5160 options::OPT_gline_tables_only)) {
5161 *EmitCodeView =
true;
5162 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
5166 CmdArgs.push_back(
"-gcodeview");
5168 *EmitCodeView =
false;
5173 if (EH.Synch || EH.Asynch) {
5175 CmdArgs.push_back(
"-fcxx-exceptions");
5176 CmdArgs.push_back(
"-fexceptions");
5178 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
5179 CmdArgs.push_back(
"-fexternc-nounwind");
5182 if (Args.hasArg(options::OPT__SLASH_EP)) {
5183 CmdArgs.push_back(
"-E");
5184 CmdArgs.push_back(
"-P");
5187 unsigned VolatileOptionID;
5188 if (
getToolChain().getArch() == llvm::Triple::x86_64 ||
5190 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5192 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5194 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5195 VolatileOptionID = A->getOption().getID();
5197 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5198 CmdArgs.push_back(
"-fms-volatile");
5200 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5201 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5202 if (MostGeneralArg && BestCaseArg)
5203 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5204 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5206 if (MostGeneralArg) {
5207 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5208 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5209 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5211 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5212 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5213 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5214 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5215 << FirstConflict->getAsString(Args)
5216 << SecondConflict->getAsString(Args);
5219 CmdArgs.push_back(
"-fms-memptr-rep=single");
5220 else if (MultipleArg)
5221 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
5223 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
5228 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
5229 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
5230 options::OPT__SLASH_Gregcall)) {
5231 unsigned DCCOptId = CCArg->getOption().getID();
5232 const char *DCCFlag =
nullptr;
5233 bool ArchSupported =
true;
5236 case options::OPT__SLASH_Gd:
5237 DCCFlag =
"-fdefault-calling-conv=cdecl";
5239 case options::OPT__SLASH_Gr:
5240 ArchSupported = Arch == llvm::Triple::x86;
5241 DCCFlag =
"-fdefault-calling-conv=fastcall";
5243 case options::OPT__SLASH_Gz:
5244 ArchSupported = Arch == llvm::Triple::x86;
5245 DCCFlag =
"-fdefault-calling-conv=stdcall";
5247 case options::OPT__SLASH_Gv:
5248 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
5249 DCCFlag =
"-fdefault-calling-conv=vectorcall";
5251 case options::OPT__SLASH_Gregcall:
5252 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
5253 DCCFlag =
"-fdefault-calling-conv=regcall";
5258 if (ArchSupported && DCCFlag)
5259 CmdArgs.push_back(DCCFlag);
5262 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5263 A->render(Args, CmdArgs);
5265 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5266 CmdArgs.push_back(
"-fdiagnostics-format");
5267 if (Args.hasArg(options::OPT__SLASH_fallback))
5268 CmdArgs.push_back(
"msvc-fallback");
5270 CmdArgs.push_back(
"msvc");
5273 if (Args.hasArg(options::OPT__SLASH_Guard) &&
5274 Args.getLastArgValue(options::OPT__SLASH_Guard).equals_lower(
"cf"))
5275 CmdArgs.push_back(
"-cfguard");
5281 return CLFallback.get();
5287 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
5294 if (
const char *
End = strrchr(Str,
'.'))
5295 return Args.MakeArgString(std::string(Str,
End));
5305 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
5306 std::string Str(OutputOpt->getValue());
5307 Res = Str.substr(0, Str.rfind(
'.'));
5311 return Args.MakeArgString(Res +
".d");
5317 ArgStringList &CmdArgs)
const {
5323 CmdArgs.push_back(
"-target-abi");
5324 CmdArgs.push_back(ABIName.data());
5328 ArgStringList &CmdArgs)
const {
5329 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
5330 StringRef
Value = A->getValue();
5331 if (Value ==
"intel" || Value ==
"att") {
5332 CmdArgs.push_back(
"-mllvm");
5333 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
5336 << A->getOption().getName() <<
Value;
5343 const ArgList &Args,
5344 const char *LinkingOutput)
const {
5345 ArgStringList CmdArgs;
5347 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
5351 const std::string &TripleStr = Triple.getTriple();
5355 Args.ClaimAllArgs(options::OPT_w);
5357 Args.ClaimAllArgs(options::OPT_emit_llvm);
5364 CmdArgs.push_back(
"-cc1as");
5367 CmdArgs.push_back(
"-triple");
5368 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5372 CmdArgs.push_back(
"-filetype");
5373 CmdArgs.push_back(
"obj");
5377 CmdArgs.push_back(
"-main-file-name");
5381 std::string CPU =
getCPUName(Args, Triple,
true);
5383 CmdArgs.push_back(
"-target-cpu");
5384 CmdArgs.push_back(Args.MakeArgString(CPU));
5391 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5394 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5397 const Action *SourceAction = &JA;
5399 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
5400 SourceAction = SourceAction->
getInputs()[0];
5405 bool WantDebug =
false;
5406 unsigned DwarfVersion = 0;
5407 Args.ClaimAllArgs(options::OPT_g_Group);
5408 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
5409 WantDebug = !A->getOption().matches(options::OPT_g0) &&
5410 !A->getOption().matches(options::OPT_ggdb0);
5414 if (DwarfVersion == 0)
5419 if (SourceAction->
getType() == types::TY_Asm ||
5420 SourceAction->
getType() == types::TY_PP_Asm) {
5434 CmdArgs.push_back(
"-dwarf-debug-producer");
5438 Args.AddAllArgs(CmdArgs, options::OPT_I);
5441 llvm::DebuggerKind::Default);
5447 llvm::Reloc::Model RelocationModel;
5450 std::tie(RelocationModel, PICLevel, IsPIE) =
5455 CmdArgs.push_back(
"-mrelocation-model");
5456 CmdArgs.push_back(RMName);
5462 ArgStringList OriginalArgs;
5463 for (
const auto &Arg : Args)
5464 Arg->render(Args, OriginalArgs);
5469 for (
const char *OriginalArg : OriginalArgs) {
5473 Flags += EscapedArg;
5475 CmdArgs.push_back(
"-dwarf-debug-flags");
5476 CmdArgs.push_back(Args.MakeArgString(Flags));
5486 case llvm::Triple::mips:
5487 case llvm::Triple::mipsel:
5488 case llvm::Triple::mips64:
5489 case llvm::Triple::mips64el:
5490 AddMIPSTargetArgs(Args, CmdArgs);
5493 case llvm::Triple::x86:
5494 case llvm::Triple::x86_64:
5495 AddX86TargetArgs(Args, CmdArgs);
5498 case llvm::Triple::arm:
5499 case llvm::Triple::armeb:
5500 case llvm::Triple::thumb:
5501 case llvm::Triple::thumbeb:
5504 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
5505 options::OPT_mno_default_build_attributes,
true)) {
5506 CmdArgs.push_back(
"-mllvm");
5507 CmdArgs.push_back(
"-arm-add-build-attributes");
5517 Args.ClaimAllArgs(options::OPT_W_Group);
5522 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
5524 assert(Output.
isFilename() &&
"Unexpected lipo output.");
5525 CmdArgs.push_back(
"-o");
5528 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
5530 CmdArgs.push_back(
"-split-dwarf-file");
5534 assert(Input.isFilename() &&
"Invalid input.");
5535 CmdArgs.push_back(Input.getFilename());
5538 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
5546 const llvm::opt::ArgList &TCArgs,
5547 const char *LinkingOutput)
const {
5549 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
5557 ArgStringList CmdArgs;
5560 CmdArgs.push_back(TCArgs.MakeArgString(
5563 assert(JA.
getInputs().size() == Inputs.size() &&
5564 "Not have inputs for all dependence actions??");
5568 Triples +=
"-targets=";
5569 for (
unsigned I = 0; I < Inputs.size(); ++I) {
5578 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
5580 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
5581 assert(CurTC ==
nullptr &&
"Expected one dependence!");
5588 Triples += CurTC->
getTriple().normalize();
5594 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
5598 TCArgs.MakeArgString(Twine(
"-outputs=") + Output.
getFilename()));
5603 for (
unsigned I = 0; I < Inputs.size(); ++I) {
5609 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
5611 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
5612 assert(CurTC ==
nullptr &&
"Expected one dependence!");
5618 CmdArgs.push_back(TCArgs.MakeArgString(UB));
5629 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
5630 const char *LinkingOutput)
const {
5632 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
5641 ArgStringList CmdArgs;
5643 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
5647 CmdArgs.push_back(TCArgs.MakeArgString(
5652 Triples +=
"-targets=";
5653 auto DepInfo = UA.getDependentActionsInfo();
5654 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
5658 auto &Dep = DepInfo[I];
5661 Triples += Dep.DependentToolChain->getTriple().normalize();
5663 !Dep.DependentBoundArch.empty()) {
5665 Triples += Dep.DependentBoundArch;
5669 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
5673 TCArgs.MakeArgString(Twine(
"-inputs=") + Input.getFilename()));
5678 for (
unsigned I = 0; I < Outputs.size(); ++I) {
5681 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
5683 CmdArgs.push_back(TCArgs.MakeArgString(UB));
5684 CmdArgs.push_back(
"-unbundle");
StringRef getSysRoot() const
Returns the sysroot path.
static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, ArgStringList &CmdArgs)
static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple, const ArgList &Args, ArgStringList &CmdArgs, bool ForAS)
static bool useFramePointerForTargetByDefault(const ArgList &Args, const llvm::Triple &Triple)
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC)
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
unsigned CCPrintHeaders
Set CC_PRINT_HEADERS mode, which causes the frontend to log header include information to CCPrintHead...
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.
static void addExceptionArgs(const ArgList &Args, types::ID InputType, const ToolChain &TC, bool KernelOrKext, const ObjCRuntime &objcRuntime, ArgStringList &CmdArgs)
Adds exception related arguments to the driver command arguments.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Defines types useful for describing an Objective-C runtime.
static void addDebugPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the debug file path prefix map.
static void forAllAssociatedToolChains(Compilation &C, const JobAction &JA, const ToolChain &RegularToolChain, llvm::function_ref< void(const ToolChain &)> Work)
Apply Work on the current tool chain RegularToolChain and any other offloading tool chain that is ass...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticBuilder Diag(unsigned DiagID) const
static void QuoteTarget(StringRef Target, SmallVectorImpl< char > &Res)
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args)
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
static bool shouldUseFramePointer(const ArgList &Args, const llvm::Triple &Triple)
static bool UseRelaxAll(Compilation &C, const ArgList &Args)
Check if -relax-all should be passed to the internal assembler.
static StringRef bytes(const std::vector< T, Allocator > &v)
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
bool embedBitcodeMarkerOnly() const
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, bool OFastEnabled, const ArgList &Args, ArgStringList &CmdArgs)
bool isOffloading(OffloadKind OKind) const
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.
static const char * RelocationModelName(llvm::Reloc::Model Model)
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
static void addPGOAndCoverageFlags(Compilation &C, const Driver &D, const InputInfo &Output, const ArgList &Args, ArgStringList &CmdArgs)
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
types::ID getType() const
bool isDeviceOffloading(OffloadKind OKind) const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
OffloadKind getOffloadingDeviceKind() const
static void RenderSSPOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC)
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.
static void RenderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, bool EmitCodeView, bool IsWindowsMSVC, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind &DebugInfoKind, const Arg *&SplitDWARFArg)
static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
const ToolChain & getDefaultToolChain() const
static void getDefaultModuleCachePath(SmallVectorImpl< char > &Result)
Compute the default -fmodule-cache-path.
Exposes information about the current target.
static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs)
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
const DiagnosticsEngine & getDiags() const
bool isForDiagnostics() const
Return true if we're compiling for diagnostics.
static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind DebugInfoKind, unsigned DwarfVersion, llvm::DebuggerKind DebuggerTuning)
Defines the clang::LangOptions interface.
ActionClass getKind() const
Emit only debug info necessary for generating line number tables (-gline-tables-only).
static void getWebAssemblyTargetFeatures(const ArgList &Args, std::vector< StringRef > &Features)
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
std::string getAsString() const
static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
The -mprefer-vector-width option accepts either a positive integer or the string "none".
static unsigned DwarfVersionNum(StringRef ArgValue)
Defines version macros and version-related utility functions for Clang.
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
void addCommand(std::unique_ptr< Command > C)
'gnustep' is the modern non-fragile GNUstep runtime.
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args)
const_offload_toolchains_range getOffloadToolChains() const
static bool isSignedCharDefault(const llvm::Triple &Triple)
static void RenderModulesOptions(Compilation &C, const Driver &D, const ArgList &Args, const InputInfo &Input, const InputInfo &Output, ArgStringList &CmdArgs, bool &HaveModules)
bool embedBitcodeInObject() const
static bool isNoCommonDefault(const llvm::Triple &Triple)
static void EscapeSpacesAndBackslashes(const char *Arg, SmallVectorImpl< char > &Res)
const llvm::opt::DerivedArgList & getArgs() const
static bool getRefinementStep(StringRef In, const Driver &D, const Arg &A, size_t &Position)
This is a helper function for validating the optional refinement step parameter in reciprocal argumen...
Limit generated debug info to reduce size (-fno-standalone-debug).
static bool checkDebugInfoOption(const Arg *A, const ArgList &Args, const Driver &D, const ToolChain &TC)
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
bool isSaveTempsEnabled() const
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
const VersionTuple & getVersion() const
static void appendUserToPath(SmallVectorImpl< char > &Result)
'#include ""' paths, added by 'gcc -iquote'.
Dataflow Directional Tag Classes.
const char * CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
static void RenderObjCOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, ObjCRuntime &Runtime, bool InferCovariantReturns, const InputInfo &Input, ArgStringList &CmdArgs)
The basic abstraction for the target Objective-C runtime.
Emit location information but do not generate debug info in the output.
std::string SysRoot
sysroot, if present
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
ActionList & getActions()
static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args)
/EH controls whether to run destructor cleanups when exceptions are thrown.
std::string ClangExecutable
The original path to the clang executable.
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Compilation - A set of tasks to perform for a single driver invocation.
const Driver & getDriver() const
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
const char * CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
const char * addFailureResultFile(const char *Name, const JobAction *JA)
addFailureResultFile - Add a file to remove if we crash, and returns its argument.
static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple)
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 option to specify the debug compilation directory.
static void ParseMRecip(const Driver &D, const ArgList &Args, ArgStringList &OutStrings)
The -mrecip flag requires processing of many optional parameters.
static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec)
Vectorize at all optimization levels greater than 1 except for -Oz.
static bool maybeConsumeDash(const std::string &EH, size_t &I)
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
const char * getClangProgramPath() const
Get the path to the main clang executable.
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
static bool shouldUseLeafFramePointer(const ArgList &Args, const llvm::Triple &Triple)
static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input)
static bool ContainsCompileAction(const Action *A)
Check whether the given input tree contains any compilation actions.
static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A)
static bool ShouldDisableDwarfDirectory(const ArgList &Args, const ToolChain &TC)
bool isLLVMIR(ID Id)
Is this LLVM IR.
const char * getOffloadingArch() const
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs)
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
bool allowsWeak() const
Does this runtime allow the use of __weak?
std::string ResourceDir
The path to the compiler resource directory.