34 #include "llvm/ADT/StringExtras.h" 35 #include "llvm/Config/llvm-config.h" 36 #include "llvm/Option/ArgList.h" 37 #include "llvm/Support/CodeGen.h" 38 #include "llvm/Support/Compression.h" 39 #include "llvm/Support/FileSystem.h" 40 #include "llvm/Support/Path.h" 41 #include "llvm/Support/Process.h" 42 #include "llvm/Support/TargetParser.h" 43 #include "llvm/Support/YAMLParser.h" 51 using namespace clang;
56 Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
57 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
58 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
59 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
60 << A->getBaseArg().getAsString(Args)
61 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
68 if (Args.hasArg(options::OPT_static))
70 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
71 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
96 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
101 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
117 Res.push_back(Target[i]);
126 llvm::function_ref<
void(
const ToolChain &)> Work) {
128 Work(RegularToolChain);
143 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
158 const Arg &A,
size_t &Position) {
159 const char RefinementStepToken =
':';
160 Position = In.find(RefinementStepToken);
161 if (Position != StringRef::npos) {
162 StringRef Option = A.getOption().getName();
163 StringRef RefStep = In.substr(Position + 1);
171 if (RefStep.size() != 1) {
172 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
175 char RefStepChar = RefStep[0];
176 if (RefStepChar < '0' || RefStepChar >
'9') {
177 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
186 ArgStringList &OutStrings) {
187 StringRef DisabledPrefixIn =
"!";
188 StringRef DisabledPrefixOut =
"!";
189 StringRef EnabledPrefixOut =
"";
190 StringRef Out =
"-mrecip=";
192 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
196 unsigned NumOptions = A->getNumValues();
197 if (NumOptions == 0) {
199 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
204 if (NumOptions == 1) {
205 StringRef Val = A->getValue(0);
209 StringRef ValBase = Val.slice(0, RefStepLoc);
210 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
211 OutStrings.push_back(Args.MakeArgString(Out + Val));
220 llvm::StringMap<bool> OptionStrings;
221 OptionStrings.insert(std::make_pair(
"divd",
false));
222 OptionStrings.insert(std::make_pair(
"divf",
false));
223 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
224 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
225 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
226 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
227 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
228 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
230 for (
unsigned i = 0; i != NumOptions; ++i) {
231 StringRef Val = A->getValue(i);
233 bool IsDisabled = Val.startswith(DisabledPrefixIn);
242 StringRef ValBase = Val.slice(0, RefStep);
243 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
244 if (OptionIter == OptionStrings.end()) {
246 OptionIter = OptionStrings.find(ValBase.str() +
'f');
247 if (OptionIter == OptionStrings.end()) {
249 D.
Diag(diag::err_drv_unknown_argument) << Val;
255 if (OptionStrings[ValBase.str() +
'd']) {
256 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
261 if (OptionIter->second ==
true) {
263 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
268 OptionIter->second =
true;
271 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
272 OptionStrings[ValBase.str() +
'd'] =
true;
275 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
276 Out = Args.MakeArgString(Out + Prefix + Val);
277 if (i != NumOptions - 1)
278 Out = Args.MakeArgString(Out +
",");
281 OutStrings.push_back(Args.MakeArgString(Out));
287 ArgStringList &CmdArgs) {
288 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
292 StringRef
Value = A->getValue();
293 if (Value ==
"none") {
294 CmdArgs.push_back(
"-mprefer-vector-width=none");
297 if (Value.getAsInteger(10, Width)) {
298 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
301 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + Value));
306 std::vector<StringRef> &Features) {
311 const ArgList &Args, ArgStringList &CmdArgs,
314 std::vector<StringRef> Features;
315 switch (Triple.getArch()) {
318 case llvm::Triple::mips:
319 case llvm::Triple::mipsel:
320 case llvm::Triple::mips64:
321 case llvm::Triple::mips64el:
325 case llvm::Triple::arm:
326 case llvm::Triple::armeb:
327 case llvm::Triple::thumb:
328 case llvm::Triple::thumbeb:
332 case llvm::Triple::ppc:
333 case llvm::Triple::ppc64:
334 case llvm::Triple::ppc64le:
337 case llvm::Triple::riscv32:
338 case llvm::Triple::riscv64:
341 case llvm::Triple::systemz:
344 case llvm::Triple::aarch64:
345 case llvm::Triple::aarch64_be:
348 case llvm::Triple::x86:
349 case llvm::Triple::x86_64:
352 case llvm::Triple::hexagon:
355 case llvm::Triple::wasm32:
356 case llvm::Triple::wasm64:
359 case llvm::Triple::sparc:
360 case llvm::Triple::sparcel:
361 case llvm::Triple::sparcv9:
364 case llvm::Triple::r600:
365 case llvm::Triple::amdgcn:
368 case llvm::Triple::msp430:
373 llvm::StringMap<unsigned> LastOpt;
374 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
375 StringRef Name = Features[I];
376 assert(Name[0] ==
'-' || Name[0] ==
'+');
377 LastOpt[Name.drop_front(1)] = I;
380 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
382 StringRef Name = Features[I];
383 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
384 assert(LastI != LastOpt.end());
385 unsigned Last = LastI->second;
389 CmdArgs.push_back(
"-target-feature");
390 CmdArgs.push_back(Name.data());
396 const llvm::Triple &Triple) {
403 if (!Triple.isMacOSX())
406 return (!Triple.isMacOSXVersionLT(10, 5) &&
407 (Triple.getArch() == llvm::Triple::x86_64 ||
408 Triple.getArch() == llvm::Triple::arm));
418 ArgStringList &CmdArgs) {
419 const llvm::Triple &Triple = TC.
getTriple();
424 Args.ClaimAllArgs(options::OPT_fexceptions);
425 Args.ClaimAllArgs(options::OPT_fno_exceptions);
426 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
427 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
428 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
429 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
434 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
440 Args.hasFlag(options::OPT_fobjc_exceptions,
441 options::OPT_fno_objc_exceptions,
true)) {
442 CmdArgs.push_back(
"-fobjc-exceptions");
449 bool CXXExceptionsEnabled =
450 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
451 Arg *ExceptionArg = Args.getLastArg(
452 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
453 options::OPT_fexceptions, options::OPT_fno_exceptions);
455 CXXExceptionsEnabled =
456 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
457 ExceptionArg->getOption().matches(options::OPT_fexceptions);
459 if (CXXExceptionsEnabled) {
460 CmdArgs.push_back(
"-fcxx-exceptions");
467 CmdArgs.push_back(
"-fexceptions");
477 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
483 bool UseDwarfDirectory =
484 Args.hasFlag(options::OPT_fdwarf_directory_asm,
486 return !UseDwarfDirectory;
492 assert(A.getOption().matches(options::OPT_gN_Group) &&
493 "Not a -g option that specifies a debug-info level");
494 if (A.getOption().matches(options::OPT_g0) ||
495 A.getOption().matches(options::OPT_ggdb0))
497 if (A.getOption().matches(options::OPT_gline_tables_only) ||
498 A.getOption().matches(options::OPT_ggdb1))
500 if (A.getOption().matches(options::OPT_gline_directives_only))
506 switch (Triple.getArch()){
509 case llvm::Triple::arm:
510 case llvm::Triple::thumb:
513 return Triple.isOSDarwin();
518 const llvm::Triple &Triple) {
519 switch (Triple.getArch()) {
520 case llvm::Triple::xcore:
521 case llvm::Triple::wasm32:
522 case llvm::Triple::wasm64:
526 case llvm::Triple::riscv32:
527 case llvm::Triple::riscv64:
533 if (Triple.isOSNetBSD()) {
537 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI ||
539 switch (Triple.getArch()) {
541 case llvm::Triple::mips64:
542 case llvm::Triple::mips64el:
543 case llvm::Triple::mips:
544 case llvm::Triple::mipsel:
545 case llvm::Triple::ppc:
546 case llvm::Triple::ppc64:
547 case llvm::Triple::ppc64le:
548 case llvm::Triple::systemz:
549 case llvm::Triple::x86:
550 case llvm::Triple::x86_64:
557 if (Triple.isOSWindows()) {
558 switch (Triple.getArch()) {
559 case llvm::Triple::x86:
561 case llvm::Triple::x86_64:
562 return Triple.isOSBinFormatMachO();
563 case llvm::Triple::arm:
564 case llvm::Triple::thumb:
578 const llvm::Triple &Triple) {
579 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
580 options::OPT_fomit_frame_pointer))
581 return A->getOption().matches(options::OPT_fno_omit_frame_pointer) ||
584 if (Args.hasArg(options::OPT_pg))
591 const llvm::Triple &Triple) {
592 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
593 options::OPT_momit_leaf_frame_pointer))
594 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
596 if (Args.hasArg(options::OPT_pg))
599 if (Triple.isPS4CPU())
608 if (!llvm::sys::fs::current_path(cwd)) {
609 CmdArgs.push_back(
"-fdebug-compilation-dir");
610 CmdArgs.push_back(Args.MakeArgString(cwd));
616 for (
const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
617 StringRef Map = A->getValue();
618 if (Map.find(
'=') == StringRef::npos)
619 D.
Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map;
621 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
629 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
630 if (A->getOption().matches(options::OPT_O4) ||
631 A->getOption().matches(options::OPT_Ofast))
634 if (A->getOption().matches(options::OPT_O0))
637 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
640 StringRef S(A->getValue());
648 unsigned OptLevel = 0;
649 if (S.getAsInteger(10, OptLevel))
660 ArgStringList &CmdArgs) {
663 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
666 CmdArgs.push_back(
"-x");
667 if (Args.hasArg(options::OPT_rewrite_objc))
673 const char *ClangType;
675 case types::TY_CXXModule:
678 case types::TY_PP_CXXModule:
679 ClangType =
"c++-cpp-output";
685 CmdArgs.push_back(ClangType);
691 const char *Username = getenv(
"LOGNAME");
693 const char *Username = getenv(
"USERNAME");
698 for (
const char *
P = Username; *
P; ++
P, ++Len) {
705 if (Username && Len > 0) {
706 Result.append(Username, Username + Len);
713 std::string UID = llvm::utostr(getuid());
716 std::string UID =
"9999";
718 Result.append(UID.begin(), UID.end());
722 const InputInfo &Output,
const ArgList &Args,
723 ArgStringList &CmdArgs) {
725 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
726 options::OPT_fprofile_generate_EQ,
727 options::OPT_fno_profile_generate);
728 if (PGOGenerateArg &&
729 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
730 PGOGenerateArg =
nullptr;
732 auto *ProfileGenerateArg = Args.getLastArg(
733 options::OPT_fprofile_instr_generate,
734 options::OPT_fprofile_instr_generate_EQ,
735 options::OPT_fno_profile_instr_generate);
736 if (ProfileGenerateArg &&
737 ProfileGenerateArg->getOption().matches(
738 options::OPT_fno_profile_instr_generate))
739 ProfileGenerateArg =
nullptr;
741 if (PGOGenerateArg && ProfileGenerateArg)
742 D.
Diag(diag::err_drv_argument_not_allowed_with)
743 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
747 if (PGOGenerateArg && ProfileUseArg)
748 D.
Diag(diag::err_drv_argument_not_allowed_with)
749 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
751 if (ProfileGenerateArg && ProfileUseArg)
752 D.
Diag(diag::err_drv_argument_not_allowed_with)
753 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
755 if (ProfileGenerateArg) {
756 if (ProfileGenerateArg->getOption().matches(
757 options::OPT_fprofile_instr_generate_EQ))
758 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
759 ProfileGenerateArg->getValue()));
761 CmdArgs.push_back(
"-fprofile-instrument=clang");
764 if (PGOGenerateArg) {
765 CmdArgs.push_back(
"-fprofile-instrument=llvm");
766 if (PGOGenerateArg->getOption().matches(
767 options::OPT_fprofile_generate_EQ)) {
769 llvm::sys::path::append(Path,
"default_%m.profraw");
771 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
776 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
777 CmdArgs.push_back(Args.MakeArgString(
778 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
779 else if ((ProfileUseArg->getOption().matches(
780 options::OPT_fprofile_use_EQ) ||
781 ProfileUseArg->getOption().matches(
782 options::OPT_fprofile_instr_use))) {
784 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
785 if (Path.empty() || llvm::sys::fs::is_directory(Path))
786 llvm::sys::path::append(Path,
"default.profdata");
788 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
792 if (Args.hasArg(options::OPT_ftest_coverage) ||
793 Args.hasArg(options::OPT_coverage))
794 CmdArgs.push_back(
"-femit-coverage-notes");
795 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
797 Args.hasArg(options::OPT_coverage))
798 CmdArgs.push_back(
"-femit-coverage-data");
800 if (Args.hasFlag(options::OPT_fcoverage_mapping,
801 options::OPT_fno_coverage_mapping,
false)) {
802 if (!ProfileGenerateArg)
803 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
804 <<
"-fcoverage-mapping" 805 <<
"-fprofile-instr-generate";
807 CmdArgs.push_back(
"-fcoverage-mapping");
810 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
811 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
812 if (!Args.hasArg(options::OPT_coverage))
813 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
814 <<
"-fprofile-exclude-files=" 817 StringRef
v = Arg->getValue();
819 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" + v)));
822 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
823 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
824 if (!Args.hasArg(options::OPT_coverage))
825 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
826 <<
"-fprofile-filter-files=" 829 StringRef
v = Arg->getValue();
830 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" + v)));
833 if (C.
getArgs().hasArg(options::OPT_c) ||
834 C.
getArgs().hasArg(options::OPT_S)) {
836 CmdArgs.push_back(
"-coverage-notes-file");
838 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
839 OutputFilename = FinalOutput->getValue();
841 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
843 if (llvm::sys::path::is_relative(CoverageFilename)) {
845 if (!llvm::sys::fs::current_path(Pwd)) {
846 llvm::sys::path::append(Pwd, CoverageFilename);
847 CoverageFilename.swap(Pwd);
850 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
851 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
857 if (Args.hasArg(options::OPT_fprofile_arcs) ||
858 Args.hasArg(options::OPT_coverage)) {
859 CmdArgs.push_back(
"-coverage-data-file");
860 if (Arg *FProfileDir = Args.getLastArg(options::OPT_fprofile_dir)) {
861 CoverageFilename = FProfileDir->getValue();
862 llvm::sys::path::append(CoverageFilename, OutputFilename);
864 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
865 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
873 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
876 for (
const auto &AI : A->
inputs())
886 bool RelaxDefault =
true;
888 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
889 RelaxDefault = A->getOption().matches(options::OPT_O0);
892 RelaxDefault =
false;
901 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
909 return llvm::StringSwitch<unsigned>(ArgValue)
910 .Case(
"-gdwarf-2", 2)
911 .Case(
"-gdwarf-3", 3)
912 .Case(
"-gdwarf-4", 4)
913 .Case(
"-gdwarf-5", 5)
919 unsigned DwarfVersion,
920 llvm::DebuggerKind DebuggerTuning) {
921 switch (DebugInfoKind) {
923 CmdArgs.push_back(
"-debug-info-kind=line-directives-only");
926 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
929 CmdArgs.push_back(
"-debug-info-kind=limited");
932 CmdArgs.push_back(
"-debug-info-kind=standalone");
937 if (DwarfVersion > 0)
939 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
940 switch (DebuggerTuning) {
941 case llvm::DebuggerKind::GDB:
942 CmdArgs.push_back(
"-debugger-tuning=gdb");
944 case llvm::DebuggerKind::LLDB:
945 CmdArgs.push_back(
"-debugger-tuning=lldb");
947 case llvm::DebuggerKind::SCE:
948 CmdArgs.push_back(
"-debugger-tuning=sce");
957 assert(A &&
"Expected non-nullptr argument.");
960 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
966 ArgStringList &CmdArgs,
969 const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ);
973 if (A->getOption().getID() == options::OPT_gz) {
974 if (llvm::zlib::isAvailable())
975 CmdArgs.push_back(
"-compress-debug-sections");
977 D.
Diag(diag::warn_debug_compression_unavailable);
981 StringRef
Value = A->getValue();
982 if (Value ==
"none") {
983 CmdArgs.push_back(
"-compress-debug-sections=none");
984 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
985 if (llvm::zlib::isAvailable()) {
987 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
989 D.
Diag(diag::warn_debug_compression_unavailable);
992 D.
Diag(diag::err_drv_unsupported_option_argument)
993 << A->getOption().getName() <<
Value;
1000 case llvm::Reloc::Static:
1002 case llvm::Reloc::PIC_:
1004 case llvm::Reloc::DynamicNoPIC:
1005 return "dynamic-no-pic";
1006 case llvm::Reloc::ROPI:
1008 case llvm::Reloc::RWPI:
1010 case llvm::Reloc::ROPI_RWPI:
1013 llvm_unreachable(
"Unknown Reloc::Model kind");
1017 const Driver &D,
const ArgList &Args,
1018 ArgStringList &CmdArgs,
1022 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
1026 Args.AddLastArg(CmdArgs, options::OPT_C);
1027 Args.AddLastArg(CmdArgs, options::OPT_CC);
1030 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
1031 (A = Args.getLastArg(options::OPT_MD)) ||
1032 (A = Args.getLastArg(options::OPT_MMD))) {
1034 const char *DepFile;
1035 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1036 DepFile = MF->getValue();
1038 }
else if (Output.
getType() == types::TY_Dependencies) {
1040 }
else if (A->getOption().matches(options::OPT_M) ||
1041 A->getOption().matches(options::OPT_MM)) {
1044 DepFile = getDependencyFileName(Args, Inputs);
1047 CmdArgs.push_back(
"-dependency-file");
1048 CmdArgs.push_back(DepFile);
1051 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
1052 const char *DepTarget;
1056 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1057 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1058 DepTarget = OutputOpt->getValue();
1064 llvm::sys::path::replace_extension(P,
"o");
1065 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1068 if (!A->getOption().matches(options::OPT_MD) && !A->getOption().matches(options::OPT_MMD)) {
1069 CmdArgs.push_back(
"-w");
1071 CmdArgs.push_back(
"-MT");
1074 CmdArgs.push_back(Args.MakeArgString(Quoted));
1077 if (A->getOption().matches(options::OPT_M) ||
1078 A->getOption().matches(options::OPT_MD))
1079 CmdArgs.push_back(
"-sys-header-deps");
1080 if ((isa<PrecompileJobAction>(JA) &&
1081 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1082 Args.hasArg(options::OPT_fmodule_file_deps))
1083 CmdArgs.push_back(
"-module-file-deps");
1086 if (Args.hasArg(options::OPT_MG)) {
1087 if (!A || A->getOption().matches(options::OPT_MD) ||
1088 A->getOption().matches(options::OPT_MMD))
1089 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1090 CmdArgs.push_back(
"-MG");
1093 Args.AddLastArg(CmdArgs, options::OPT_MP);
1094 Args.AddLastArg(CmdArgs, options::OPT_MV);
1097 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1100 if (A->getOption().matches(options::OPT_MQ)) {
1101 CmdArgs.push_back(
"-MT");
1104 CmdArgs.push_back(Args.MakeArgString(Quoted));
1108 A->render(Args, CmdArgs);
1117 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1125 if (getToolChain().getDriver().IsCLMode()) {
1126 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1127 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1130 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1132 if (YcArg || YuArg) {
1133 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1134 if (!isa<PrecompileJobAction>(JA)) {
1135 CmdArgs.push_back(
"-include-pch");
1137 C, !ThroughHeader.empty()
1139 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1142 if (ThroughHeader.empty()) {
1143 CmdArgs.push_back(Args.MakeArgString(
1144 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1147 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1152 bool RenderedImplicitInclude =
false;
1153 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1154 if (A->getOption().matches(options::OPT_include)) {
1156 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1157 RenderedImplicitInclude =
true;
1159 bool FoundPCH =
false;
1164 llvm::sys::path::replace_extension(P,
"pch");
1165 if (llvm::sys::fs::exists(P))
1169 llvm::sys::path::replace_extension(P,
"gch");
1170 if (llvm::sys::fs::exists(P)) {
1176 if (IsFirstImplicitInclude) {
1178 CmdArgs.push_back(
"-include-pch");
1179 CmdArgs.push_back(Args.MakeArgString(P));
1183 D.
Diag(diag::warn_drv_pch_not_first_include) << P
1184 << A->getAsString(Args);
1187 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1198 A->render(Args, CmdArgs);
1201 Args.AddAllArgs(CmdArgs,
1202 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1203 options::OPT_F, options::OPT_index_header_map});
1211 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1212 options::OPT_Xpreprocessor);
1215 if (Arg *A = Args.getLastArg(options::OPT_I_))
1216 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1221 if (sysroot !=
"") {
1222 if (!Args.hasArg(options::OPT_isysroot)) {
1223 CmdArgs.push_back(
"-isysroot");
1224 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
1241 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1250 [&Args, &CmdArgs](
const ToolChain &TC) {
1257 [&Args, &CmdArgs](
const ToolChain &TC) {
1262 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1268 switch (Triple.getArch()) {
1272 case llvm::Triple::aarch64:
1273 case llvm::Triple::aarch64_be:
1274 case llvm::Triple::arm:
1275 case llvm::Triple::armeb:
1276 case llvm::Triple::thumb:
1277 case llvm::Triple::thumbeb:
1278 if (Triple.isOSDarwin() || Triple.isOSWindows())
1282 case llvm::Triple::ppc:
1283 case llvm::Triple::ppc64:
1284 if (Triple.isOSDarwin())
1288 case llvm::Triple::hexagon:
1289 case llvm::Triple::ppc64le:
1290 case llvm::Triple::riscv32:
1291 case llvm::Triple::riscv64:
1292 case llvm::Triple::systemz:
1293 case llvm::Triple::xcore:
1299 switch (Triple.getArch()) {
1301 if (Triple.isOSFuchsia())
1305 case llvm::Triple::xcore:
1306 case llvm::Triple::wasm32:
1307 case llvm::Triple::wasm64:
1313 void RenderARMABI(
const llvm::Triple &Triple,
const ArgList &Args,
1314 ArgStringList &CmdArgs) {
1318 const char *ABIName =
nullptr;
1319 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1320 ABIName = A->getValue();
1322 std::string CPU =
getCPUName(Args, Triple,
false);
1323 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1326 CmdArgs.push_back(
"-target-abi");
1327 CmdArgs.push_back(ABIName);
1331 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1332 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1333 RenderARMABI(Triple, Args, CmdArgs);
1340 CmdArgs.push_back(
"-msoft-float");
1341 CmdArgs.push_back(
"-mfloat-abi");
1342 CmdArgs.push_back(
"soft");
1345 CmdArgs.push_back(
"-mfloat-abi");
1346 CmdArgs.push_back(
"soft");
1350 CmdArgs.push_back(
"-mfloat-abi");
1351 CmdArgs.push_back(
"hard");
1355 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1356 options::OPT_mno_global_merge)) {
1357 CmdArgs.push_back(
"-mllvm");
1358 if (A->getOption().matches(options::OPT_mno_global_merge))
1359 CmdArgs.push_back(
"-arm-global-merge=false");
1361 CmdArgs.push_back(
"-arm-global-merge=true");
1364 if (!Args.hasFlag(options::OPT_mimplicit_float,
1365 options::OPT_mno_implicit_float,
true))
1366 CmdArgs.push_back(
"-no-implicit-float");
1369 void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1370 const ArgList &Args,
bool KernelOrKext,
1371 ArgStringList &CmdArgs)
const {
1382 case llvm::Triple::arm:
1383 case llvm::Triple::armeb:
1384 case llvm::Triple::thumb:
1385 case llvm::Triple::thumbeb:
1387 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1388 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1391 case llvm::Triple::aarch64:
1392 case llvm::Triple::aarch64_be:
1393 AddAArch64TargetArgs(Args, CmdArgs);
1394 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1397 case llvm::Triple::mips:
1398 case llvm::Triple::mipsel:
1399 case llvm::Triple::mips64:
1400 case llvm::Triple::mips64el:
1401 AddMIPSTargetArgs(Args, CmdArgs);
1404 case llvm::Triple::ppc:
1405 case llvm::Triple::ppc64:
1406 case llvm::Triple::ppc64le:
1407 AddPPCTargetArgs(Args, CmdArgs);
1410 case llvm::Triple::riscv32:
1411 case llvm::Triple::riscv64:
1412 AddRISCVTargetArgs(Args, CmdArgs);
1415 case llvm::Triple::sparc:
1416 case llvm::Triple::sparcel:
1417 case llvm::Triple::sparcv9:
1418 AddSparcTargetArgs(Args, CmdArgs);
1421 case llvm::Triple::systemz:
1422 AddSystemZTargetArgs(Args, CmdArgs);
1425 case llvm::Triple::x86:
1426 case llvm::Triple::x86_64:
1427 AddX86TargetArgs(Args, CmdArgs);
1430 case llvm::Triple::lanai:
1431 AddLanaiTargetArgs(Args, CmdArgs);
1434 case llvm::Triple::hexagon:
1435 AddHexagonTargetArgs(Args, CmdArgs);
1438 case llvm::Triple::wasm32:
1439 case llvm::Triple::wasm64:
1440 AddWebAssemblyTargetArgs(Args, CmdArgs);
1449 static std::tuple<StringRef, StringRef, bool>
1452 StringRef
Scope =
"none";
1453 StringRef Key =
"a_key";
1454 bool IndirectBranches =
false;
1456 StringRef
Value = A->getValue();
1459 if (Value.equals(
"standard")) {
1462 IndirectBranches =
true;
1464 }
else if (!Value.equals(
"none")) {
1466 StringRef(A->getValue()).split(BranchProtection,
'+');
1468 auto Protection = BranchProtection.begin();
1469 while (Protection != BranchProtection.end()) {
1470 if (Protection->equals(
"bti"))
1471 IndirectBranches =
true;
1472 else if (Protection->equals(
"pac-ret")) {
1474 while (++Protection != BranchProtection.end()) {
1477 if (Protection->equals(
"leaf"))
1479 else if (Protection->equals(
"b-key"))
1486 D.
Diag(diag::err_invalid_branch_protection)
1487 << *Protection << A->getAsString(Args);
1492 return std::make_tuple(Scope, Key, IndirectBranches);
1496 void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1497 ArgStringList &CmdArgs) {
1498 const char *ABIName =
nullptr;
1499 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1500 ABIName = A->getValue();
1501 else if (Triple.isOSDarwin())
1502 ABIName =
"darwinpcs";
1506 CmdArgs.push_back(
"-target-abi");
1507 CmdArgs.push_back(ABIName);
1511 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1512 ArgStringList &CmdArgs)
const {
1513 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1515 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1516 Args.hasArg(options::OPT_mkernel) ||
1517 Args.hasArg(options::OPT_fapple_kext))
1518 CmdArgs.push_back(
"-disable-red-zone");
1520 if (!Args.hasFlag(options::OPT_mimplicit_float,
1521 options::OPT_mno_implicit_float,
true))
1522 CmdArgs.push_back(
"-no-implicit-float");
1524 RenderAArch64ABI(Triple, Args, CmdArgs);
1526 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1527 options::OPT_mno_fix_cortex_a53_835769)) {
1528 CmdArgs.push_back(
"-mllvm");
1529 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1530 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1532 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1533 }
else if (Triple.isAndroid()) {
1535 CmdArgs.push_back(
"-mllvm");
1536 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1540 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1541 options::OPT_mno_global_merge)) {
1542 CmdArgs.push_back(
"-mllvm");
1543 if (A->getOption().matches(options::OPT_mno_global_merge))
1544 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1546 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1550 if (Arg *A = Args.getLastArg(options::OPT_msign_return_address_EQ,
1551 options::OPT_mbranch_protection_EQ)) {
1553 const Driver &D = getToolChain().getDriver();
1555 StringRef
Scope, Key;
1556 bool IndirectBranches;
1558 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1559 Scope = A->getValue();
1560 if (!Scope.equals(
"none") && !Scope.equals(
"non-leaf") &&
1561 !Scope.equals(
"all"))
1562 D.
Diag(diag::err_invalid_branch_protection)
1563 << Scope << A->getAsString(Args);
1565 IndirectBranches =
false;
1567 std::tie(Scope, Key, IndirectBranches) =
1571 Args.MakeArgString(Twine(
"-msign-return-address=") + Scope));
1573 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1574 if (IndirectBranches)
1575 CmdArgs.push_back(
"-mbranch-target-enforce");
1579 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1580 ArgStringList &CmdArgs)
const {
1581 const Driver &D = getToolChain().getDriver();
1584 const llvm::Triple &Triple = getToolChain().getTriple();
1587 CmdArgs.push_back(
"-target-abi");
1588 CmdArgs.push_back(ABIName.data());
1593 CmdArgs.push_back(
"-msoft-float");
1594 CmdArgs.push_back(
"-mfloat-abi");
1595 CmdArgs.push_back(
"soft");
1599 CmdArgs.push_back(
"-mfloat-abi");
1600 CmdArgs.push_back(
"hard");
1603 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1604 if (A->getOption().matches(options::OPT_mxgot)) {
1605 CmdArgs.push_back(
"-mllvm");
1606 CmdArgs.push_back(
"-mxgot");
1610 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1611 options::OPT_mno_ldc1_sdc1)) {
1612 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1613 CmdArgs.push_back(
"-mllvm");
1614 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1618 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1619 options::OPT_mno_check_zero_division)) {
1620 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1621 CmdArgs.push_back(
"-mllvm");
1622 CmdArgs.push_back(
"-mno-check-zero-division");
1626 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1627 StringRef
v = A->getValue();
1628 CmdArgs.push_back(
"-mllvm");
1629 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1633 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1635 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1648 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1650 llvm::Reloc::Model RelocationModel;
1653 std::tie(RelocationModel, PICLevel, IsPIE) =
1656 NoABICalls = NoABICalls ||
1657 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1659 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1661 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1662 CmdArgs.push_back(
"-mllvm");
1663 CmdArgs.push_back(
"-mgpopt");
1665 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1666 options::OPT_mno_local_sdata);
1667 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1668 options::OPT_mno_extern_sdata);
1669 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1670 options::OPT_mno_embedded_data);
1672 CmdArgs.push_back(
"-mllvm");
1673 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1674 CmdArgs.push_back(
"-mlocal-sdata=1");
1676 CmdArgs.push_back(
"-mlocal-sdata=0");
1678 LocalSData->claim();
1682 CmdArgs.push_back(
"-mllvm");
1683 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1684 CmdArgs.push_back(
"-mextern-sdata=1");
1686 CmdArgs.push_back(
"-mextern-sdata=0");
1688 ExternSData->claim();
1692 CmdArgs.push_back(
"-mllvm");
1693 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1694 CmdArgs.push_back(
"-membedded-data=1");
1696 CmdArgs.push_back(
"-membedded-data=0");
1698 EmbeddedData->claim();
1701 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1702 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1707 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1708 StringRef Val = StringRef(A->getValue());
1710 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1711 CmdArgs.push_back(
"-mllvm");
1712 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1714 D.
Diag(diag::err_drv_unsupported_option_argument)
1715 << A->getOption().getName() << Val;
1717 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1721 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1722 ArgStringList &CmdArgs)
const {
1724 const char *ABIName =
nullptr;
1725 if (getToolChain().getTriple().isOSLinux())
1726 switch (getToolChain().getArch()) {
1727 case llvm::Triple::ppc64: {
1731 bool HasQPX =
false;
1732 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1733 HasQPX = A->getValue() == StringRef(
"a2q");
1734 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1736 ABIName =
"elfv1-qpx";
1743 case llvm::Triple::ppc64le:
1750 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1754 if (StringRef(A->getValue()) !=
"altivec")
1755 ABIName = A->getValue();
1762 CmdArgs.push_back(
"-msoft-float");
1763 CmdArgs.push_back(
"-mfloat-abi");
1764 CmdArgs.push_back(
"soft");
1768 CmdArgs.push_back(
"-mfloat-abi");
1769 CmdArgs.push_back(
"hard");
1773 CmdArgs.push_back(
"-target-abi");
1774 CmdArgs.push_back(ABIName);
1778 void Clang::AddRISCVTargetArgs(
const ArgList &Args,
1779 ArgStringList &CmdArgs)
const {
1782 const char *ABIName =
nullptr;
1783 const llvm::Triple &Triple = getToolChain().getTriple();
1784 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1785 ABIName = A->getValue();
1786 else if (Triple.getArch() == llvm::Triple::riscv32)
1788 else if (Triple.getArch() == llvm::Triple::riscv64)
1791 llvm_unreachable(
"Unexpected triple!");
1793 CmdArgs.push_back(
"-target-abi");
1794 CmdArgs.push_back(ABIName);
1797 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1798 ArgStringList &CmdArgs)
const {
1804 CmdArgs.push_back(
"-msoft-float");
1805 CmdArgs.push_back(
"-mfloat-abi");
1806 CmdArgs.push_back(
"soft");
1810 CmdArgs.push_back(
"-mfloat-abi");
1811 CmdArgs.push_back(
"hard");
1815 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
1816 ArgStringList &CmdArgs)
const {
1817 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false))
1818 CmdArgs.push_back(
"-mbackchain");
1821 void Clang::AddX86TargetArgs(
const ArgList &Args,
1822 ArgStringList &CmdArgs)
const {
1823 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1824 Args.hasArg(options::OPT_mkernel) ||
1825 Args.hasArg(options::OPT_fapple_kext))
1826 CmdArgs.push_back(
"-disable-red-zone");
1828 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
1829 options::OPT_mno_tls_direct_seg_refs,
true))
1830 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
1834 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1835 Args.hasArg(options::OPT_fapple_kext));
1836 if (Arg *A = Args.getLastArg(
1837 options::OPT_msoft_float, options::OPT_mno_soft_float,
1838 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
1839 const Option &O = A->getOption();
1840 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1841 O.matches(options::OPT_msoft_float));
1843 if (NoImplicitFloat)
1844 CmdArgs.push_back(
"-no-implicit-float");
1846 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1847 StringRef
Value = A->getValue();
1848 if (Value ==
"intel" || Value ==
"att") {
1849 CmdArgs.push_back(
"-mllvm");
1850 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
1852 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1853 << A->getOption().getName() <<
Value;
1855 }
else if (getToolChain().getDriver().IsCLMode()) {
1856 CmdArgs.push_back(
"-mllvm");
1857 CmdArgs.push_back(
"-x86-asm-syntax=intel");
1861 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
1862 CmdArgs.push_back(
"-mfloat-abi");
1863 CmdArgs.push_back(
"soft");
1864 CmdArgs.push_back(
"-mstack-alignment=4");
1868 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
1869 ArgStringList &CmdArgs)
const {
1870 CmdArgs.push_back(
"-mqdsp6-compat");
1871 CmdArgs.push_back(
"-Wreturn-type");
1874 CmdArgs.push_back(
"-mllvm");
1875 CmdArgs.push_back(Args.MakeArgString(
"-hexagon-small-data-threshold=" +
1876 Twine(G.getValue())));
1879 if (!Args.hasArg(options::OPT_fno_short_enums))
1880 CmdArgs.push_back(
"-fshort-enums");
1881 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1882 CmdArgs.push_back(
"-mllvm");
1883 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
1885 CmdArgs.push_back(
"-mllvm");
1886 CmdArgs.push_back(
"-machine-sink-split=0");
1889 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
1890 ArgStringList &CmdArgs)
const {
1891 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1892 StringRef CPUName = A->getValue();
1894 CmdArgs.push_back(
"-target-cpu");
1895 CmdArgs.push_back(Args.MakeArgString(CPUName));
1897 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1898 StringRef
Value = A->getValue();
1902 if (Value.getAsInteger(10, Mregparm)) {
1903 if (Mregparm != 4) {
1904 getToolChain().getDriver().Diag(
1905 diag::err_drv_unsupported_option_argument)
1906 << A->getOption().getName() <<
Value;
1912 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
1913 ArgStringList &CmdArgs)
const {
1915 if (!Args.hasArg(options::OPT_fvisibility_EQ,
1916 options::OPT_fvisibility_ms_compat)) {
1917 CmdArgs.push_back(
"-fvisibility");
1918 CmdArgs.push_back(
"hidden");
1924 const InputInfo &Input,
const ArgList &Args)
const {
1926 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH))
1929 using llvm::yaml::escape;
1930 const Driver &D = getToolChain().getDriver();
1932 if (!CompilationDatabase) {
1934 auto File = llvm::make_unique<llvm::raw_fd_ostream>(
Filename, EC, llvm::sys::fs::F_Text);
1936 D.
Diag(clang::diag::err_drv_compilationdatabase) << Filename
1940 CompilationDatabase = std::move(File);
1942 auto &CDB = *CompilationDatabase;
1944 if (llvm::sys::fs::current_path(Buf))
1946 CDB <<
"{ \"directory\": \"" << escape(Buf) <<
"\"";
1947 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
1948 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
1952 CDB <<
", \"" << escape(Buf) <<
"\"";
1953 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
1956 CDB <<
", \"" << escape(Buf) <<
"\"";
1958 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
1959 for (
auto &A: Args) {
1960 auto &O = A->getOption();
1962 if (O.getID() == options::OPT_x)
1965 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
1968 if (O.getKind() == Option::InputClass)
1972 A->render(Args, ASL);
1974 CDB <<
", \"" << escape(it) <<
"\"";
1978 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
1982 const ArgList &Args,
1983 ArgStringList &CmdArgs,
1986 CmdArgs.push_back(
"-mrelax-all");
1990 bool DefaultIncrementalLinkerCompatible =
1992 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
1993 options::OPT_mno_incremental_linker_compatible,
1994 DefaultIncrementalLinkerCompatible))
1995 CmdArgs.push_back(
"-mincremental-linker-compatible");
1998 case llvm::Triple::arm:
1999 case llvm::Triple::armeb:
2000 case llvm::Triple::thumb:
2001 case llvm::Triple::thumbeb:
2002 if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) {
2003 StringRef
Value = A->getValue();
2004 if (Value ==
"always" || Value ==
"never" || Value ==
"arm" ||
2006 CmdArgs.push_back(
"-mllvm");
2007 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" + Value));
2009 D.
Diag(diag::err_drv_unsupported_option_argument)
2010 << A->getOption().getName() <<
Value;
2023 bool TakeNextArg =
false;
2026 const char *MipsTargetFeature =
nullptr;
2028 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2031 for (StringRef
Value : A->getValues()) {
2033 CmdArgs.push_back(
Value.data());
2034 TakeNextArg =
false;
2039 Value ==
"-mbig-obj")
2045 case llvm::Triple::thumb:
2046 case llvm::Triple::thumbeb:
2047 case llvm::Triple::arm:
2048 case llvm::Triple::armeb:
2049 if (
Value ==
"-mthumb")
2054 case llvm::Triple::mips:
2055 case llvm::Triple::mipsel:
2056 case llvm::Triple::mips64:
2057 case llvm::Triple::mips64el:
2058 if (
Value ==
"--trap") {
2059 CmdArgs.push_back(
"-target-feature");
2060 CmdArgs.push_back(
"+use-tcc-in-div");
2063 if (
Value ==
"--break") {
2064 CmdArgs.push_back(
"-target-feature");
2065 CmdArgs.push_back(
"-use-tcc-in-div");
2068 if (
Value.startswith(
"-msoft-float")) {
2069 CmdArgs.push_back(
"-target-feature");
2070 CmdArgs.push_back(
"+soft-float");
2073 if (
Value.startswith(
"-mhard-float")) {
2074 CmdArgs.push_back(
"-target-feature");
2075 CmdArgs.push_back(
"-soft-float");
2079 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2080 .Case(
"-mips1",
"+mips1")
2081 .Case(
"-mips2",
"+mips2")
2082 .Case(
"-mips3",
"+mips3")
2083 .Case(
"-mips4",
"+mips4")
2084 .Case(
"-mips5",
"+mips5")
2085 .Case(
"-mips32",
"+mips32")
2086 .Case(
"-mips32r2",
"+mips32r2")
2087 .Case(
"-mips32r3",
"+mips32r3")
2088 .Case(
"-mips32r5",
"+mips32r5")
2089 .Case(
"-mips32r6",
"+mips32r6")
2090 .Case(
"-mips64",
"+mips64")
2091 .Case(
"-mips64r2",
"+mips64r2")
2092 .Case(
"-mips64r3",
"+mips64r3")
2093 .Case(
"-mips64r5",
"+mips64r5")
2094 .Case(
"-mips64r6",
"+mips64r6")
2096 if (MipsTargetFeature)
2100 if (
Value ==
"-force_cpusubtype_ALL") {
2102 }
else if (
Value ==
"-L") {
2103 CmdArgs.push_back(
"-msave-temp-labels");
2104 }
else if (
Value ==
"--fatal-warnings") {
2105 CmdArgs.push_back(
"-massembler-fatal-warnings");
2106 }
else if (
Value ==
"--noexecstack") {
2107 CmdArgs.push_back(
"-mnoexecstack");
2108 }
else if (
Value.startswith(
"-compress-debug-sections") ||
2109 Value.startswith(
"--compress-debug-sections") ||
2110 Value ==
"-nocompress-debug-sections" ||
2111 Value ==
"--nocompress-debug-sections") {
2112 CmdArgs.push_back(
Value.data());
2113 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2114 Value ==
"--mrelax-relocations=yes") {
2115 UseRelaxRelocations =
true;
2116 }
else if (
Value ==
"-mrelax-relocations=no" ||
2117 Value ==
"--mrelax-relocations=no") {
2118 UseRelaxRelocations =
false;
2119 }
else if (
Value.startswith(
"-I")) {
2120 CmdArgs.push_back(
Value.data());
2125 }
else if (
Value.startswith(
"-gdwarf-")) {
2128 if (DwarfVersion == 0) {
2129 CmdArgs.push_back(
Value.data());
2133 DwarfVersion, llvm::DebuggerKind::Default);
2135 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2136 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2138 }
else if (
Value ==
"-defsym") {
2139 if (A->getNumValues() != 2) {
2140 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2143 const char *S = A->getValue(1);
2144 auto Pair = StringRef(S).split(
'=');
2145 auto Sym = Pair.first;
2146 auto SVal = Pair.second;
2148 if (Sym.empty() || SVal.empty()) {
2149 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2153 if (SVal.getAsInteger(0, IVal)) {
2154 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2157 CmdArgs.push_back(
Value.data());
2159 }
else if (
Value ==
"-fdebug-compilation-dir") {
2160 CmdArgs.push_back(
"-fdebug-compilation-dir");
2163 D.
Diag(diag::err_drv_unsupported_option_argument)
2164 << A->getOption().getName() <<
Value;
2168 if (UseRelaxRelocations)
2169 CmdArgs.push_back(
"--mrelax-relocations");
2170 if (MipsTargetFeature !=
nullptr) {
2171 CmdArgs.push_back(
"-target-feature");
2172 CmdArgs.push_back(MipsTargetFeature);
2178 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2182 bool OFastEnabled,
const ArgList &Args,
2183 ArgStringList &CmdArgs) {
2189 bool HonorINFs =
true;
2190 bool HonorNaNs =
true;
2193 bool AssociativeMath =
false;
2194 bool ReciprocalMath =
false;
2195 bool SignedZeros =
true;
2196 bool TrappingMath =
true;
2197 StringRef DenormalFPMath =
"";
2198 StringRef FPContract =
"";
2200 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2201 CmdArgs.push_back(
"-mlimit-float-precision");
2202 CmdArgs.push_back(A->getValue());
2205 for (
const Arg *A : Args) {
2206 switch (A->getOption().getID()) {
2211 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2212 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2213 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2214 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2215 case options::OPT_fmath_errno: MathErrno =
true;
break;
2216 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2217 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2218 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2219 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2220 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2221 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2222 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2223 case options::OPT_ftrapping_math: TrappingMath =
true;
break;
2224 case options::OPT_fno_trapping_math: TrappingMath =
false;
break;
2226 case options::OPT_fdenormal_fp_math_EQ:
2227 DenormalFPMath = A->getValue();
2231 case options::OPT_ffp_contract: {
2232 StringRef Val = A->getValue();
2233 if (Val ==
"fast" || Val ==
"on" || Val ==
"off")
2236 D.
Diag(diag::err_drv_unsupported_option_argument)
2237 << A->getOption().getName() << Val;
2241 case options::OPT_ffinite_math_only:
2245 case options::OPT_fno_finite_math_only:
2250 case options::OPT_funsafe_math_optimizations:
2251 AssociativeMath =
true;
2252 ReciprocalMath =
true;
2253 SignedZeros =
false;
2254 TrappingMath =
false;
2256 case options::OPT_fno_unsafe_math_optimizations:
2257 AssociativeMath =
false;
2258 ReciprocalMath =
false;
2260 TrappingMath =
true;
2262 DenormalFPMath =
"";
2265 case options::OPT_Ofast:
2270 case options::OPT_ffast_math:
2274 AssociativeMath =
true;
2275 ReciprocalMath =
true;
2276 SignedZeros =
false;
2277 TrappingMath =
false;
2279 FPContract =
"fast";
2281 case options::OPT_fno_fast_math:
2288 AssociativeMath =
false;
2289 ReciprocalMath =
false;
2291 TrappingMath =
true;
2293 DenormalFPMath =
"";
2303 CmdArgs.push_back(
"-menable-no-infs");
2306 CmdArgs.push_back(
"-menable-no-nans");
2309 CmdArgs.push_back(
"-fmath-errno");
2311 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2313 CmdArgs.push_back(
"-menable-unsafe-fp-math");
2316 CmdArgs.push_back(
"-fno-signed-zeros");
2318 if (AssociativeMath && !SignedZeros && !TrappingMath)
2319 CmdArgs.push_back(
"-mreassociate");
2322 CmdArgs.push_back(
"-freciprocal-math");
2325 CmdArgs.push_back(
"-fno-trapping-math");
2327 if (!DenormalFPMath.empty())
2329 Args.MakeArgString(
"-fdenormal-fp-math=" + DenormalFPMath));
2331 if (!FPContract.empty())
2332 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
2339 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
2340 ReciprocalMath && !SignedZeros && !TrappingMath)
2341 CmdArgs.push_back(
"-ffast-math");
2344 if (!HonorINFs && !HonorNaNs)
2345 CmdArgs.push_back(
"-ffinite-math-only");
2347 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2348 CmdArgs.push_back(
"-mfpmath");
2349 CmdArgs.push_back(A->getValue());
2353 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
2354 options::OPT_fstrict_float_cast_overflow,
false))
2355 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
2359 const llvm::Triple &Triple,
2362 CmdArgs.push_back(
"-analyzer-store=region");
2365 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
2368 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2369 CmdArgs.push_back(
"-analyzer-checker=core");
2370 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
2372 if (!Triple.isWindowsMSVCEnvironment()) {
2373 CmdArgs.push_back(
"-analyzer-checker=unix");
2376 CmdArgs.push_back(
"-analyzer-checker=unix.API");
2377 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
2378 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
2379 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
2380 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
2381 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
2385 if (Triple.isPS4CPU()) {
2386 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
2387 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
2390 if (Triple.isOSDarwin())
2391 CmdArgs.push_back(
"-analyzer-checker=osx");
2393 CmdArgs.push_back(
"-analyzer-checker=deadcode");
2396 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
2398 if (!Triple.isPS4CPU()) {
2399 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
2400 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
2401 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
2402 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
2403 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
2404 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
2408 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
2409 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
2413 CmdArgs.push_back(
"-analyzer-output");
2414 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2415 CmdArgs.push_back(A->getValue());
2417 CmdArgs.push_back(
"plist");
2422 CmdArgs.push_back(
"-w");
2425 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2429 ArgStringList &CmdArgs,
bool KernelOrKext) {
2434 if (EffectiveTriple.isNVPTX())
2438 unsigned StackProtectorLevel = 0;
2439 unsigned DefaultStackProtectorLevel =
2442 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2443 options::OPT_fstack_protector_all,
2444 options::OPT_fstack_protector_strong,
2445 options::OPT_fstack_protector)) {
2446 if (A->getOption().matches(options::OPT_fstack_protector))
2447 StackProtectorLevel =
2449 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
2451 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2454 StackProtectorLevel = DefaultStackProtectorLevel;
2457 if (StackProtectorLevel) {
2458 CmdArgs.push_back(
"-stack-protector");
2459 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2463 for (
const Arg *A : Args.filtered(options::OPT__param)) {
2464 StringRef Str(A->getValue());
2465 if (Str.startswith(
"ssp-buffer-size=")) {
2466 if (StackProtectorLevel) {
2467 CmdArgs.push_back(
"-stack-protector-buffer-size");
2469 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
2478 const ArgList &Args,
2479 ArgStringList &CmdArgs) {
2481 StringRef TrivialAutoVarInit =
"";
2483 for (
const Arg *A : Args) {
2484 switch (A->getOption().getID()) {
2487 case options::OPT_ftrivial_auto_var_init: {
2489 StringRef Val = A->getValue();
2490 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
2491 TrivialAutoVarInit = Val;
2493 D.
Diag(diag::err_drv_unsupported_option_argument)
2494 << A->getOption().getName() << Val;
2500 if (TrivialAutoVarInit.empty())
2501 switch (DefaultTrivialAutoVarInit) {
2505 TrivialAutoVarInit =
"pattern";
2508 TrivialAutoVarInit =
"zero";
2512 if (!TrivialAutoVarInit.empty()) {
2513 if (TrivialAutoVarInit ==
"zero" && !Args.hasArg(options::OPT_enable_trivial_var_init_zero))
2514 D.
Diag(diag::err_drv_trivial_auto_var_init_zero_disabled);
2516 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
2521 const unsigned ForwardedArguments[] = {
2522 options::OPT_cl_opt_disable,
2523 options::OPT_cl_strict_aliasing,
2524 options::OPT_cl_single_precision_constant,
2525 options::OPT_cl_finite_math_only,
2526 options::OPT_cl_kernel_arg_info,
2527 options::OPT_cl_unsafe_math_optimizations,
2528 options::OPT_cl_fast_relaxed_math,
2529 options::OPT_cl_mad_enable,
2530 options::OPT_cl_no_signed_zeros,
2531 options::OPT_cl_denorms_are_zero,
2532 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
2533 options::OPT_cl_uniform_work_group_size
2536 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
2537 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
2538 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
2541 for (
const auto &Arg : ForwardedArguments)
2542 if (
const auto *A = Args.getLastArg(Arg))
2543 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
2547 ArgStringList &CmdArgs) {
2548 bool ARCMTEnabled =
false;
2549 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2550 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2551 options::OPT_ccc_arcmt_modify,
2552 options::OPT_ccc_arcmt_migrate)) {
2553 ARCMTEnabled =
true;
2554 switch (A->getOption().getID()) {
2555 default: llvm_unreachable(
"missed a case");
2556 case options::OPT_ccc_arcmt_check:
2557 CmdArgs.push_back(
"-arcmt-check");
2559 case options::OPT_ccc_arcmt_modify:
2560 CmdArgs.push_back(
"-arcmt-modify");
2562 case options::OPT_ccc_arcmt_migrate:
2563 CmdArgs.push_back(
"-arcmt-migrate");
2564 CmdArgs.push_back(
"-mt-migrate-directory");
2565 CmdArgs.push_back(A->getValue());
2567 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2568 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2573 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2574 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2575 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2578 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2580 D.
Diag(diag::err_drv_argument_not_allowed_with)
2581 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
2583 CmdArgs.push_back(
"-mt-migrate-directory");
2584 CmdArgs.push_back(A->getValue());
2586 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2587 options::OPT_objcmt_migrate_subscripting,
2588 options::OPT_objcmt_migrate_property)) {
2590 CmdArgs.push_back(
"-objcmt-migrate-literals");
2591 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
2592 CmdArgs.push_back(
"-objcmt-migrate-property");
2594 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2595 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2596 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2599 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2600 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2601 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2602 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2603 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2604 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2605 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
2606 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2607 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2608 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2609 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2610 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2611 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2612 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2613 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
2614 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
2619 const ArgList &Args, ArgStringList &CmdArgs) {
2622 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
2623 !Args.hasArg(options::OPT_mkernel));
2625 CmdArgs.push_back(
"-fno-builtin");
2628 if (Args.hasArg(options::OPT_ffreestanding))
2629 UseBuiltins =
false;
2632 for (
const auto &Arg : Args) {
2633 const Option &O = Arg->getOption();
2634 if (!O.matches(options::OPT_fno_builtin_))
2644 StringRef FuncName = Arg->getValue();
2645 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
2651 if (TC.
getArch() == llvm::Triple::le32)
2652 CmdArgs.push_back(
"-fno-math-builtin");
2656 llvm::sys::path::system_temp_directory(
false, Result);
2657 llvm::sys::path::append(Result,
"org.llvm.clang.");
2659 llvm::sys::path::append(Result,
"ModuleCache");
2663 const ArgList &Args,
const InputInfo &Input,
2665 ArgStringList &CmdArgs,
bool &HaveModules) {
2669 bool HaveClangModules =
false;
2670 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
2671 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2672 options::OPT_fno_cxx_modules,
true);
2674 CmdArgs.push_back(
"-fmodules");
2675 HaveClangModules =
true;
2679 HaveModules = HaveClangModules;
2680 if (Args.hasArg(options::OPT_fmodules_ts)) {
2681 CmdArgs.push_back(
"-fmodules-ts");
2687 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
2688 options::OPT_fno_implicit_module_maps, HaveClangModules))
2689 CmdArgs.push_back(
"-fimplicit-module-maps");
2692 if (Args.hasFlag(options::OPT_fmodules_decluse,
2693 options::OPT_fno_modules_decluse,
false))
2694 CmdArgs.push_back(
"-fmodules-decluse");
2698 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
2699 options::OPT_fno_modules_strict_decluse,
false))
2700 CmdArgs.push_back(
"-fmodules-strict-decluse");
2703 bool ImplicitModules =
false;
2704 if (!Args.hasFlag(options::OPT_fimplicit_modules,
2705 options::OPT_fno_implicit_modules, HaveClangModules)) {
2707 CmdArgs.push_back(
"-fno-implicit-modules");
2708 }
else if (HaveModules) {
2709 ImplicitModules =
true;
2713 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
2714 Path = A->getValue();
2720 llvm::sys::path::replace_extension(Path,
".cache");
2721 llvm::sys::path::append(Path,
"modules");
2722 }
else if (Path.empty()) {
2727 const char Arg[] =
"-fmodules-cache-path=";
2728 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
2729 CmdArgs.push_back(Args.MakeArgString(Path));
2734 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
2735 CmdArgs.push_back(Args.MakeArgString(
2736 std::string(
"-fprebuilt-module-path=") + A->getValue()));
2743 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
2747 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
2751 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
2753 llvm::sys::path::append(BuiltinModuleMap,
"include");
2754 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
2755 if (llvm::sys::fs::exists(BuiltinModuleMap))
2757 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
2765 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
2767 Args.ClaimAllArgs(options::OPT_fmodule_file);
2773 llvm::sys::path::replace_extension(VFSDir,
".cache");
2777 llvm::sys::path::append(VFSDir,
"vfs");
2778 CmdArgs.push_back(
"-module-dependency-dir");
2779 CmdArgs.push_back(Args.MakeArgString(VFSDir));
2782 if (HaveClangModules)
2783 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
2786 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
2787 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
2788 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
2790 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
2792 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
2793 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
2794 D.
Diag(diag::err_drv_argument_not_allowed_with)
2795 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
2797 llvm::sys::fs::file_status Status;
2798 if (llvm::sys::fs::status(A->getValue(), Status))
2799 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
2801 Args.MakeArgString(
"-fbuild-session-timestamp=" +
2802 Twine((uint64_t)Status.getLastModificationTime()
2807 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
2808 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
2809 options::OPT_fbuild_session_file))
2810 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
2812 Args.AddLastArg(CmdArgs,
2813 options::OPT_fmodules_validate_once_per_build_session);
2816 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
2817 options::OPT_fno_modules_validate_system_headers,
2819 CmdArgs.push_back(
"-fmodules-validate-system-headers");
2821 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
2825 ArgStringList &CmdArgs) {
2827 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
2828 options::OPT_fno_signed_char,
2829 options::OPT_funsigned_char,
2830 options::OPT_fno_unsigned_char)) {
2831 if (A->getOption().matches(options::OPT_funsigned_char) ||
2832 A->getOption().matches(options::OPT_fno_signed_char)) {
2833 CmdArgs.push_back(
"-fno-signed-char");
2836 CmdArgs.push_back(
"-fno-signed-char");
2841 Args.getLastArg(options::OPT_fchar8__t, options::OPT_fno_char8__t))
2842 A->render(Args, CmdArgs);
2844 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
2845 options::OPT_fno_short_wchar)) {
2846 if (A->getOption().matches(options::OPT_fshort_wchar)) {
2847 CmdArgs.push_back(
"-fwchar-type=short");
2848 CmdArgs.push_back(
"-fno-signed-wchar");
2850 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
2851 CmdArgs.push_back(
"-fwchar-type=int");
2852 if (IsARM && !(T.isOSWindows() || T.isOSNetBSD() ||
2854 CmdArgs.push_back(
"-fno-signed-wchar");
2856 CmdArgs.push_back(
"-fsigned-wchar");
2862 const llvm::Triple &T,
const ArgList &Args,
2864 const InputInfo &Input, ArgStringList &CmdArgs) {
2865 const llvm::Triple::ArchType Arch = TC.
getArch();
2871 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2872 options::OPT_fno_objc_legacy_dispatch,
2875 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
2877 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
2883 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
2885 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
2892 CmdArgs.push_back(
"-fobjc-arc");
2899 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
2901 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
2906 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2907 options::OPT_fno_objc_arc_exceptions,
2909 CmdArgs.push_back(
"-fobjc-arc-exceptions");
2914 if (Args.hasArg(options::OPT_fno_objc_arc)) {
2915 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
2916 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
2922 auto *Arg = Args.getLastArg(
2923 options::OPT_fobjc_convert_messages_to_runtime_calls,
2924 options::OPT_fno_objc_convert_messages_to_runtime_calls);
2926 Arg->getOption().matches(
2927 options::OPT_fno_objc_convert_messages_to_runtime_calls))
2928 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
2933 if (InferCovariantReturns)
2934 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
2939 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
2943 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
2944 D.
Diag(diag::err_objc_weak_unsupported);
2946 WeakArg->render(Args, CmdArgs);
2952 ArgStringList &CmdArgs) {
2953 bool CaretDefault =
true;
2954 bool ColumnDefault =
true;
2956 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
2957 options::OPT__SLASH_diagnostics_column,
2958 options::OPT__SLASH_diagnostics_caret)) {
2959 switch (A->getOption().getID()) {
2960 case options::OPT__SLASH_diagnostics_caret:
2961 CaretDefault =
true;
2962 ColumnDefault =
true;
2964 case options::OPT__SLASH_diagnostics_column:
2965 CaretDefault =
false;
2966 ColumnDefault =
true;
2968 case options::OPT__SLASH_diagnostics_classic:
2969 CaretDefault =
false;
2970 ColumnDefault =
false;
2976 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2977 options::OPT_fno_caret_diagnostics, CaretDefault))
2978 CmdArgs.push_back(
"-fno-caret-diagnostics");
2981 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
2982 options::OPT_fno_diagnostics_fixit_info))
2983 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
2986 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
2987 options::OPT_fno_diagnostics_show_option))
2988 CmdArgs.push_back(
"-fdiagnostics-show-option");
2991 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2992 CmdArgs.push_back(
"-fdiagnostics-show-category");
2993 CmdArgs.push_back(A->getValue());
2996 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
2997 options::OPT_fno_diagnostics_show_hotness,
false))
2998 CmdArgs.push_back(
"-fdiagnostics-show-hotness");
3001 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
3003 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
3004 CmdArgs.push_back(Args.MakeArgString(Opt));
3007 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3008 CmdArgs.push_back(
"-fdiagnostics-format");
3009 CmdArgs.push_back(A->getValue());
3012 if (
const Arg *A = Args.getLastArg(
3013 options::OPT_fdiagnostics_show_note_include_stack,
3014 options::OPT_fno_diagnostics_show_note_include_stack)) {
3015 const Option &O = A->getOption();
3016 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
3017 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
3019 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
3026 for (
const Arg *A : Args) {
3027 const Option &O = A->getOption();
3028 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3029 !O.matches(options::OPT_fdiagnostics_color) &&
3030 !O.matches(options::OPT_fno_color_diagnostics) &&
3031 !O.matches(options::OPT_fno_diagnostics_color) &&
3032 !O.matches(options::OPT_fdiagnostics_color_EQ))
3035 if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
3036 StringRef
Value(A->getValue());
3038 D.
Diag(diag::err_drv_clang_unsupported)
3039 << (
"-fdiagnostics-color=" +
Value).
str();
3045 CmdArgs.push_back(
"-fcolor-diagnostics");
3047 if (Args.hasArg(options::OPT_fansi_escape_codes))
3048 CmdArgs.push_back(
"-fansi-escape-codes");
3050 if (!Args.hasFlag(options::OPT_fshow_source_location,
3051 options::OPT_fno_show_source_location))
3052 CmdArgs.push_back(
"-fno-show-source-location");
3054 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
3055 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
3057 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
3059 CmdArgs.push_back(
"-fno-show-column");
3061 if (!Args.hasFlag(options::OPT_fspell_checking,
3062 options::OPT_fno_spell_checking))
3063 CmdArgs.push_back(
"-fno-spell-checking");
3069 const ArgList &Args, Arg *&Arg) {
3071 Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ);
3075 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
3078 StringRef
Value = Arg->getValue();
3079 if (Value ==
"split")
3081 if (Value ==
"single")
3084 D.
Diag(diag::err_drv_unsupported_option_argument)
3085 << Arg->getOption().getName() << Arg->getValue();
3090 const llvm::Triple &T,
const ArgList &Args,
3091 bool EmitCodeView,
bool IsWindowsMSVC,
3092 ArgStringList &CmdArgs,
3095 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
3096 options::OPT_fno_debug_info_for_profiling,
false) &&
3098 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
3099 CmdArgs.push_back(
"-fdebug-info-for-profiling");
3110 unsigned DWARFVersion = 0;
3113 bool SplitDWARFInlining =
3114 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
3115 options::OPT_fno_split_dwarf_inlining,
true);
3117 Args.ClaimAllArgs(options::OPT_g_Group);
3125 SplitDWARFInlining =
false;
3128 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
3131 if (A->getOption().matches(options::OPT_gN_Group)) {
3142 if (A->getIndex() > SplitDWARFArg->getIndex()) {
3146 SplitDWARFInlining))
3148 }
else if (SplitDWARFInlining)
3162 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
3164 if (A->getOption().matches(options::OPT_glldb))
3165 DebuggerTuning = llvm::DebuggerKind::LLDB;
3166 else if (A->getOption().matches(options::OPT_gsce))
3167 DebuggerTuning = llvm::DebuggerKind::SCE;
3169 DebuggerTuning = llvm::DebuggerKind::GDB;
3175 Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
3176 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
3180 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview)) {
3182 EmitCodeView =
true;
3187 if (!EmitCodeView && DWARFVersion == 0 &&
3191 EmitCodeView =
true;
3205 Args.ClaimAllArgs(options::OPT_g_flags_Group);
3212 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
3214 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3216 DebuggerTuning != llvm::DebuggerKind::SCE))
3217 CmdArgs.push_back(
"-dwarf-column-info");
3221 if (
const Arg *A = Args.getLastArg(options::OPT_gmodules))
3226 CmdArgs.push_back(
"-dwarf-ext-refs");
3227 CmdArgs.push_back(
"-fmodule-format=obj");
3234 if (T.isOSLinux() || T.isOSFuchsia()) {
3235 if (!SplitDWARFInlining)
3236 CmdArgs.push_back(
"-fno-split-dwarf-inlining");
3243 CmdArgs.push_back(
"-enable-split-dwarf=single");
3245 CmdArgs.push_back(
"-enable-split-dwarf");
3254 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
3255 options::OPT_fno_standalone_debug,
3257 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
3262 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
3268 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
3269 if (DWARFVersion < 5)
3270 D.Diag(diag::err_drv_argument_only_allowed_with)
3271 << A->getAsString(Args) <<
"-gdwarf-5";
3273 CmdArgs.push_back(
"-gembed-source");
3277 CmdArgs.push_back(
"-gcodeview");
3280 if (Args.hasFlag(options::OPT_gcodeview_ghash,
3281 options::OPT_gno_codeview_ghash,
false)) {
3282 CmdArgs.push_back(
"-gcodeview-ghash");
3293 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
3297 CmdArgs.push_back(
"-debug-info-macro");
3300 const auto *PubnamesArg =
3301 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
3302 options::OPT_gpubnames, options::OPT_gno_pubnames);
3304 DebuggerTuning == llvm::DebuggerKind::LLDB ||
3307 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
3308 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
3309 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
3310 options::OPT_gpubnames)
3312 :
"-ggnu-pubnames");
3314 if (Args.hasFlag(options::OPT_fdebug_ranges_base_address,
3315 options::OPT_fno_debug_ranges_base_address,
false)) {
3316 CmdArgs.push_back(
"-fdebug-ranges-base-address");
3322 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
3323 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
3326 CmdArgs.push_back(
"-mllvm");
3327 CmdArgs.push_back(
"-generate-arange-section");
3330 if (Args.hasFlag(options::OPT_fdebug_types_section,
3331 options::OPT_fno_debug_types_section,
false)) {
3332 if (!T.isOSBinFormatELF()) {
3333 D.Diag(diag::err_drv_unsupported_opt_for_target)
3334 << Args.getLastArg(options::OPT_fdebug_types_section)
3338 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
3340 CmdArgs.push_back(
"-mllvm");
3341 CmdArgs.push_back(
"-generate-type-units");
3347 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3348 CmdArgs.push_back(
"-debug-forward-template-params");
3352 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3353 CmdArgs.push_back(
"-dwarf-explicit-import");
3360 const ArgList &Args,
const char *LinkingOutput)
const {
3361 const auto &TC = getToolChain();
3362 const llvm::Triple &RawTriple = TC.getTriple();
3363 const llvm::Triple &Triple = TC.getEffectiveTriple();
3364 const std::string &TripleStr = Triple.getTriple();
3367 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3368 const Driver &D = TC.getDriver();
3369 ArgStringList CmdArgs;
3372 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
3381 bool IsHeaderModulePrecompile = isa<HeaderModulePrecompileJobAction>(JA);
3385 const char *ModuleName = [&]{
3386 auto *ModuleNameArg = Args.getLastArg(options::OPT_fmodule_name_EQ);
3387 return ModuleNameArg ? ModuleNameArg->getValue() :
"";
3389 InputInfo HeaderModuleInput(Inputs[0].getType(), ModuleName, ModuleName);
3392 IsHeaderModulePrecompile ? HeaderModuleInput : Inputs[0];
3395 const InputInfo *CudaDeviceInput =
nullptr;
3396 const InputInfo *OpenMPDeviceInput =
nullptr;
3400 }
else if (IsHeaderModulePrecompile &&
3403 if (I.getType() != Expected) {
3404 D.
Diag(diag::err_drv_module_header_wrong_kind)
3408 ModuleHeaderInputs.push_back(I);
3409 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
3410 CudaDeviceInput = &I;
3411 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
3412 OpenMPDeviceInput = &I;
3414 llvm_unreachable(
"unexpectedly given multiple inputs");
3418 const llvm::Triple *AuxTriple = IsCuda ? TC.getAuxTriple() :
nullptr;
3419 bool IsWindowsGNU = RawTriple.isWindowsGNUEnvironment();
3420 bool IsWindowsCygnus = RawTriple.isWindowsCygwinEnvironment();
3421 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
3422 bool IsIAMCU = RawTriple.isOSIAMCU();
3427 if (IsCuda || IsHIP) {
3428 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
3429 IsWindowsGNU |= AuxTriple && AuxTriple->isWindowsGNUEnvironment();
3430 IsWindowsCygnus |= AuxTriple && AuxTriple->isWindowsCygwinEnvironment();
3435 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
3440 CmdArgs.push_back(
"-cc1");
3443 CmdArgs.push_back(
"-triple");
3444 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3446 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
3447 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
3448 Args.ClaimAllArgs(options::OPT_MJ);
3451 if (IsCuda || IsHIP) {
3454 std::string NormalizedTriple;
3467 CmdArgs.push_back(
"-aux-triple");
3468 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3471 if (IsOpenMPDevice) {
3473 std::string NormalizedTriple =
3477 CmdArgs.push_back(
"-aux-triple");
3478 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3481 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3482 Triple.getArch() == llvm::Triple::thumb)) {
3483 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
3485 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
3487 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
3494 TC.addClangWarningOptions(CmdArgs);
3497 RewriteKind rewriteKind = RK_None;
3499 if (isa<AnalyzeJobAction>(JA)) {
3500 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
3501 CmdArgs.push_back(
"-analyze");
3502 }
else if (isa<MigrateJobAction>(JA)) {
3503 CmdArgs.push_back(
"-migrate");
3504 }
else if (isa<PreprocessJobAction>(JA)) {
3505 if (Output.
getType() == types::TY_Dependencies)
3506 CmdArgs.push_back(
"-Eonly");
3508 CmdArgs.push_back(
"-E");
3509 if (Args.hasArg(options::OPT_rewrite_objc) &&
3510 !Args.hasArg(options::OPT_g_Group))
3511 CmdArgs.push_back(
"-P");
3513 }
else if (isa<AssembleJobAction>(JA)) {
3514 CmdArgs.push_back(
"-emit-obj");
3519 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
3520 }
else if (isa<PrecompileJobAction>(JA)) {
3521 if (JA.
getType() == types::TY_Nothing)
3522 CmdArgs.push_back(
"-fsyntax-only");
3523 else if (JA.
getType() == types::TY_ModuleFile)
3524 CmdArgs.push_back(IsHeaderModulePrecompile
3525 ?
"-emit-header-module" 3526 :
"-emit-module-interface");
3528 CmdArgs.push_back(
"-emit-pch");
3529 }
else if (isa<VerifyPCHJobAction>(JA)) {
3530 CmdArgs.push_back(
"-verify-pch");
3532 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3533 "Invalid action for clang tool.");
3534 if (JA.
getType() == types::TY_Nothing) {
3535 CmdArgs.push_back(
"-fsyntax-only");
3536 }
else if (JA.
getType() == types::TY_LLVM_IR ||
3537 JA.
getType() == types::TY_LTO_IR) {
3538 CmdArgs.push_back(
"-emit-llvm");
3539 }
else if (JA.
getType() == types::TY_LLVM_BC ||
3540 JA.
getType() == types::TY_LTO_BC) {
3541 CmdArgs.push_back(
"-emit-llvm-bc");
3542 }
else if (JA.
getType() == types::TY_PP_Asm) {
3543 CmdArgs.push_back(
"-S");
3544 }
else if (JA.
getType() == types::TY_AST) {
3545 CmdArgs.push_back(
"-emit-pch");
3546 }
else if (JA.
getType() == types::TY_ModuleFile) {
3547 CmdArgs.push_back(
"-module-file-info");
3548 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
3549 CmdArgs.push_back(
"-rewrite-objc");
3550 rewriteKind = RK_NonFragile;
3551 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
3552 CmdArgs.push_back(
"-rewrite-objc");
3553 rewriteKind = RK_Fragile;
3555 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
3562 if (JA.
getType() == types::TY_LLVM_BC)
3563 CmdArgs.push_back(
"-emit-llvm-uselists");
3569 if (D.
isUsingLTO() && !isDeviceOffloadAction) {
3570 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
3575 if (!(RawTriple.isOSDarwin() || RawTriple.isPS4()) ||
3577 CmdArgs.push_back(
"-flto-unit");
3581 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
3583 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3585 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
3588 if (Args.getLastArg(options::OPT_save_temps_EQ))
3589 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
3594 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
3596 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
3598 CmdArgs.push_back(
"-disable-llvm-passes");
3602 static const constexpr
unsigned kBitcodeOptionBlacklist[] = {
3603 options::OPT_mkernel,
3604 options::OPT_fapple_kext,
3605 options::OPT_ffunction_sections,
3606 options::OPT_fno_function_sections,
3607 options::OPT_fdata_sections,
3608 options::OPT_fno_data_sections,
3609 options::OPT_funique_section_names,
3610 options::OPT_fno_unique_section_names,
3611 options::OPT_mrestrict_it,
3612 options::OPT_mno_restrict_it,
3613 options::OPT_mstackrealign,
3614 options::OPT_mno_stackrealign,
3615 options::OPT_mstack_alignment,
3616 options::OPT_mcmodel_EQ,
3617 options::OPT_mlong_calls,
3618 options::OPT_mno_long_calls,
3619 options::OPT_ggnu_pubnames,
3620 options::OPT_gdwarf_aranges,
3621 options::OPT_fdebug_types_section,
3622 options::OPT_fno_debug_types_section,
3623 options::OPT_fdwarf_directory_asm,
3624 options::OPT_fno_dwarf_directory_asm,
3625 options::OPT_mrelax_all,
3626 options::OPT_mno_relax_all,
3627 options::OPT_ftrap_function_EQ,
3628 options::OPT_ffixed_r9,
3629 options::OPT_mfix_cortex_a53_835769,
3630 options::OPT_mno_fix_cortex_a53_835769,
3631 options::OPT_ffixed_x18,
3632 options::OPT_mglobal_merge,
3633 options::OPT_mno_global_merge,
3634 options::OPT_mred_zone,
3635 options::OPT_mno_red_zone,
3636 options::OPT_Wa_COMMA,
3637 options::OPT_Xassembler,
3640 for (
const auto &A : Args)
3641 if (std::find(std::begin(kBitcodeOptionBlacklist),
3642 std::end(kBitcodeOptionBlacklist),
3643 A->getOption().getID()) !=
3644 std::end(kBitcodeOptionBlacklist))
3645 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
3648 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3649 options::OPT_fno_optimize_sibling_calls))
3650 CmdArgs.push_back(
"-mdisable-tail-calls");
3656 switch (TC.getArch()) {
3658 case llvm::Triple::arm:
3659 case llvm::Triple::armeb:
3660 case llvm::Triple::thumbeb:
3661 RenderARMABI(Triple, Args, CmdArgs);
3663 case llvm::Triple::aarch64:
3664 case llvm::Triple::aarch64_be:
3665 RenderAArch64ABI(Triple, Args, CmdArgs);
3670 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3671 if (A->getOption().matches(options::OPT_O4)) {
3672 CmdArgs.push_back(
"-O3");
3673 D.
Diag(diag::warn_O4_is_O3);
3675 A->render(Args, CmdArgs);
3680 if (Output.
getType() == types::TY_Dependencies) {
3683 CmdArgs.push_back(
"-o");
3686 assert(Output.
isNothing() &&
"Input output.");
3689 for (
const auto &II : Inputs) {
3691 if (II.isFilename())
3692 CmdArgs.push_back(II.getFilename());
3694 II.getInputArg().renderAsInput(Args, CmdArgs);
3703 CmdArgs.push_back(
"-fembed-bitcode=marker");
3709 CmdArgs.push_back(
"-disable-free");
3712 const bool IsAssertBuild =
false;
3714 const bool IsAssertBuild =
true;
3719 CmdArgs.push_back(
"-disable-llvm-verifier");
3722 if (Args.hasFlag(options::OPT_fdiscard_value_names,
3723 options::OPT_fno_discard_value_names, !IsAssertBuild))
3724 CmdArgs.push_back(
"-discard-value-names");
3728 CmdArgs.push_back(
"-main-file-name");
3729 CmdArgs.push_back(getBaseInputName(Args, Input));
3733 if (Args.hasArg(options::OPT_static))
3734 CmdArgs.push_back(
"-static-define");
3736 if (Args.hasArg(options::OPT_municode))
3737 CmdArgs.push_back(
"-DUNICODE");
3739 if (isa<AnalyzeJobAction>(JA))
3745 bool FoundAnalyzerConfig =
false;
3746 for (
auto Arg : Args.filtered(options::OPT_Xclang))
3747 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
3748 FoundAnalyzerConfig =
true;
3751 if (!FoundAnalyzerConfig)
3752 for (
auto Arg : Args.filtered(options::OPT_Xanalyzer))
3753 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
3754 FoundAnalyzerConfig =
true;
3757 if (FoundAnalyzerConfig)
3758 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
3763 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
3764 if (FunctionAlignment) {
3765 CmdArgs.push_back(
"-function-alignment");
3766 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
3769 llvm::Reloc::Model RelocationModel;
3772 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
3776 if ((RelocationModel == llvm::Reloc::ROPI ||
3777 RelocationModel == llvm::Reloc::ROPI_RWPI) &&
3779 !Args.hasArg(options::OPT_fallow_unsupported))
3780 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
3783 CmdArgs.push_back(
"-mrelocation-model");
3784 CmdArgs.push_back(RMName);
3787 CmdArgs.push_back(
"-pic-level");
3788 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
3790 CmdArgs.push_back(
"-pic-is-pie");
3793 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3794 CmdArgs.push_back(
"-meabi");
3795 CmdArgs.push_back(A->getValue());
3798 CmdArgs.push_back(
"-mthread-model");
3799 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
3800 if (!TC.isThreadModelSupported(A->getValue()))
3801 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
3802 << A->getValue() << A->getAsString(Args);
3803 CmdArgs.push_back(A->getValue());
3806 CmdArgs.push_back(Args.MakeArgString(TC.getThreadModel()));
3808 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3810 if (Args.hasFlag(options::OPT_fmerge_all_constants,
3811 options::OPT_fno_merge_all_constants,
false))
3812 CmdArgs.push_back(
"-fmerge-all-constants");
3814 if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks,
3815 options::OPT_fdelete_null_pointer_checks,
false))
3816 CmdArgs.push_back(
"-fno-delete-null-pointer-checks");
3820 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3821 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
3822 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3823 options::OPT_frewrite_map_file_EQ)) {
3824 StringRef Map = A->getValue();
3825 if (!llvm::sys::fs::exists(Map)) {
3826 D.
Diag(diag::err_drv_no_such_file) << Map;
3828 CmdArgs.push_back(
"-frewrite-map-file");
3829 CmdArgs.push_back(A->getValue());
3835 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3836 StringRef
v = A->getValue();
3837 CmdArgs.push_back(
"-mllvm");
3838 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
3842 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
3844 CmdArgs.push_back(
"-fno-jump-tables");
3846 if (Args.hasFlag(options::OPT_fprofile_sample_accurate,
3847 options::OPT_fno_profile_sample_accurate,
false))
3848 CmdArgs.push_back(
"-fprofile-sample-accurate");
3850 if (!Args.hasFlag(options::OPT_fpreserve_as_comments,
3851 options::OPT_fno_preserve_as_comments,
true))
3852 CmdArgs.push_back(
"-fno-preserve-as-comments");
3854 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3855 CmdArgs.push_back(
"-mregparm");
3856 CmdArgs.push_back(A->getValue());
3859 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3860 options::OPT_freg_struct_return)) {
3861 if (TC.getArch() != llvm::Triple::x86) {
3862 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3863 << A->getSpelling() << RawTriple.str();
3864 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3865 CmdArgs.push_back(
"-fpcc-struct-return");
3867 assert(A->getOption().matches(options::OPT_freg_struct_return));
3868 CmdArgs.push_back(
"-freg-struct-return");
3872 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
3873 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
3876 CmdArgs.push_back(
"-mdisable-fp-elim");
3877 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3878 options::OPT_fno_zero_initialized_in_bss))
3879 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
3884 OptSpecifier StrictAliasingAliasOption =
3885 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
3888 bool TBAAOnByDefault = !D.
IsCLMode();
3889 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
3890 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
3891 CmdArgs.push_back(
"-relaxed-aliasing");
3892 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3893 options::OPT_fno_struct_path_tbaa))
3894 CmdArgs.push_back(
"-no-struct-path-tbaa");
3895 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3897 CmdArgs.push_back(
"-fstrict-enums");
3898 if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
3900 CmdArgs.push_back(
"-fno-strict-return");
3901 if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
3902 options::OPT_fno_allow_editor_placeholders,
false))
3903 CmdArgs.push_back(
"-fallow-editor-placeholders");
3904 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
3905 options::OPT_fno_strict_vtable_pointers,
3907 CmdArgs.push_back(
"-fstrict-vtable-pointers");
3908 if (Args.hasFlag(options::OPT_fforce_emit_vtables,
3909 options::OPT_fno_force_emit_vtables,
3911 CmdArgs.push_back(
"-fforce-emit-vtables");
3912 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3913 options::OPT_fno_optimize_sibling_calls))
3914 CmdArgs.push_back(
"-mdisable-tail-calls");
3915 if (Args.hasFlag(options::OPT_fno_escaping_block_tail_calls,
3916 options::OPT_fescaping_block_tail_calls,
false))
3917 CmdArgs.push_back(
"-fno-escaping-block-tail-calls");
3919 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
3920 options::OPT_fno_fine_grained_bitfield_accesses);
3923 if (Args.hasArg(options::OPT_fsplit_stack))
3924 CmdArgs.push_back(
"-split-stacks");
3930 bool IsIntegratedAssemblerDefault = TC.IsIntegratedAssemblerDefault();
3931 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
3932 IsIntegratedAssemblerDefault) ||
3933 Args.hasArg(options::OPT_dA))
3934 CmdArgs.push_back(
"-masm-verbose");
3936 if (!TC.useIntegratedAs())
3937 CmdArgs.push_back(
"-no-integrated-as");
3939 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3940 CmdArgs.push_back(
"-mdebug-pass");
3941 CmdArgs.push_back(
"Structure");
3943 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3944 CmdArgs.push_back(
"-mdebug-pass");
3945 CmdArgs.push_back(
"Arguments");
3951 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
3952 CmdArgs.push_back(
"-mconstructor-aliases");
3956 if (KernelOrKext && RawTriple.isOSDarwin())
3957 CmdArgs.push_back(
"-fforbid-guard-variables");
3959 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
3961 CmdArgs.push_back(
"-mms-bitfields");
3964 if (Args.hasFlag(options::OPT_mpie_copy_relocations,
3965 options::OPT_mno_pie_copy_relocations,
3967 CmdArgs.push_back(
"-mpie-copy-relocations");
3970 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
3971 CmdArgs.push_back(
"-fno-plt");
3978 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
3981 CmdArgs.push_back(
"-ffreestanding");
3986 bool AsynchronousUnwindTables =
3987 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3988 options::OPT_fno_asynchronous_unwind_tables,
3989 (TC.IsUnwindTablesDefault(Args) ||
3990 TC.getSanitizerArgs().needsUnwindTables()) &&
3992 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3993 AsynchronousUnwindTables))
3994 CmdArgs.push_back(
"-munwind-tables");
3999 (void)Args.hasArg(options::OPT_mtune_EQ);
4001 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
4002 CmdArgs.push_back(
"-mcode-model");
4003 CmdArgs.push_back(A->getValue());
4007 std::string CPU =
getCPUName(Args, Triple,
false);
4009 CmdArgs.push_back(
"-target-cpu");
4010 CmdArgs.push_back(Args.MakeArgString(CPU));
4013 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
4017 bool EmitCodeView =
false;
4022 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
4026 CmdArgs, DebugInfoKind, DwarfFission);
4031 (RawTriple.isOSLinux() || RawTriple.isOSFuchsia()) &&
4032 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4033 isa<BackendJobAction>(JA));
4034 const char *SplitDWARFOut;
4036 CmdArgs.push_back(
"-split-dwarf-file");
4038 CmdArgs.push_back(SplitDWARFOut);
4042 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4043 CmdArgs.push_back(
"-target-linker-version");
4044 CmdArgs.push_back(A->getValue());
4048 CmdArgs.push_back(
"-momit-leaf-frame-pointer");
4052 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
4054 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
4055 TC.getArch() == llvm::Triple::x86) {
4056 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
4057 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
4058 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
4059 << Unsupported->getOption().getName();
4062 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
4063 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
4064 << Unsupported->getOption().getName()
4065 <<
"please use -maltivec and include altivec.h explicitly";
4066 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
4067 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
4068 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
4071 Args.AddAllArgs(CmdArgs, options::OPT_v);
4072 Args.AddLastArg(CmdArgs, options::OPT_H);
4074 CmdArgs.push_back(
"-header-include-file");
4078 Args.AddLastArg(CmdArgs, options::OPT_P);
4079 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
4082 CmdArgs.push_back(
"-diagnostic-log-file");
4089 if (Args.hasFlag(options::OPT_ffunction_sections,
4090 options::OPT_fno_function_sections, UseSeparateSections)) {
4091 CmdArgs.push_back(
"-ffunction-sections");
4094 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
4095 UseSeparateSections)) {
4096 CmdArgs.push_back(
"-fdata-sections");
4099 if (!Args.hasFlag(options::OPT_funique_section_names,
4100 options::OPT_fno_unique_section_names,
true))
4101 CmdArgs.push_back(
"-fno-unique-section-names");
4103 if (
auto *A = Args.getLastArg(
4104 options::OPT_finstrument_functions,
4105 options::OPT_finstrument_functions_after_inlining,
4106 options::OPT_finstrument_function_entry_bare))
4107 A->render(Args, CmdArgs);
4112 if (!Triple.isNVPTX())
4115 if (
auto *ABICompatArg = Args.getLastArg(options::OPT_fclang_abi_compat_EQ))
4116 ABICompatArg->render(Args, CmdArgs);
4119 if (RawTriple.isPS4CPU() &&
4120 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
4126 if (Args.hasArg(options::OPT_nostdinc)) {
4127 CmdArgs.push_back(
"-nostdsysteminc");
4128 CmdArgs.push_back(
"-nobuiltininc");
4130 if (Args.hasArg(options::OPT_nostdlibinc))
4131 CmdArgs.push_back(
"-nostdsysteminc");
4132 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
4133 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
4137 CmdArgs.push_back(
"-resource-dir");
4140 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
4149 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
4155 Args.ClaimAllArgs(options::OPT_D);
4158 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4159 if (A->getOption().matches(options::OPT_O4)) {
4160 CmdArgs.push_back(
"-O3");
4161 D.
Diag(diag::warn_O4_is_O3);
4163 A->render(Args, CmdArgs);
4169 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4170 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
4175 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
4176 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
4182 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
4184 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
4185 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
4186 CmdArgs.push_back(
"-pedantic");
4187 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
4188 Args.AddLastArg(CmdArgs, options::OPT_w);
4191 if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
4193 Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
4200 bool ImplyVCPPCXXVer =
false;
4201 if (Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
4202 if (
Std->getOption().matches(options::OPT_ansi))
4204 CmdArgs.push_back(
"-std=c++98");
4206 CmdArgs.push_back(
"-std=c89");
4208 Std->render(Args, CmdArgs);
4211 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
4212 options::OPT_ftrigraphs,
4213 options::OPT_fno_trigraphs))
4215 A->render(Args, CmdArgs);
4224 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
4226 else if (IsWindowsMSVC)
4227 ImplyVCPPCXXVer =
true;
4229 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4230 options::OPT_fno_trigraphs);
4246 Args.getLastArg(options::OPT_Wwrite_strings,
4247 options::OPT_Wno_write_strings, options::OPT_w);
4249 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
4250 CmdArgs.push_back(
"-fconst-strings");
4257 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4259 CmdArgs.push_back(
"-fdeprecated-macro");
4263 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4264 if (Asm->getOption().matches(options::OPT_fasm))
4265 CmdArgs.push_back(
"-fgnu-keywords");
4267 CmdArgs.push_back(
"-fno-gnu-keywords");
4271 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4274 CmdArgs.push_back(
"-fno-autolink");
4281 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4282 options::OPT_ftemplate_depth_EQ)) {
4283 CmdArgs.push_back(
"-ftemplate-depth");
4284 CmdArgs.push_back(A->getValue());
4287 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4288 CmdArgs.push_back(
"-foperator-arrow-depth");
4289 CmdArgs.push_back(A->getValue());
4292 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4293 CmdArgs.push_back(
"-fconstexpr-depth");
4294 CmdArgs.push_back(A->getValue());
4297 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4298 CmdArgs.push_back(
"-fconstexpr-steps");
4299 CmdArgs.push_back(A->getValue());
4302 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4303 CmdArgs.push_back(
"-fbracket-depth");
4304 CmdArgs.push_back(A->getValue());
4307 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4308 options::OPT_Wlarge_by_value_copy_def)) {
4309 if (A->getNumValues()) {
4310 StringRef
bytes = A->getValue();
4311 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
4313 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
4316 if (Args.hasArg(options::OPT_relocatable_pch))
4317 CmdArgs.push_back(
"-relocatable-pch");
4319 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
4320 static const char *kCFABIs[] = {
4321 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
4324 if (find(kCFABIs, StringRef(A->getValue())) == std::end(kCFABIs))
4325 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
4327 A->render(Args, CmdArgs);
4330 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4331 CmdArgs.push_back(
"-fconstant-string-class");
4332 CmdArgs.push_back(A->getValue());
4335 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4336 CmdArgs.push_back(
"-ftabstop");
4337 CmdArgs.push_back(A->getValue());
4340 if (Args.hasFlag(options::OPT_fstack_size_section,
4341 options::OPT_fno_stack_size_section, RawTriple.isPS4()))
4342 CmdArgs.push_back(
"-fstack-size-section");
4344 CmdArgs.push_back(
"-ferror-limit");
4345 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
4346 CmdArgs.push_back(A->getValue());
4348 CmdArgs.push_back(
"19");
4350 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4351 CmdArgs.push_back(
"-fmacro-backtrace-limit");
4352 CmdArgs.push_back(A->getValue());
4355 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4356 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
4357 CmdArgs.push_back(A->getValue());
4360 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4361 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
4362 CmdArgs.push_back(A->getValue());
4365 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4366 CmdArgs.push_back(
"-fspell-checking-limit");
4367 CmdArgs.push_back(A->getValue());
4371 CmdArgs.push_back(
"-fmessage-length");
4372 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
4373 CmdArgs.push_back(A->getValue());
4377 unsigned N = llvm::sys::Process::StandardErrColumns();
4378 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
4382 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4383 options::OPT_fvisibility_ms_compat)) {
4384 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4385 CmdArgs.push_back(
"-fvisibility");
4386 CmdArgs.push_back(A->getValue());
4388 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4389 CmdArgs.push_back(
"-fvisibility");
4390 CmdArgs.push_back(
"hidden");
4391 CmdArgs.push_back(
"-ftype-visibility");
4392 CmdArgs.push_back(
"default");
4396 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
4397 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
4399 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4402 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
4403 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
4404 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
4405 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
4406 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls,
4407 options::OPT_fno_emulated_tls);
4408 Args.AddLastArg(CmdArgs, options::OPT_fkeep_static_consts);
4411 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
4412 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4414 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4415 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
4419 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4420 options::OPT_fno_openmp,
false) &&
4427 CmdArgs.push_back(
"-fopenmp");
4432 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
4433 options::OPT_fnoopenmp_use_tls,
true))
4434 CmdArgs.push_back(
"-fnoopenmp-use-tls");
4435 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
4436 options::OPT_fno_openmp_simd);
4437 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
4438 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
4439 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
4440 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
4441 options::OPT_fno_openmp_optimistic_collapse,
4443 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
4447 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
4448 options::OPT_fno_openmp_cuda_mode,
false))
4449 CmdArgs.push_back(
"-fopenmp-cuda-mode");
4453 if (Args.hasFlag(options::OPT_fopenmp_cuda_force_full_runtime,
4454 options::OPT_fno_openmp_cuda_force_full_runtime,
4456 CmdArgs.push_back(
"-fopenmp-cuda-force-full-runtime");
4468 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
4469 options::OPT_fno_openmp_simd);
4470 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
4474 Sanitize.
addArgs(TC, Args, CmdArgs, InputType);
4476 const XRayArgs &XRay = TC.getXRayArgs();
4477 XRay.
addArgs(TC, Args, CmdArgs, InputType);
4479 if (TC.SupportsProfiling())
4480 Args.AddLastArg(CmdArgs, options::OPT_pg);
4482 if (TC.SupportsProfiling())
4483 Args.AddLastArg(CmdArgs, options::OPT_mfentry);
4486 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4487 options::OPT_fno_lax_vector_conversions))
4488 CmdArgs.push_back(
"-fno-lax-vector-conversions");
4490 if (Args.getLastArg(options::OPT_fapple_kext) ||
4491 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
4492 CmdArgs.push_back(
"-fapple-kext");
4494 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
4495 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
4496 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
4497 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4498 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
4500 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4501 CmdArgs.push_back(
"-ftrapv-handler");
4502 CmdArgs.push_back(A->getValue());
4505 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
4509 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
4510 if (A->getOption().matches(options::OPT_fwrapv))
4511 CmdArgs.push_back(
"-fwrapv");
4512 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4513 options::OPT_fno_strict_overflow)) {
4514 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4515 CmdArgs.push_back(
"-fwrapv");
4518 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4519 options::OPT_fno_reroll_loops))
4520 if (A->getOption().matches(options::OPT_freroll_loops))
4521 CmdArgs.push_back(
"-freroll-loops");
4523 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
4524 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4525 options::OPT_fno_unroll_loops);
4527 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4529 if (Args.hasFlag(options::OPT_mspeculative_load_hardening, options::OPT_mno_speculative_load_hardening,
4531 CmdArgs.push_back(Args.MakeArgString(
"-mspeculative-load-hardening"));
4537 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4539 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
4541 if (Args.hasArg(options::OPT_mstack_alignment)) {
4542 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4543 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
4546 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4547 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4550 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
4552 CmdArgs.push_back(
"-mstack-probe-size=0");
4555 if (!Args.hasFlag(options::OPT_mstack_arg_probe,
4556 options::OPT_mno_stack_arg_probe,
true))
4557 CmdArgs.push_back(Args.MakeArgString(
"-mno-stack-arg-probe"));
4559 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4560 options::OPT_mno_restrict_it)) {
4561 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4562 CmdArgs.push_back(
"-mllvm");
4563 CmdArgs.push_back(
"-arm-restrict-it");
4565 CmdArgs.push_back(
"-mllvm");
4566 CmdArgs.push_back(
"-arm-no-restrict-it");
4568 }
else if (Triple.isOSWindows() &&
4569 (Triple.getArch() == llvm::Triple::arm ||
4570 Triple.getArch() == llvm::Triple::thumb)) {
4572 CmdArgs.push_back(
"-mllvm");
4573 CmdArgs.push_back(
"-arm-restrict-it");
4579 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
4581 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
4587 StringRef fname = A->getValue();
4588 if (!llvm::sys::fs::exists(fname))
4589 D.
Diag(diag::err_drv_no_such_file) << fname;
4591 A->render(Args, CmdArgs);
4593 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
4597 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4598 options::OPT_fno_assume_sane_operator_new))
4599 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4602 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
4603 TC.IsBlocksDefault()) ||
4604 (Args.hasArg(options::OPT_fgnu_runtime) &&
4605 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4606 !Args.hasArg(options::OPT_fno_blocks))) {
4607 CmdArgs.push_back(
"-fblocks");
4609 if (!Args.hasArg(options::OPT_fgnu_runtime) && !TC.hasBlocksRuntime())
4610 CmdArgs.push_back(
"-fblocks-runtime-optional");
4614 if (TC.IsEncodeExtendedBlockSignatureDefault())
4615 CmdArgs.push_back(
"-fencode-extended-block-signature");
4617 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
4620 CmdArgs.push_back(
"-fcoroutines-ts");
4623 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
4624 options::OPT_fno_double_square_bracket_attributes);
4626 bool HaveModules =
false;
4630 if (Args.hasFlag(options::OPT_fno_access_control,
4631 options::OPT_faccess_control,
false))
4632 CmdArgs.push_back(
"-fno-access-control");
4635 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4636 options::OPT_felide_constructors,
false))
4637 CmdArgs.push_back(
"-fno-elide-constructors");
4643 CmdArgs.push_back(
"-fno-rtti");
4646 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4647 TC.getArch() == llvm::Triple::hexagon))
4648 CmdArgs.push_back(
"-fshort-enums");
4654 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
4655 !RawTriple.isOSWindows() &&
4656 RawTriple.getOS() != llvm::Triple::Solaris &&
4657 TC.getArch() != llvm::Triple::xcore &&
4658 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
4659 RawTriple.hasEnvironment())) ||
4661 CmdArgs.push_back(
"-fno-use-cxa-atexit");
4663 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
4664 options::OPT_fno_register_global_dtors_with_atexit,
4665 RawTriple.isOSDarwin() && !KernelOrKext))
4666 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
4669 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
4671 CmdArgs.push_back(
"-fms-extensions");
4674 if (Args.hasFlag(options::OPT_fuse_line_directives,
4675 options::OPT_fno_use_line_directives,
false))
4676 CmdArgs.push_back(
"-fuse-line-directives");
4679 if (Args.hasFlag(options::OPT_fms_compatibility,
4680 options::OPT_fno_ms_compatibility,
4682 Args.hasFlag(options::OPT_fms_extensions,
4683 options::OPT_fno_ms_extensions,
true))))
4684 CmdArgs.push_back(
"-fms-compatibility");
4686 VersionTuple MSVT = TC.computeMSVCVersion(&D, Args);
4689 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
4691 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4692 if (ImplyVCPPCXXVer) {
4693 StringRef LanguageStandard;
4694 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
4695 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
4696 .Case(
"c++14",
"-std=c++14")
4697 .Case(
"c++17",
"-std=c++17")
4698 .Case(
"c++latest",
"-std=c++2a")
4700 if (LanguageStandard.empty())
4701 D.
Diag(clang::diag::warn_drv_unused_argument)
4702 << StdArg->getAsString(Args);
4705 if (LanguageStandard.empty()) {
4706 if (IsMSVC2015Compatible)
4707 LanguageStandard =
"-std=c++14";
4709 LanguageStandard =
"-std=c++11";
4712 CmdArgs.push_back(LanguageStandard.data());
4716 if (Args.hasFlag(options::OPT_fborland_extensions,
4717 options::OPT_fno_borland_extensions,
false))
4718 CmdArgs.push_back(
"-fborland-extensions");
4721 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
4723 CmdArgs.push_back(
"-fdeclspec");
4724 else if (Args.hasArg(options::OPT_fno_declspec))
4725 CmdArgs.push_back(
"-fno-declspec");
4729 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4730 options::OPT_fno_threadsafe_statics,
4731 !IsWindowsMSVC || IsMSVC2015Compatible))
4732 CmdArgs.push_back(
"-fno-threadsafe-statics");
4738 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
4739 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
4740 CmdArgs.push_back(
"-fdelayed-template-parsing");
4744 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
4745 options::OPT_fno_gnu_keywords))
4746 A->render(Args, CmdArgs);
4748 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
4750 CmdArgs.push_back(
"-fgnu89-inline");
4752 if (Args.hasArg(options::OPT_fno_inline))
4753 CmdArgs.push_back(
"-fno-inline");
4755 if (Arg* InlineArg = Args.getLastArg(options::OPT_finline_functions,
4756 options::OPT_finline_hint_functions,
4757 options::OPT_fno_inline_functions))
4758 InlineArg->render(Args, CmdArgs);
4760 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager,
4761 options::OPT_fno_experimental_new_pass_manager);
4763 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
4767 if (Args.hasFlag(options::OPT_fapplication_extension,
4768 options::OPT_fno_application_extension,
false))
4769 CmdArgs.push_back(
"-fapplication-extension");
4776 Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
4777 options::OPT_fseh_exceptions,
4778 options::OPT_fdwarf_exceptions);
4780 const Option &Opt = A->getOption();
4781 if (Opt.matches(options::OPT_fsjlj_exceptions))
4782 CmdArgs.push_back(
"-fsjlj-exceptions");
4783 if (Opt.matches(options::OPT_fseh_exceptions))
4784 CmdArgs.push_back(
"-fseh-exceptions");
4785 if (Opt.matches(options::OPT_fdwarf_exceptions))
4786 CmdArgs.push_back(
"-fdwarf-exceptions");
4788 switch (TC.GetExceptionModel(Args)) {
4791 case llvm::ExceptionHandling::DwarfCFI:
4792 CmdArgs.push_back(
"-fdwarf-exceptions");
4794 case llvm::ExceptionHandling::SjLj:
4795 CmdArgs.push_back(
"-fsjlj-exceptions");
4797 case llvm::ExceptionHandling::WinEH:
4798 CmdArgs.push_back(
"-fseh-exceptions");
4804 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4805 options::OPT_fno_assume_sane_operator_new))
4806 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4811 if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
4812 options::OPT_fno_relaxed_template_template_args,
false))
4813 CmdArgs.push_back(
"-frelaxed-template-template-args");
4817 if (Args.hasFlag(options::OPT_fsized_deallocation,
4818 options::OPT_fno_sized_deallocation,
false))
4819 CmdArgs.push_back(
"-fsized-deallocation");
4823 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
4824 options::OPT_fno_aligned_allocation,
4825 options::OPT_faligned_new_EQ)) {
4826 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
4827 CmdArgs.push_back(
"-fno-aligned-allocation");
4829 CmdArgs.push_back(
"-faligned-allocation");
4834 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
4835 options::OPT_faligned_new_EQ))
4837 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
4841 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4842 options::OPT_fno_constant_cfstrings) ||
4843 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4844 options::OPT_mno_constant_cfstrings))
4845 CmdArgs.push_back(
"-fno-constant-cfstrings");
4848 if (Args.hasFlag(options::OPT_fpascal_strings,
4849 options::OPT_fno_pascal_strings,
false))
4850 CmdArgs.push_back(
"-fpascal-strings");
4854 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
4855 std::string PackStructStr =
"-fpack-struct=";
4856 PackStructStr += A->getValue();
4857 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
4858 }
else if (Args.hasFlag(options::OPT_fpack_struct,
4859 options::OPT_fno_pack_struct,
false)) {
4860 CmdArgs.push_back(
"-fpack-struct=1");
4864 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4865 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4866 if (!SkipMaxTypeAlign) {
4867 std::string MaxTypeAlignStr =
"-fmax-type-align=";
4868 MaxTypeAlignStr += A->getValue();
4869 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4871 }
else if (RawTriple.isOSDarwin()) {
4872 if (!SkipMaxTypeAlign) {
4873 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
4874 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4878 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
4879 CmdArgs.push_back(
"-Qn");
4883 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
4885 CmdArgs.push_back(
"-fno-common");
4889 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
4890 options::OPT_funsigned_bitfields))
4891 D.
Diag(diag::warn_drv_clang_unsupported)
4892 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4895 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
4896 D.
Diag(diag::err_drv_clang_unsupported)
4897 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4900 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4901 StringRef value = inputCharset->getValue();
4902 if (!value.equals_lower(
"utf-8"))
4903 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4908 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4909 StringRef value = execCharset->getValue();
4910 if (!value.equals_lower(
"utf-8"))
4911 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4918 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4920 CmdArgs.push_back(
"-fasm-blocks");
4923 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4924 options::OPT_fno_gnu_inline_asm,
true))
4925 CmdArgs.push_back(
"-fno-gnu-inline-asm");
4931 OptSpecifier VectorizeAliasOption =
4932 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
4933 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4934 options::OPT_fno_vectorize, EnableVec))
4935 CmdArgs.push_back(
"-vectorize-loops");
4939 OptSpecifier SLPVectAliasOption =
4940 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
4941 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4942 options::OPT_fno_slp_vectorize, EnableSLPVec))
4943 CmdArgs.push_back(
"-vectorize-slp");
4947 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4948 A->render(Args, CmdArgs);
4950 if (Arg *A = Args.getLastArg(
4951 options::OPT_fsanitize_undefined_strip_path_components_EQ))
4952 A->render(Args, CmdArgs);
4956 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4957 options::OPT_fno_dollars_in_identifiers)) {
4958 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
4959 CmdArgs.push_back(
"-fdollars-in-identifiers");
4961 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
4966 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4967 options::OPT_fno_unit_at_a_time)) {
4968 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
4969 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4972 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4973 options::OPT_fno_apple_pragma_pack,
false))
4974 CmdArgs.push_back(
"-fapple-pragma-pack");
4976 if (Args.hasFlag(options::OPT_fsave_optimization_record,
4977 options::OPT_foptimization_record_file_EQ,
4978 options::OPT_fno_save_optimization_record,
false)) {
4979 CmdArgs.push_back(
"-opt-record-file");
4981 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
4983 CmdArgs.push_back(A->getValue());
4987 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
4988 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
4989 F = FinalOutput->getValue();
5001 llvm::sys::path::replace_extension(F,
"");
5003 Triple.normalize());
5009 llvm::sys::path::replace_extension(F,
"opt.yaml");
5010 CmdArgs.push_back(Args.MakeArgString(F));
5014 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
5015 options::OPT_fno_rewrite_imports,
false);
5017 CmdArgs.push_back(
"-frewrite-imports");
5023 if (Args.hasFlag(options::OPT_frewrite_includes,
5024 options::OPT_fno_rewrite_includes,
false) ||
5026 CmdArgs.push_back(
"-frewrite-includes");
5029 if (Arg *A = Args.getLastArg(options::OPT_traditional,
5030 options::OPT_traditional_cpp)) {
5031 if (isa<PreprocessJobAction>(JA))
5032 CmdArgs.push_back(
"-traditional-cpp");
5034 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
5037 Args.AddLastArg(CmdArgs, options::OPT_dM);
5038 Args.AddLastArg(CmdArgs, options::OPT_dD);
5041 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5042 CmdArgs.push_back(
"-serialize-diagnostic-file");
5043 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
5046 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5047 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
5050 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
5052 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
5055 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5056 CmdArgs.push_back(
"-load");
5057 CmdArgs.push_back(A->getValue());
5063 if (!StatsFile.empty())
5064 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
5071 !isa<PreprocessJobAction>(JA)) {
5072 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
5074 if (StringRef(Arg->getValue()) !=
"-finclude-default-header")
5075 CmdArgs.push_back(Arg->getValue());
5079 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
5081 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
5087 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
5088 CmdArgs.push_back(
"-disable-llvm-optzns");
5090 A->render(Args, CmdArgs);
5104 isa<CompileJobAction>(JA))
5105 CmdArgs.push_back(
"-disable-llvm-passes");
5107 if (Output.
getType() == types::TY_Dependencies) {
5110 CmdArgs.push_back(
"-o");
5113 assert(Output.
isNothing() &&
"Invalid output.");
5119 if (IsHeaderModulePrecompile)
5120 FrontendInputs = ModuleHeaderInputs;
5122 FrontendInputs = {};
5124 for (
const InputInfo &Input : FrontendInputs) {
5131 Args.AddAllArgs(CmdArgs, options::OPT_undef);
5140 auto GRecordSwitches =
5141 Args.hasFlag(options::OPT_grecord_command_line,
5142 options::OPT_gno_record_command_line,
false);
5143 auto FRecordSwitches =
5144 Args.hasFlag(options::OPT_frecord_command_line,
5145 options::OPT_fno_record_command_line,
false);
5146 if (FRecordSwitches && !Triple.isOSBinFormatELF())
5147 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5148 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
5150 if (TC.UseDwarfDebugFlags() || GRecordSwitches || FRecordSwitches) {
5151 ArgStringList OriginalArgs;
5152 for (
const auto &Arg : Args)
5153 Arg->render(Args, OriginalArgs);
5157 for (
const char *OriginalArg : OriginalArgs) {
5161 Flags += EscapedArg;
5163 auto FlagsArgString = Args.MakeArgString(Flags);
5164 if (TC.UseDwarfDebugFlags() || GRecordSwitches) {
5165 CmdArgs.push_back(
"-dwarf-debug-flags");
5166 CmdArgs.push_back(FlagsArgString);
5168 if (FRecordSwitches) {
5169 CmdArgs.push_back(
"-record-command-line");
5170 CmdArgs.push_back(FlagsArgString);
5176 if ((IsCuda || IsHIP) && CudaDeviceInput) {
5177 CmdArgs.push_back(
"-fcuda-include-gpubinary");
5178 CmdArgs.push_back(CudaDeviceInput->
getFilename());
5179 if (Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false))
5180 CmdArgs.push_back(
"-fgpu-rdc");
5184 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
5185 options::OPT_fno_cuda_short_ptr,
false))
5186 CmdArgs.push_back(
"-fcuda-short-ptr");
5194 if (IsOpenMPDevice) {
5195 CmdArgs.push_back(
"-fopenmp-is-device");
5196 if (OpenMPDeviceInput) {
5197 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
5198 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
5207 Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ);
5208 assert(Tgts && Tgts->getNumValues() &&
5209 "OpenMP offloading has to have targets specified.");
5210 for (
unsigned i = 0; i < Tgts->getNumValues(); ++i) {
5215 llvm::Triple T(Tgts->getValue(i));
5216 TargetInfo += T.getTriple();
5218 CmdArgs.push_back(Args.MakeArgString(TargetInfo.str()));
5221 bool WholeProgramVTables =
5222 Args.hasFlag(options::OPT_fwhole_program_vtables,
5223 options::OPT_fno_whole_program_vtables,
false);
5224 if (WholeProgramVTables) {
5226 D.
Diag(diag::err_drv_argument_only_allowed_with)
5227 <<
"-fwhole-program-vtables" 5229 CmdArgs.push_back(
"-fwhole-program-vtables");
5232 bool RequiresSplitLTOUnit = WholeProgramVTables || Sanitize.
needsLTO();
5234 Args.hasFlag(options::OPT_fsplit_lto_unit,
5235 options::OPT_fno_split_lto_unit, RequiresSplitLTOUnit);
5236 if (RequiresSplitLTOUnit && !SplitLTOUnit)
5237 D.
Diag(diag::err_drv_argument_not_allowed_with)
5238 <<
"-fno-split-lto-unit" 5239 << (WholeProgramVTables ?
"-fwhole-program-vtables" :
"-fsanitize=cfi");
5241 CmdArgs.push_back(
"-fsplit-lto-unit");
5243 if (Arg *A = Args.getLastArg(options::OPT_fexperimental_isel,
5244 options::OPT_fno_experimental_isel)) {
5245 CmdArgs.push_back(
"-mllvm");
5246 if (A->getOption().matches(options::OPT_fexperimental_isel)) {
5247 CmdArgs.push_back(
"-global-isel=1");
5252 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
5253 bool IsOptLevelSupported =
false;
5255 Arg *A = Args.getLastArg(options::OPT_O_Group);
5256 if (Triple.getArch() == llvm::Triple::aarch64) {
5257 if (!A || A->getOption().matches(options::OPT_O0))
5258 IsOptLevelSupported =
true;
5260 if (!IsArchSupported || !IsOptLevelSupported) {
5261 CmdArgs.push_back(
"-mllvm");
5262 CmdArgs.push_back(
"-global-isel-abort=2");
5264 if (!IsArchSupported)
5265 D.
Diag(diag::warn_drv_experimental_isel_incomplete) << Triple.getArchName();
5267 D.
Diag(diag::warn_drv_experimental_isel_incomplete_opt);
5270 CmdArgs.push_back(
"-global-isel=0");
5274 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
5275 options::OPT_fno_force_enable_int128)) {
5276 if (A->getOption().matches(options::OPT_fforce_enable_int128))
5277 CmdArgs.push_back(
"-fforce-enable-int128");
5280 if (Args.hasFlag(options::OPT_fcomplete_member_pointers,
5281 options::OPT_fno_complete_member_pointers,
false))
5282 CmdArgs.push_back(
"-fcomplete-member-pointers");
5284 if (!Args.hasFlag(options::OPT_fcxx_static_destructors,
5285 options::OPT_fno_cxx_static_destructors,
true))
5286 CmdArgs.push_back(
"-fno-c++-static-destructors");
5288 if (Arg *A = Args.getLastArg(options::OPT_moutline,
5289 options::OPT_mno_outline)) {
5290 if (A->getOption().matches(options::OPT_moutline)) {
5294 if (Triple.getArch() != llvm::Triple::aarch64) {
5295 D.
Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
5297 CmdArgs.push_back(
"-mllvm");
5298 CmdArgs.push_back(
"-enable-machine-outliner");
5302 CmdArgs.push_back(
"-mllvm");
5303 CmdArgs.push_back(
"-enable-machine-outliner=never");
5307 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
5308 (TC.getTriple().isOSBinFormatELF() ||
5309 TC.getTriple().isOSBinFormatCOFF()) &&
5310 !TC.getTriple().isPS4() &&
5311 !TC.getTriple().isOSNetBSD() &&
5313 !TC.getTriple().isAndroid() &&
5314 TC.useIntegratedAs()))
5315 CmdArgs.push_back(
"-faddrsig");
5318 if (Args.hasArg(options::OPT__SLASH_fallback) &&
5319 Output.
getType() == types::TY_Object &&
5320 (InputType == types::TY_C || InputType == types::TY_CXX)) {
5322 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
5323 C.
addCommand(llvm::make_unique<FallbackCommand>(
5324 JA, *
this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
5325 }
else if (Args.hasArg(options::OPT__SLASH_fallback) &&
5326 isa<PrecompileJobAction>(JA)) {
5329 C.
addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *
this, Exec,
5332 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
5336 if (Output.
getType() == types::TY_Object &&
5337 Args.hasFlag(options::OPT__SLASH_showFilenames,
5338 options::OPT__SLASH_showFilenames_,
false)) {
5342 if (Arg *A = Args.getLastArg(options::OPT_pg))
5344 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer" 5345 << A->getAsString(Args);
5351 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
5355 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5356 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
5359 Args.ClaimAllArgs(options::OPT_emit_llvm);
5366 :
Tool(
"clang",
"clang frontend", TC, RF_Full) {}
5373 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
5374 ArgStringList &cmdArgs,
5375 RewriteKind rewriteKind)
const {
5378 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5379 options::OPT_fobjc_runtime_EQ);
5384 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5386 StringRef value = runtimeArg->getValue();
5392 (runtime.
getVersion() >= VersionTuple(2, 0)))
5396 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
5400 runtimeArg->render(args, cmdArgs);
5409 unsigned objcABIVersion = 1;
5411 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
5412 StringRef value = abiArg->getValue();
5415 else if (value ==
"2")
5417 else if (value ==
"3")
5423 bool nonFragileABIIsDefault =
5424 (rewriteKind == RK_NonFragile ||
5425 (rewriteKind == RK_None &&
5427 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5428 options::OPT_fno_objc_nonfragile_abi,
5429 nonFragileABIIsDefault)) {
5431 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 5432 unsigned nonFragileABIVersion = 1;
5434 unsigned nonFragileABIVersion = 2;
5438 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
5439 StringRef value = abiArg->getValue();
5441 nonFragileABIVersion = 1;
5442 else if (value ==
"2")
5443 nonFragileABIVersion = 2;
5449 objcABIVersion = 1 + nonFragileABIVersion;
5457 bool isNonFragile = objcABIVersion != 1;
5463 switch (rewriteKind) {
5476 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5488 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
5498 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
5503 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
5511 bool Asynch =
false;
5512 bool NoUnwindC =
false;
5526 std::vector<std::string> EHArgs =
5527 Args.getAllArgValues(options::OPT__SLASH_EH);
5528 for (
auto EHVal : EHArgs) {
5529 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
5547 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
5553 if (EHArgs.empty() &&
5554 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
5557 EH.NoUnwindC =
true;
5563 void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
5564 ArgStringList &CmdArgs,
5566 bool *EmitCodeView)
const {
5567 unsigned RTOptionID = options::OPT__SLASH_MT;
5569 if (Args.hasArg(options::OPT__SLASH_LDd))
5572 RTOptionID = options::OPT__SLASH_MTd;
5574 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
5575 RTOptionID = A->getOption().getID();
5577 StringRef FlagForCRT;
5578 switch (RTOptionID) {
5579 case options::OPT__SLASH_MD:
5580 if (Args.hasArg(options::OPT__SLASH_LDd))
5581 CmdArgs.push_back(
"-D_DEBUG");
5582 CmdArgs.push_back(
"-D_MT");
5583 CmdArgs.push_back(
"-D_DLL");
5584 FlagForCRT =
"--dependent-lib=msvcrt";
5586 case options::OPT__SLASH_MDd:
5587 CmdArgs.push_back(
"-D_DEBUG");
5588 CmdArgs.push_back(
"-D_MT");
5589 CmdArgs.push_back(
"-D_DLL");
5590 FlagForCRT =
"--dependent-lib=msvcrtd";
5592 case options::OPT__SLASH_MT:
5593 if (Args.hasArg(options::OPT__SLASH_LDd))
5594 CmdArgs.push_back(
"-D_DEBUG");
5595 CmdArgs.push_back(
"-D_MT");
5596 CmdArgs.push_back(
"-flto-visibility-public-std");
5597 FlagForCRT =
"--dependent-lib=libcmt";
5599 case options::OPT__SLASH_MTd:
5600 CmdArgs.push_back(
"-D_DEBUG");
5601 CmdArgs.push_back(
"-D_MT");
5602 CmdArgs.push_back(
"-flto-visibility-public-std");
5603 FlagForCRT =
"--dependent-lib=libcmtd";
5606 llvm_unreachable(
"Unexpected option ID.");
5609 if (Args.hasArg(options::OPT__SLASH_Zl)) {
5610 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
5612 CmdArgs.push_back(FlagForCRT.data());
5617 CmdArgs.push_back(
"--dependent-lib=oldnames");
5620 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5621 A->render(Args, CmdArgs);
5624 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5626 CmdArgs.push_back(
"-fno-rtti-data");
5630 if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
5632 CmdArgs.push_back(
"-stack-protector");
5637 if (Arg *DebugInfoArg =
5638 Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
5639 options::OPT_gline_tables_only)) {
5640 *EmitCodeView =
true;
5641 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
5646 *EmitCodeView =
false;
5651 if (EH.Synch || EH.Asynch) {
5653 CmdArgs.push_back(
"-fcxx-exceptions");
5654 CmdArgs.push_back(
"-fexceptions");
5656 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
5657 CmdArgs.push_back(
"-fexternc-nounwind");
5660 if (Args.hasArg(options::OPT__SLASH_EP)) {
5661 CmdArgs.push_back(
"-E");
5662 CmdArgs.push_back(
"-P");
5665 unsigned VolatileOptionID;
5666 if (
getToolChain().getArch() == llvm::Triple::x86_64 ||
5668 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5670 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5672 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5673 VolatileOptionID = A->getOption().getID();
5675 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5676 CmdArgs.push_back(
"-fms-volatile");
5678 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
5679 options::OPT__SLASH_Zc_dllexportInlines,
5681 if (Args.hasArg(options::OPT__SLASH_fallback)) {
5682 D.
Diag(clang::diag::err_drv_dllexport_inlines_and_fallback);
5684 CmdArgs.push_back(
"-fno-dllexport-inlines");
5688 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5689 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5690 if (MostGeneralArg && BestCaseArg)
5691 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5692 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5694 if (MostGeneralArg) {
5695 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5696 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5697 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5699 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5700 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5701 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5702 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5703 << FirstConflict->getAsString(Args)
5704 << SecondConflict->getAsString(Args);
5707 CmdArgs.push_back(
"-fms-memptr-rep=single");
5708 else if (MultipleArg)
5709 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
5711 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
5716 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
5717 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
5718 options::OPT__SLASH_Gregcall)) {
5719 unsigned DCCOptId = CCArg->getOption().getID();
5720 const char *DCCFlag =
nullptr;
5721 bool ArchSupported =
true;
5724 case options::OPT__SLASH_Gd:
5725 DCCFlag =
"-fdefault-calling-conv=cdecl";
5727 case options::OPT__SLASH_Gr:
5728 ArchSupported = Arch == llvm::Triple::x86;
5729 DCCFlag =
"-fdefault-calling-conv=fastcall";
5731 case options::OPT__SLASH_Gz:
5732 ArchSupported = Arch == llvm::Triple::x86;
5733 DCCFlag =
"-fdefault-calling-conv=stdcall";
5735 case options::OPT__SLASH_Gv:
5736 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
5737 DCCFlag =
"-fdefault-calling-conv=vectorcall";
5739 case options::OPT__SLASH_Gregcall:
5740 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
5741 DCCFlag =
"-fdefault-calling-conv=regcall";
5746 if (ArchSupported && DCCFlag)
5747 CmdArgs.push_back(DCCFlag);
5750 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5751 A->render(Args, CmdArgs);
5753 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5754 CmdArgs.push_back(
"-fdiagnostics-format");
5755 if (Args.hasArg(options::OPT__SLASH_fallback))
5756 CmdArgs.push_back(
"msvc-fallback");
5758 CmdArgs.push_back(
"msvc");
5761 if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
5763 StringRef(A->getValue()).split(SplitArgs,
",");
5764 bool Instrument =
false;
5765 bool NoChecks =
false;
5766 for (StringRef Arg : SplitArgs) {
5767 if (Arg.equals_lower(
"cf"))
5769 else if (Arg.equals_lower(
"cf-"))
5771 else if (Arg.equals_lower(
"nochecks"))
5773 else if (Arg.equals_lower(
"nochecks-"))
5776 D.
Diag(diag::err_drv_invalid_value) << A->getSpelling() << Arg;
5780 if (Instrument || NoChecks)
5781 CmdArgs.push_back(
"-cfguard");
5788 return CLFallback.get();
5794 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
5801 if (
const char *
End = strrchr(Str,
'.'))
5802 return Args.MakeArgString(std::string(Str,
End));
5812 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
5813 std::string Str(OutputOpt->getValue());
5814 Res = Str.substr(0, Str.rfind(
'.'));
5818 return Args.MakeArgString(Res +
".d");
5824 ArgStringList &CmdArgs)
const {
5830 CmdArgs.push_back(
"-target-abi");
5831 CmdArgs.push_back(ABIName.data());
5835 ArgStringList &CmdArgs)
const {
5836 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
5837 StringRef
Value = A->getValue();
5838 if (Value ==
"intel" || Value ==
"att") {
5839 CmdArgs.push_back(
"-mllvm");
5840 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
5843 << A->getOption().getName() <<
Value;
5850 const ArgList &Args,
5851 const char *LinkingOutput)
const {
5852 ArgStringList CmdArgs;
5854 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
5858 const std::string &TripleStr = Triple.getTriple();
5862 Args.ClaimAllArgs(options::OPT_w);
5864 Args.ClaimAllArgs(options::OPT_emit_llvm);
5871 CmdArgs.push_back(
"-cc1as");
5874 CmdArgs.push_back(
"-triple");
5875 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5879 CmdArgs.push_back(
"-filetype");
5880 CmdArgs.push_back(
"obj");
5884 CmdArgs.push_back(
"-main-file-name");
5888 std::string CPU =
getCPUName(Args, Triple,
true);
5890 CmdArgs.push_back(
"-target-cpu");
5891 CmdArgs.push_back(Args.MakeArgString(CPU));
5898 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5901 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5904 const Action *SourceAction = &JA;
5906 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
5907 SourceAction = SourceAction->
getInputs()[0];
5912 bool WantDebug =
false;
5913 unsigned DwarfVersion = 0;
5914 Args.ClaimAllArgs(options::OPT_g_Group);
5915 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
5916 WantDebug = !A->getOption().matches(options::OPT_g0) &&
5917 !A->getOption().matches(options::OPT_ggdb0);
5921 if (DwarfVersion == 0)
5926 if (SourceAction->
getType() == types::TY_Asm ||
5927 SourceAction->
getType() == types::TY_PP_Asm) {
5941 CmdArgs.push_back(
"-dwarf-debug-producer");
5945 Args.AddAllArgs(CmdArgs, options::OPT_I);
5948 llvm::DebuggerKind::Default);
5954 llvm::Reloc::Model RelocationModel;
5957 std::tie(RelocationModel, PICLevel, IsPIE) =
5962 CmdArgs.push_back(
"-mrelocation-model");
5963 CmdArgs.push_back(RMName);
5969 ArgStringList OriginalArgs;
5970 for (
const auto &Arg : Args)
5971 Arg->render(Args, OriginalArgs);
5976 for (
const char *OriginalArg : OriginalArgs) {
5980 Flags += EscapedArg;
5982 CmdArgs.push_back(
"-dwarf-debug-flags");
5983 CmdArgs.push_back(Args.MakeArgString(Flags));
5993 case llvm::Triple::mips:
5994 case llvm::Triple::mipsel:
5995 case llvm::Triple::mips64:
5996 case llvm::Triple::mips64el:
5997 AddMIPSTargetArgs(Args, CmdArgs);
6000 case llvm::Triple::x86:
6001 case llvm::Triple::x86_64:
6002 AddX86TargetArgs(Args, CmdArgs);
6005 case llvm::Triple::arm:
6006 case llvm::Triple::armeb:
6007 case llvm::Triple::thumb:
6008 case llvm::Triple::thumbeb:
6011 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
6012 options::OPT_mno_default_build_attributes,
true)) {
6013 CmdArgs.push_back(
"-mllvm");
6014 CmdArgs.push_back(
"-arm-add-build-attributes");
6024 Args.ClaimAllArgs(options::OPT_W_Group);
6029 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
6031 assert(Output.
isFilename() &&
"Unexpected lipo output.");
6032 CmdArgs.push_back(
"-o");
6038 (T.isOSLinux() || T.isOSFuchsia())) {
6039 CmdArgs.push_back(
"-split-dwarf-file");
6043 assert(Input.isFilename() &&
"Invalid input.");
6044 CmdArgs.push_back(Input.getFilename());
6047 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6055 const llvm::opt::ArgList &TCArgs,
6056 const char *LinkingOutput)
const {
6058 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
6066 ArgStringList CmdArgs;
6069 CmdArgs.push_back(TCArgs.MakeArgString(
6072 assert(JA.
getInputs().size() == Inputs.size() &&
6073 "Not have inputs for all dependence actions??");
6077 Triples +=
"-targets=";
6078 for (
unsigned I = 0; I < Inputs.size(); ++I) {
6087 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
6089 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
6090 assert(CurTC ==
nullptr &&
"Expected one dependence!");
6097 Triples += CurTC->
getTriple().normalize();
6103 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
6107 TCArgs.MakeArgString(Twine(
"-outputs=") + Output.
getFilename()));
6112 for (
unsigned I = 0; I < Inputs.size(); ++I) {
6118 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
6120 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
6121 assert(CurTC ==
nullptr &&
"Expected one dependence!");
6127 CmdArgs.push_back(TCArgs.MakeArgString(UB));
6138 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
6139 const char *LinkingOutput)
const {
6141 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
6150 ArgStringList CmdArgs;
6152 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
6156 CmdArgs.push_back(TCArgs.MakeArgString(
6161 Triples +=
"-targets=";
6162 auto DepInfo = UA.getDependentActionsInfo();
6163 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
6167 auto &Dep = DepInfo[I];
6170 Triples += Dep.DependentToolChain->getTriple().normalize();
6172 !Dep.DependentBoundArch.empty()) {
6174 Triples += Dep.DependentBoundArch;
6178 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
6182 TCArgs.MakeArgString(Twine(
"-inputs=") + Input.getFilename()));
6187 for (
unsigned I = 0; I < Outputs.size(); ++I) {
6190 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
6192 CmdArgs.push_back(TCArgs.MakeArgString(UB));
6193 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.
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.
bool embedBitcodeEnabled() const
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...
Distro - Helper class for detecting and classifying Linux distributions.
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)
Emit location information but do not generate debug info in the output.
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)
Scope - A scope is a transient data structure that is used while parsing the program.
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)
llvm::vfs::FileSystem & getVFS() const
static std::tuple< StringRef, StringRef, bool > ParseAArch64BranchProtection(const Driver &D, const ArgList &Args, const Arg *A)
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 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.
static DwarfFissionKind getDebugFissionKind(const Driver &D, const ArgList &Args, Arg *&Arg)
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 only debug directives with the line numbers data.
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.
ID getPrecompiledType(ID Id)
getPrecompiledType - Get the ID of the type for this input when it has been precompiled, or INVALID if this input is not precompiled.
bool 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.
static void RenderTrivialAutoVarInitOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
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.
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, DwarfFissionKind &DwarfFission)
const char * getOffloadingArch() const
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
const list_type & getJobs() const
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.