27 #include "clang/Config/config.h" 32 #include "llvm/ADT/StringExtras.h" 33 #include "llvm/Option/ArgList.h" 34 #include "llvm/Support/CodeGen.h" 35 #include "llvm/Support/Compression.h" 36 #include "llvm/Support/FileSystem.h" 37 #include "llvm/Support/Path.h" 38 #include "llvm/Support/Process.h" 39 #include "llvm/Support/TargetParser.h" 40 #include "llvm/Support/YAMLParser.h" 48 using namespace clang;
53 Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
54 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
55 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
56 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
57 << A->getBaseArg().getAsString(Args)
58 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
65 if (Args.hasArg(options::OPT_static))
67 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
68 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
93 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
98 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
114 Res.push_back(Target[i]);
123 llvm::function_ref<
void(
const ToolChain &)> Work) {
125 Work(RegularToolChain);
136 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
151 const Arg &A,
size_t &Position) {
152 const char RefinementStepToken =
':';
153 Position = In.find(RefinementStepToken);
154 if (Position != StringRef::npos) {
155 StringRef Option = A.getOption().getName();
156 StringRef RefStep = In.substr(Position + 1);
164 if (RefStep.size() != 1) {
165 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
168 char RefStepChar = RefStep[0];
169 if (RefStepChar < '0' || RefStepChar >
'9') {
170 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
179 ArgStringList &OutStrings) {
180 StringRef DisabledPrefixIn =
"!";
181 StringRef DisabledPrefixOut =
"!";
182 StringRef EnabledPrefixOut =
"";
183 StringRef Out =
"-mrecip=";
185 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
189 unsigned NumOptions = A->getNumValues();
190 if (NumOptions == 0) {
192 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
197 if (NumOptions == 1) {
198 StringRef Val = A->getValue(0);
202 StringRef ValBase = Val.slice(0, RefStepLoc);
203 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
204 OutStrings.push_back(Args.MakeArgString(Out + Val));
213 llvm::StringMap<bool> OptionStrings;
214 OptionStrings.insert(std::make_pair(
"divd",
false));
215 OptionStrings.insert(std::make_pair(
"divf",
false));
216 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
217 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
218 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
219 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
220 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
221 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
223 for (
unsigned i = 0; i != NumOptions; ++i) {
224 StringRef Val = A->getValue(i);
226 bool IsDisabled = Val.startswith(DisabledPrefixIn);
235 StringRef ValBase = Val.slice(0, RefStep);
236 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
237 if (OptionIter == OptionStrings.end()) {
239 OptionIter = OptionStrings.find(ValBase.str() +
'f');
240 if (OptionIter == OptionStrings.end()) {
242 D.
Diag(diag::err_drv_unknown_argument) << Val;
248 if (OptionStrings[ValBase.str() +
'd']) {
249 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
254 if (OptionIter->second ==
true) {
256 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
261 OptionIter->second =
true;
264 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
265 OptionStrings[ValBase.str() +
'd'] =
true;
268 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
269 Out = Args.MakeArgString(Out + Prefix + Val);
270 if (i != NumOptions - 1)
271 Out = Args.MakeArgString(Out +
",");
274 OutStrings.push_back(Args.MakeArgString(Out));
280 ArgStringList &CmdArgs) {
281 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
285 StringRef
Value = A->getValue();
286 if (Value ==
"none") {
287 CmdArgs.push_back(
"-mprefer-vector-width=none");
290 if (Value.getAsInteger(10, Width)) {
291 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
294 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + Value));
299 std::vector<StringRef> &Features) {
304 const ArgList &Args, ArgStringList &CmdArgs,
307 std::vector<StringRef> Features;
308 switch (Triple.getArch()) {
311 case llvm::Triple::mips:
312 case llvm::Triple::mipsel:
313 case llvm::Triple::mips64:
314 case llvm::Triple::mips64el:
318 case llvm::Triple::arm:
319 case llvm::Triple::armeb:
320 case llvm::Triple::thumb:
321 case llvm::Triple::thumbeb:
325 case llvm::Triple::ppc:
326 case llvm::Triple::ppc64:
327 case llvm::Triple::ppc64le:
330 case llvm::Triple::systemz:
333 case llvm::Triple::aarch64:
334 case llvm::Triple::aarch64_be:
337 case llvm::Triple::x86:
338 case llvm::Triple::x86_64:
341 case llvm::Triple::hexagon:
344 case llvm::Triple::wasm32:
345 case llvm::Triple::wasm64:
348 case llvm::Triple::sparc:
349 case llvm::Triple::sparcel:
350 case llvm::Triple::sparcv9:
353 case llvm::Triple::r600:
354 case llvm::Triple::amdgcn:
360 llvm::StringMap<unsigned> LastOpt;
361 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
362 StringRef Name = Features[I];
363 assert(Name[0] ==
'-' || Name[0] ==
'+');
364 LastOpt[Name.drop_front(1)] = I;
367 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
369 StringRef Name = Features[I];
370 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
371 assert(LastI != LastOpt.end());
372 unsigned Last = LastI->second;
376 CmdArgs.push_back(
"-target-feature");
377 CmdArgs.push_back(Name.data());
383 const llvm::Triple &Triple) {
390 if (!Triple.isMacOSX())
393 return (!Triple.isMacOSXVersionLT(10, 5) &&
394 (Triple.getArch() == llvm::Triple::x86_64 ||
395 Triple.getArch() == llvm::Triple::arm));
405 ArgStringList &CmdArgs) {
407 const llvm::Triple &Triple = TC.
getTriple();
412 Args.ClaimAllArgs(options::OPT_fexceptions);
413 Args.ClaimAllArgs(options::OPT_fno_exceptions);
414 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
415 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
416 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
417 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
422 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
428 Args.hasFlag(options::OPT_fobjc_exceptions,
429 options::OPT_fno_objc_exceptions,
true)) {
430 CmdArgs.push_back(
"-fobjc-exceptions");
437 bool CXXExceptionsEnabled =
438 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
439 Arg *ExceptionArg = Args.getLastArg(
440 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
441 options::OPT_fexceptions, options::OPT_fno_exceptions);
443 CXXExceptionsEnabled =
444 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
445 ExceptionArg->getOption().matches(options::OPT_fexceptions);
447 if (CXXExceptionsEnabled) {
448 if (Triple.isPS4CPU()) {
450 assert(ExceptionArg &&
451 "On the PS4 exceptions should only be enabled if passing " 455 assert(RTTIArg &&
"RTTI disabled explicitly but no RTTIArg!");
456 D.
Diag(diag::err_drv_argument_not_allowed_with)
457 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
459 D.
Diag(diag::warn_drv_enabling_rtti_with_exceptions);
463 CmdArgs.push_back(
"-fcxx-exceptions");
470 CmdArgs.push_back(
"-fexceptions");
480 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
486 bool UseDwarfDirectory =
487 Args.hasFlag(options::OPT_fdwarf_directory_asm,
489 return !UseDwarfDirectory;
495 assert(A.getOption().matches(options::OPT_gN_Group) &&
496 "Not a -g option that specifies a debug-info level");
497 if (A.getOption().matches(options::OPT_g0) ||
498 A.getOption().matches(options::OPT_ggdb0))
500 if (A.getOption().matches(options::OPT_gline_tables_only) ||
501 A.getOption().matches(options::OPT_ggdb1))
507 switch (Triple.getArch()){
510 case llvm::Triple::arm:
511 case llvm::Triple::thumb:
514 return Triple.isOSDarwin();
519 const llvm::Triple &Triple) {
520 switch (Triple.getArch()) {
521 case llvm::Triple::xcore:
522 case llvm::Triple::wasm32:
523 case llvm::Triple::wasm64:
531 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI) {
532 switch (Triple.getArch()) {
534 case llvm::Triple::mips64:
535 case llvm::Triple::mips64el:
536 case llvm::Triple::mips:
537 case llvm::Triple::mipsel:
538 case llvm::Triple::ppc:
539 case llvm::Triple::ppc64:
540 case llvm::Triple::ppc64le:
541 case llvm::Triple::systemz:
542 case llvm::Triple::x86:
543 case llvm::Triple::x86_64:
550 if (Triple.isOSWindows()) {
551 switch (Triple.getArch()) {
552 case llvm::Triple::x86:
554 case llvm::Triple::x86_64:
555 return Triple.isOSBinFormatMachO();
556 case llvm::Triple::arm:
557 case llvm::Triple::thumb:
571 const llvm::Triple &Triple) {
572 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
573 options::OPT_fomit_frame_pointer))
574 return A->getOption().matches(options::OPT_fno_omit_frame_pointer) ||
577 if (Args.hasArg(options::OPT_pg))
584 const llvm::Triple &Triple) {
585 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
586 options::OPT_momit_leaf_frame_pointer))
587 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
589 if (Args.hasArg(options::OPT_pg))
592 if (Triple.isPS4CPU())
601 if (!llvm::sys::fs::current_path(cwd)) {
602 CmdArgs.push_back(
"-fdebug-compilation-dir");
603 CmdArgs.push_back(Args.MakeArgString(cwd));
610 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
611 if (A->getOption().matches(options::OPT_O4) ||
612 A->getOption().matches(options::OPT_Ofast))
615 if (A->getOption().matches(options::OPT_O0))
618 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
621 StringRef S(A->getValue());
629 unsigned OptLevel = 0;
630 if (S.getAsInteger(10, OptLevel))
641 ArgStringList &CmdArgs) {
644 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
647 CmdArgs.push_back(
"-x");
648 if (Args.hasArg(options::OPT_rewrite_objc))
654 const char *ClangType;
656 case types::TY_CXXModule:
659 case types::TY_PP_CXXModule:
660 ClangType =
"c++-cpp-output";
666 CmdArgs.push_back(ClangType);
672 const char *Username = getenv(
"LOGNAME");
674 const char *Username = getenv(
"USERNAME");
679 for (
const char *
P = Username; *
P; ++
P, ++Len) {
686 if (Username && Len > 0) {
687 Result.append(Username, Username + Len);
694 std::string UID = llvm::utostr(getuid());
697 std::string UID =
"9999";
699 Result.append(UID.begin(), UID.end());
703 const InputInfo &Output,
const ArgList &Args,
704 ArgStringList &CmdArgs) {
706 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
707 options::OPT_fprofile_generate_EQ,
708 options::OPT_fno_profile_generate);
709 if (PGOGenerateArg &&
710 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
711 PGOGenerateArg =
nullptr;
713 auto *ProfileGenerateArg = Args.getLastArg(
714 options::OPT_fprofile_instr_generate,
715 options::OPT_fprofile_instr_generate_EQ,
716 options::OPT_fno_profile_instr_generate);
717 if (ProfileGenerateArg &&
718 ProfileGenerateArg->getOption().matches(
719 options::OPT_fno_profile_instr_generate))
720 ProfileGenerateArg =
nullptr;
722 if (PGOGenerateArg && ProfileGenerateArg)
723 D.
Diag(diag::err_drv_argument_not_allowed_with)
724 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
728 if (PGOGenerateArg && ProfileUseArg)
729 D.
Diag(diag::err_drv_argument_not_allowed_with)
730 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
732 if (ProfileGenerateArg && ProfileUseArg)
733 D.
Diag(diag::err_drv_argument_not_allowed_with)
734 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
736 if (ProfileGenerateArg) {
737 if (ProfileGenerateArg->getOption().matches(
738 options::OPT_fprofile_instr_generate_EQ))
739 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
740 ProfileGenerateArg->getValue()));
742 CmdArgs.push_back(
"-fprofile-instrument=clang");
745 if (PGOGenerateArg) {
746 CmdArgs.push_back(
"-fprofile-instrument=llvm");
747 if (PGOGenerateArg->getOption().matches(
748 options::OPT_fprofile_generate_EQ)) {
750 llvm::sys::path::append(Path,
"default_%m.profraw");
752 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
757 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
758 CmdArgs.push_back(Args.MakeArgString(
759 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
760 else if ((ProfileUseArg->getOption().matches(
761 options::OPT_fprofile_use_EQ) ||
762 ProfileUseArg->getOption().matches(
763 options::OPT_fprofile_instr_use))) {
765 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
766 if (Path.empty() || llvm::sys::fs::is_directory(Path))
767 llvm::sys::path::append(Path,
"default.profdata");
769 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
773 if (Args.hasArg(options::OPT_ftest_coverage) ||
774 Args.hasArg(options::OPT_coverage))
775 CmdArgs.push_back(
"-femit-coverage-notes");
776 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
778 Args.hasArg(options::OPT_coverage))
779 CmdArgs.push_back(
"-femit-coverage-data");
781 if (Args.hasFlag(options::OPT_fcoverage_mapping,
782 options::OPT_fno_coverage_mapping,
false)) {
783 if (!ProfileGenerateArg)
784 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
785 <<
"-fcoverage-mapping" 786 <<
"-fprofile-instr-generate";
788 CmdArgs.push_back(
"-fcoverage-mapping");
791 if (C.
getArgs().hasArg(options::OPT_c) ||
792 C.
getArgs().hasArg(options::OPT_S)) {
794 CmdArgs.push_back(
"-coverage-notes-file");
796 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
797 OutputFilename = FinalOutput->getValue();
799 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
801 if (llvm::sys::path::is_relative(CoverageFilename)) {
803 if (!llvm::sys::fs::current_path(Pwd)) {
804 llvm::sys::path::append(Pwd, CoverageFilename);
805 CoverageFilename.swap(Pwd);
808 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
809 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
815 if (Args.hasArg(options::OPT_fprofile_arcs) ||
816 Args.hasArg(options::OPT_coverage)) {
817 CmdArgs.push_back(
"-coverage-data-file");
818 if (Arg *FProfileDir = Args.getLastArg(options::OPT_fprofile_dir)) {
819 CoverageFilename = FProfileDir->getValue();
820 llvm::sys::path::append(CoverageFilename, OutputFilename);
822 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
823 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
831 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
834 for (
const auto &AI : A->
inputs())
844 bool RelaxDefault =
true;
846 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
847 RelaxDefault = A->getOption().matches(options::OPT_O0);
850 RelaxDefault =
false;
859 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
867 return llvm::StringSwitch<unsigned>(ArgValue)
868 .Case(
"-gdwarf-2", 2)
869 .Case(
"-gdwarf-3", 3)
870 .Case(
"-gdwarf-4", 4)
871 .Case(
"-gdwarf-5", 5)
877 unsigned DwarfVersion,
878 llvm::DebuggerKind DebuggerTuning) {
879 switch (DebugInfoKind) {
881 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
884 CmdArgs.push_back(
"-debug-info-kind=limited");
887 CmdArgs.push_back(
"-debug-info-kind=standalone");
892 if (DwarfVersion > 0)
894 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
895 switch (DebuggerTuning) {
896 case llvm::DebuggerKind::GDB:
897 CmdArgs.push_back(
"-debugger-tuning=gdb");
899 case llvm::DebuggerKind::LLDB:
900 CmdArgs.push_back(
"-debugger-tuning=lldb");
902 case llvm::DebuggerKind::SCE:
903 CmdArgs.push_back(
"-debugger-tuning=sce");
911 ArgStringList &CmdArgs,
913 const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ);
917 if (A->getOption().getID() == options::OPT_gz) {
918 if (llvm::zlib::isAvailable())
919 CmdArgs.push_back(
"-compress-debug-sections");
921 D.
Diag(diag::warn_debug_compression_unavailable);
925 StringRef
Value = A->getValue();
926 if (Value ==
"none") {
927 CmdArgs.push_back(
"-compress-debug-sections=none");
928 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
929 if (llvm::zlib::isAvailable()) {
931 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
933 D.
Diag(diag::warn_debug_compression_unavailable);
936 D.
Diag(diag::err_drv_unsupported_option_argument)
937 << A->getOption().getName() <<
Value;
943 case llvm::Reloc::Static:
945 case llvm::Reloc::PIC_:
947 case llvm::Reloc::DynamicNoPIC:
948 return "dynamic-no-pic";
949 case llvm::Reloc::ROPI:
951 case llvm::Reloc::RWPI:
953 case llvm::Reloc::ROPI_RWPI:
956 llvm_unreachable(
"Unknown Reloc::Model kind");
960 const Driver &D,
const ArgList &Args,
961 ArgStringList &CmdArgs,
965 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
969 Args.AddLastArg(CmdArgs, options::OPT_C);
970 Args.AddLastArg(CmdArgs, options::OPT_CC);
973 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
974 (A = Args.getLastArg(options::OPT_MD)) ||
975 (A = Args.getLastArg(options::OPT_MMD))) {
978 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
979 DepFile = MF->getValue();
981 }
else if (Output.
getType() == types::TY_Dependencies) {
983 }
else if (A->getOption().matches(options::OPT_M) ||
984 A->getOption().matches(options::OPT_MM)) {
987 DepFile = getDependencyFileName(Args, Inputs);
990 CmdArgs.push_back(
"-dependency-file");
991 CmdArgs.push_back(DepFile);
994 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
995 const char *DepTarget;
999 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1000 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1001 DepTarget = OutputOpt->getValue();
1007 llvm::sys::path::replace_extension(P,
"o");
1008 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1011 if (!A->getOption().matches(options::OPT_MD) && !A->getOption().matches(options::OPT_MMD)) {
1012 CmdArgs.push_back(
"-w");
1014 CmdArgs.push_back(
"-MT");
1017 CmdArgs.push_back(Args.MakeArgString(Quoted));
1020 if (A->getOption().matches(options::OPT_M) ||
1021 A->getOption().matches(options::OPT_MD))
1022 CmdArgs.push_back(
"-sys-header-deps");
1023 if ((isa<PrecompileJobAction>(JA) &&
1024 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1025 Args.hasArg(options::OPT_fmodule_file_deps))
1026 CmdArgs.push_back(
"-module-file-deps");
1029 if (Args.hasArg(options::OPT_MG)) {
1030 if (!A || A->getOption().matches(options::OPT_MD) ||
1031 A->getOption().matches(options::OPT_MMD))
1032 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1033 CmdArgs.push_back(
"-MG");
1036 Args.AddLastArg(CmdArgs, options::OPT_MP);
1037 Args.AddLastArg(CmdArgs, options::OPT_MV);
1040 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1043 if (A->getOption().matches(options::OPT_MQ)) {
1044 CmdArgs.push_back(
"-MT");
1047 CmdArgs.push_back(Args.MakeArgString(Quoted));
1051 A->render(Args, CmdArgs);
1060 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1067 int YcIndex = -1, YuIndex = -1;
1070 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1071 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1072 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1076 if (!A->getOption().matches(options::OPT_include))
1078 if (YcArg && strcmp(A->getValue(), YcArg->getValue()) == 0)
1080 if (YuArg && strcmp(A->getValue(), YuArg->getValue()) == 0)
1084 if (isa<PrecompileJobAction>(JA) && YcIndex != -1) {
1087 assert(Inputs.size() == 1 &&
"Need one input when building pch");
1088 CmdArgs.push_back(Args.MakeArgString(Twine(
"-find-pch-source=") +
1089 Inputs[0].second->getValue()));
1092 bool RenderedImplicitInclude =
false;
1094 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1097 if (getToolChain().getDriver().IsCLMode() &&
1098 A->getOption().matches(options::OPT_include)) {
1111 int PchIndex = YcIndex != -1 ? YcIndex : YuIndex;
1112 if (PchIndex != -1) {
1113 if (isa<PrecompileJobAction>(JA)) {
1115 assert(YcIndex != -1 && PchIndex == YcIndex);
1120 if (AI < PchIndex) {
1124 if (AI == PchIndex) {
1126 CmdArgs.push_back(
"-include-pch");
1133 }
else if (A->getOption().matches(options::OPT_include)) {
1135 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1136 RenderedImplicitInclude =
true;
1141 bool FoundPTH =
false;
1142 bool FoundPCH =
false;
1148 llvm::sys::path::replace_extension(P,
"pch");
1149 if (llvm::sys::fs::exists(P))
1154 llvm::sys::path::replace_extension(P,
"pth");
1155 if (llvm::sys::fs::exists(P))
1159 if (!FoundPCH && !FoundPTH) {
1160 llvm::sys::path::replace_extension(P,
"gch");
1161 if (llvm::sys::fs::exists(P)) {
1167 if (FoundPCH || FoundPTH) {
1168 if (IsFirstImplicitInclude) {
1171 CmdArgs.push_back(
"-include-pch");
1173 CmdArgs.push_back(
"-include-pth");
1174 CmdArgs.push_back(Args.MakeArgString(P));
1178 D.
Diag(diag::warn_drv_pch_not_first_include) << P
1179 << A->getAsString(Args);
1182 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1193 A->render(Args, CmdArgs);
1196 Args.AddAllArgs(CmdArgs,
1197 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1198 options::OPT_F, options::OPT_index_header_map});
1206 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1207 options::OPT_Xpreprocessor);
1210 if (Arg *A = Args.getLastArg(options::OPT_I_))
1211 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1216 if (sysroot !=
"") {
1217 if (!Args.hasArg(options::OPT_isysroot)) {
1218 CmdArgs.push_back(
"-isysroot");
1219 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
1236 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1245 [&Args, &CmdArgs](
const ToolChain &TC) {
1252 [&Args, &CmdArgs](
const ToolChain &TC) {
1257 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1263 switch (Triple.getArch()) {
1267 case llvm::Triple::aarch64:
1268 case llvm::Triple::aarch64_be:
1269 case llvm::Triple::arm:
1270 case llvm::Triple::armeb:
1271 case llvm::Triple::thumb:
1272 case llvm::Triple::thumbeb:
1273 if (Triple.isOSDarwin() || Triple.isOSWindows())
1277 case llvm::Triple::ppc:
1278 case llvm::Triple::ppc64:
1279 if (Triple.isOSDarwin())
1283 case llvm::Triple::hexagon:
1284 case llvm::Triple::ppc64le:
1285 case llvm::Triple::systemz:
1286 case llvm::Triple::xcore:
1292 switch (Triple.getArch()) {
1296 case llvm::Triple::xcore:
1297 case llvm::Triple::wasm32:
1298 case llvm::Triple::wasm64:
1303 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1304 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1308 const char *ABIName =
nullptr;
1309 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1310 ABIName = A->getValue();
1312 std::string CPU =
getCPUName(Args, Triple,
false);
1313 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1316 CmdArgs.push_back(
"-target-abi");
1317 CmdArgs.push_back(ABIName);
1324 CmdArgs.push_back(
"-msoft-float");
1325 CmdArgs.push_back(
"-mfloat-abi");
1326 CmdArgs.push_back(
"soft");
1329 CmdArgs.push_back(
"-mfloat-abi");
1330 CmdArgs.push_back(
"soft");
1334 CmdArgs.push_back(
"-mfloat-abi");
1335 CmdArgs.push_back(
"hard");
1339 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1340 options::OPT_mno_global_merge)) {
1341 CmdArgs.push_back(
"-backend-option");
1342 if (A->getOption().matches(options::OPT_mno_global_merge))
1343 CmdArgs.push_back(
"-arm-global-merge=false");
1345 CmdArgs.push_back(
"-arm-global-merge=true");
1348 if (!Args.hasFlag(options::OPT_mimplicit_float,
1349 options::OPT_mno_implicit_float,
true))
1350 CmdArgs.push_back(
"-no-implicit-float");
1353 void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1354 const ArgList &Args,
bool KernelOrKext,
1355 ArgStringList &CmdArgs)
const {
1366 case llvm::Triple::arm:
1367 case llvm::Triple::armeb:
1368 case llvm::Triple::thumb:
1369 case llvm::Triple::thumbeb:
1371 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1372 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1375 case llvm::Triple::aarch64:
1376 case llvm::Triple::aarch64_be:
1377 AddAArch64TargetArgs(Args, CmdArgs);
1378 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1381 case llvm::Triple::mips:
1382 case llvm::Triple::mipsel:
1383 case llvm::Triple::mips64:
1384 case llvm::Triple::mips64el:
1385 AddMIPSTargetArgs(Args, CmdArgs);
1388 case llvm::Triple::ppc:
1389 case llvm::Triple::ppc64:
1390 case llvm::Triple::ppc64le:
1391 AddPPCTargetArgs(Args, CmdArgs);
1394 case llvm::Triple::sparc:
1395 case llvm::Triple::sparcel:
1396 case llvm::Triple::sparcv9:
1397 AddSparcTargetArgs(Args, CmdArgs);
1400 case llvm::Triple::systemz:
1401 AddSystemZTargetArgs(Args, CmdArgs);
1404 case llvm::Triple::x86:
1405 case llvm::Triple::x86_64:
1406 AddX86TargetArgs(Args, CmdArgs);
1409 case llvm::Triple::lanai:
1410 AddLanaiTargetArgs(Args, CmdArgs);
1413 case llvm::Triple::hexagon:
1414 AddHexagonTargetArgs(Args, CmdArgs);
1417 case llvm::Triple::wasm32:
1418 case llvm::Triple::wasm64:
1419 AddWebAssemblyTargetArgs(Args, CmdArgs);
1424 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1425 ArgStringList &CmdArgs)
const {
1426 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1428 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1429 Args.hasArg(options::OPT_mkernel) ||
1430 Args.hasArg(options::OPT_fapple_kext))
1431 CmdArgs.push_back(
"-disable-red-zone");
1433 if (!Args.hasFlag(options::OPT_mimplicit_float,
1434 options::OPT_mno_implicit_float,
true))
1435 CmdArgs.push_back(
"-no-implicit-float");
1437 const char *ABIName =
nullptr;
1438 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1439 ABIName = A->getValue();
1440 else if (Triple.isOSDarwin())
1441 ABIName =
"darwinpcs";
1445 CmdArgs.push_back(
"-target-abi");
1446 CmdArgs.push_back(ABIName);
1448 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1449 options::OPT_mno_fix_cortex_a53_835769)) {
1450 CmdArgs.push_back(
"-backend-option");
1451 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1452 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1454 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1455 }
else if (Triple.isAndroid()) {
1457 CmdArgs.push_back(
"-backend-option");
1458 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1462 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1463 options::OPT_mno_global_merge)) {
1464 CmdArgs.push_back(
"-backend-option");
1465 if (A->getOption().matches(options::OPT_mno_global_merge))
1466 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1468 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1472 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1473 ArgStringList &CmdArgs)
const {
1474 const Driver &D = getToolChain().getDriver();
1477 const llvm::Triple &Triple = getToolChain().getTriple();
1480 CmdArgs.push_back(
"-target-abi");
1481 CmdArgs.push_back(ABIName.data());
1486 CmdArgs.push_back(
"-msoft-float");
1487 CmdArgs.push_back(
"-mfloat-abi");
1488 CmdArgs.push_back(
"soft");
1492 CmdArgs.push_back(
"-mfloat-abi");
1493 CmdArgs.push_back(
"hard");
1496 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1497 if (A->getOption().matches(options::OPT_mxgot)) {
1498 CmdArgs.push_back(
"-mllvm");
1499 CmdArgs.push_back(
"-mxgot");
1503 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1504 options::OPT_mno_ldc1_sdc1)) {
1505 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1506 CmdArgs.push_back(
"-mllvm");
1507 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1511 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1512 options::OPT_mno_check_zero_division)) {
1513 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1514 CmdArgs.push_back(
"-mllvm");
1515 CmdArgs.push_back(
"-mno-check-zero-division");
1519 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1520 StringRef
v = A->getValue();
1521 CmdArgs.push_back(
"-mllvm");
1522 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1526 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1528 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1541 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1543 llvm::Reloc::Model RelocationModel;
1546 std::tie(RelocationModel, PICLevel, IsPIE) =
1549 NoABICalls = NoABICalls ||
1550 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1552 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1554 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1555 CmdArgs.push_back(
"-mllvm");
1556 CmdArgs.push_back(
"-mgpopt");
1558 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1559 options::OPT_mno_local_sdata);
1560 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1561 options::OPT_mno_extern_sdata);
1562 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1563 options::OPT_mno_embedded_data);
1565 CmdArgs.push_back(
"-mllvm");
1566 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1567 CmdArgs.push_back(
"-mlocal-sdata=1");
1569 CmdArgs.push_back(
"-mlocal-sdata=0");
1571 LocalSData->claim();
1575 CmdArgs.push_back(
"-mllvm");
1576 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1577 CmdArgs.push_back(
"-mextern-sdata=1");
1579 CmdArgs.push_back(
"-mextern-sdata=0");
1581 ExternSData->claim();
1585 CmdArgs.push_back(
"-mllvm");
1586 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1587 CmdArgs.push_back(
"-membedded-data=1");
1589 CmdArgs.push_back(
"-membedded-data=0");
1591 EmbeddedData->claim();
1594 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1595 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1600 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1601 StringRef Val = StringRef(A->getValue());
1603 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1604 CmdArgs.push_back(
"-mllvm");
1605 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1607 D.
Diag(diag::err_drv_unsupported_option_argument)
1608 << A->getOption().getName() << Val;
1610 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1614 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1615 ArgStringList &CmdArgs)
const {
1617 const char *ABIName =
nullptr;
1618 if (getToolChain().getTriple().isOSLinux())
1619 switch (getToolChain().getArch()) {
1620 case llvm::Triple::ppc64: {
1624 bool HasQPX =
false;
1625 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1626 HasQPX = A->getValue() == StringRef(
"a2q");
1627 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1629 ABIName =
"elfv1-qpx";
1636 case llvm::Triple::ppc64le:
1643 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1647 if (StringRef(A->getValue()) !=
"altivec")
1648 ABIName = A->getValue();
1655 CmdArgs.push_back(
"-msoft-float");
1656 CmdArgs.push_back(
"-mfloat-abi");
1657 CmdArgs.push_back(
"soft");
1661 CmdArgs.push_back(
"-mfloat-abi");
1662 CmdArgs.push_back(
"hard");
1666 CmdArgs.push_back(
"-target-abi");
1667 CmdArgs.push_back(ABIName);
1671 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1672 ArgStringList &CmdArgs)
const {
1678 CmdArgs.push_back(
"-msoft-float");
1679 CmdArgs.push_back(
"-mfloat-abi");
1680 CmdArgs.push_back(
"soft");
1684 CmdArgs.push_back(
"-mfloat-abi");
1685 CmdArgs.push_back(
"hard");
1689 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
1690 ArgStringList &CmdArgs)
const {
1691 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false))
1692 CmdArgs.push_back(
"-mbackchain");
1695 void Clang::AddX86TargetArgs(
const ArgList &Args,
1696 ArgStringList &CmdArgs)
const {
1697 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1698 Args.hasArg(options::OPT_mkernel) ||
1699 Args.hasArg(options::OPT_fapple_kext))
1700 CmdArgs.push_back(
"-disable-red-zone");
1704 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1705 Args.hasArg(options::OPT_fapple_kext));
1706 if (Arg *A = Args.getLastArg(
1707 options::OPT_msoft_float, options::OPT_mno_soft_float,
1708 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
1709 const Option &O = A->getOption();
1710 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1711 O.matches(options::OPT_msoft_float));
1713 if (NoImplicitFloat)
1714 CmdArgs.push_back(
"-no-implicit-float");
1716 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1717 StringRef
Value = A->getValue();
1718 if (Value ==
"intel" || Value ==
"att") {
1719 CmdArgs.push_back(
"-mllvm");
1720 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
1722 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1723 << A->getOption().getName() <<
Value;
1728 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
1729 CmdArgs.push_back(
"-mfloat-abi");
1730 CmdArgs.push_back(
"soft");
1731 CmdArgs.push_back(
"-mstack-alignment=4");
1735 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
1736 ArgStringList &CmdArgs)
const {
1737 CmdArgs.push_back(
"-mqdsp6-compat");
1738 CmdArgs.push_back(
"-Wreturn-type");
1741 CmdArgs.push_back(
"-mllvm");
1742 CmdArgs.push_back(Args.MakeArgString(
"-hexagon-small-data-threshold=" +
1743 Twine(G.getValue())));
1746 if (!Args.hasArg(options::OPT_fno_short_enums))
1747 CmdArgs.push_back(
"-fshort-enums");
1748 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1749 CmdArgs.push_back(
"-mllvm");
1750 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
1752 CmdArgs.push_back(
"-mllvm");
1753 CmdArgs.push_back(
"-machine-sink-split=0");
1756 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
1757 ArgStringList &CmdArgs)
const {
1758 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1759 StringRef CPUName = A->getValue();
1761 CmdArgs.push_back(
"-target-cpu");
1762 CmdArgs.push_back(Args.MakeArgString(CPUName));
1764 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1765 StringRef
Value = A->getValue();
1769 if (Value.getAsInteger(10, Mregparm)) {
1770 if (Mregparm != 4) {
1771 getToolChain().getDriver().Diag(
1772 diag::err_drv_unsupported_option_argument)
1773 << A->getOption().getName() <<
Value;
1779 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
1780 ArgStringList &CmdArgs)
const {
1782 if (!Args.hasArg(options::OPT_fvisibility_EQ,
1783 options::OPT_fvisibility_ms_compat)) {
1784 CmdArgs.push_back(
"-fvisibility");
1785 CmdArgs.push_back(
"hidden");
1790 StringRef Target,
const InputInfo &Output,
1791 const InputInfo &Input,
const ArgList &Args)
const {
1793 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH))
1796 using llvm::yaml::escape;
1797 const Driver &D = getToolChain().getDriver();
1799 if (!CompilationDatabase) {
1801 auto File = llvm::make_unique<llvm::raw_fd_ostream>(
Filename, EC, llvm::sys::fs::F_Text);
1803 D.
Diag(clang::diag::err_drv_compilationdatabase) << Filename
1807 CompilationDatabase = std::move(File);
1809 auto &CDB = *CompilationDatabase;
1811 if (llvm::sys::fs::current_path(Buf))
1813 CDB <<
"{ \"directory\": \"" << escape(Buf) <<
"\"";
1814 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
1815 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
1819 CDB <<
", \"" << escape(Buf) <<
"\"";
1820 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
1823 CDB <<
", \"" << escape(Buf) <<
"\"";
1825 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
1826 for (
auto &A: Args) {
1827 auto &O = A->getOption();
1829 if (O.getID() == options::OPT_x)
1832 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
1835 if (O.getKind() == Option::InputClass)
1839 A->render(Args, ASL);
1841 CDB <<
", \"" << escape(it) <<
"\"";
1845 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
1849 const ArgList &Args,
1850 ArgStringList &CmdArgs,
1853 CmdArgs.push_back(
"-mrelax-all");
1857 bool DefaultIncrementalLinkerCompatible =
1859 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
1860 options::OPT_mno_incremental_linker_compatible,
1861 DefaultIncrementalLinkerCompatible))
1862 CmdArgs.push_back(
"-mincremental-linker-compatible");
1865 case llvm::Triple::arm:
1866 case llvm::Triple::armeb:
1867 case llvm::Triple::thumb:
1868 case llvm::Triple::thumbeb:
1869 if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) {
1870 StringRef
Value = A->getValue();
1871 if (Value ==
"always" || Value ==
"never" || Value ==
"arm" ||
1873 CmdArgs.push_back(
"-mllvm");
1874 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" + Value));
1876 D.
Diag(diag::err_drv_unsupported_option_argument)
1877 << A->getOption().getName() <<
Value;
1890 bool TakeNextArg =
false;
1893 const char *MipsTargetFeature =
nullptr;
1895 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
1898 for (StringRef
Value : A->getValues()) {
1900 CmdArgs.push_back(
Value.data());
1901 TakeNextArg =
false;
1906 Value ==
"-mbig-obj")
1912 case llvm::Triple::thumb:
1913 case llvm::Triple::thumbeb:
1914 case llvm::Triple::arm:
1915 case llvm::Triple::armeb:
1916 if (
Value ==
"-mthumb")
1921 case llvm::Triple::mips:
1922 case llvm::Triple::mipsel:
1923 case llvm::Triple::mips64:
1924 case llvm::Triple::mips64el:
1925 if (
Value ==
"--trap") {
1926 CmdArgs.push_back(
"-target-feature");
1927 CmdArgs.push_back(
"+use-tcc-in-div");
1930 if (
Value ==
"--break") {
1931 CmdArgs.push_back(
"-target-feature");
1932 CmdArgs.push_back(
"-use-tcc-in-div");
1935 if (
Value.startswith(
"-msoft-float")) {
1936 CmdArgs.push_back(
"-target-feature");
1937 CmdArgs.push_back(
"+soft-float");
1940 if (
Value.startswith(
"-mhard-float")) {
1941 CmdArgs.push_back(
"-target-feature");
1942 CmdArgs.push_back(
"-soft-float");
1946 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
1947 .Case(
"-mips1",
"+mips1")
1948 .Case(
"-mips2",
"+mips2")
1949 .Case(
"-mips3",
"+mips3")
1950 .Case(
"-mips4",
"+mips4")
1951 .Case(
"-mips5",
"+mips5")
1952 .Case(
"-mips32",
"+mips32")
1953 .Case(
"-mips32r2",
"+mips32r2")
1954 .Case(
"-mips32r3",
"+mips32r3")
1955 .Case(
"-mips32r5",
"+mips32r5")
1956 .Case(
"-mips32r6",
"+mips32r6")
1957 .Case(
"-mips64",
"+mips64")
1958 .Case(
"-mips64r2",
"+mips64r2")
1959 .Case(
"-mips64r3",
"+mips64r3")
1960 .Case(
"-mips64r5",
"+mips64r5")
1961 .Case(
"-mips64r6",
"+mips64r6")
1963 if (MipsTargetFeature)
1967 if (
Value ==
"-force_cpusubtype_ALL") {
1969 }
else if (
Value ==
"-L") {
1970 CmdArgs.push_back(
"-msave-temp-labels");
1971 }
else if (
Value ==
"--fatal-warnings") {
1972 CmdArgs.push_back(
"-massembler-fatal-warnings");
1973 }
else if (
Value ==
"--noexecstack") {
1974 CmdArgs.push_back(
"-mnoexecstack");
1975 }
else if (
Value.startswith(
"-compress-debug-sections") ||
1976 Value.startswith(
"--compress-debug-sections") ||
1977 Value ==
"-nocompress-debug-sections" ||
1978 Value ==
"--nocompress-debug-sections") {
1979 CmdArgs.push_back(
Value.data());
1980 }
else if (
Value ==
"-mrelax-relocations=yes" ||
1981 Value ==
"--mrelax-relocations=yes") {
1982 UseRelaxRelocations =
true;
1983 }
else if (
Value ==
"-mrelax-relocations=no" ||
1984 Value ==
"--mrelax-relocations=no") {
1985 UseRelaxRelocations =
false;
1986 }
else if (
Value.startswith(
"-I")) {
1987 CmdArgs.push_back(
Value.data());
1992 }
else if (
Value.startswith(
"-gdwarf-")) {
1995 if (DwarfVersion == 0) {
1996 CmdArgs.push_back(
Value.data());
2000 DwarfVersion, llvm::DebuggerKind::Default);
2002 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2003 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2005 }
else if (
Value ==
"-defsym") {
2006 if (A->getNumValues() != 2) {
2007 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2010 const char *S = A->getValue(1);
2011 auto Pair = StringRef(S).split(
'=');
2012 auto Sym = Pair.first;
2013 auto SVal = Pair.second;
2015 if (Sym.empty() || SVal.empty()) {
2016 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2020 if (SVal.getAsInteger(0, IVal)) {
2021 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2024 CmdArgs.push_back(
Value.data());
2027 D.
Diag(diag::err_drv_unsupported_option_argument)
2028 << A->getOption().getName() <<
Value;
2032 if (UseRelaxRelocations)
2033 CmdArgs.push_back(
"--mrelax-relocations");
2034 if (MipsTargetFeature !=
nullptr) {
2035 CmdArgs.push_back(
"-target-feature");
2036 CmdArgs.push_back(MipsTargetFeature);
2041 bool OFastEnabled,
const ArgList &Args,
2042 ArgStringList &CmdArgs) {
2048 bool HonorINFs =
true;
2049 bool HonorNaNs =
true;
2052 bool AssociativeMath =
false;
2053 bool ReciprocalMath =
false;
2054 bool SignedZeros =
true;
2055 bool TrappingMath =
true;
2056 StringRef DenormalFPMath =
"";
2057 StringRef FPContract =
"";
2059 for (
const Arg *A : Args) {
2060 switch (A->getOption().getID()) {
2065 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2066 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2067 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2068 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2069 case options::OPT_fmath_errno: MathErrno =
true;
break;
2070 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2071 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2072 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2073 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2074 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2075 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2076 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2077 case options::OPT_ftrapping_math: TrappingMath =
true;
break;
2078 case options::OPT_fno_trapping_math: TrappingMath =
false;
break;
2080 case options::OPT_fdenormal_fp_math_EQ:
2081 DenormalFPMath = A->getValue();
2085 case options::OPT_ffp_contract: {
2086 StringRef Val = A->getValue();
2087 if (Val ==
"fast" || Val ==
"on" || Val ==
"off")
2090 D.
Diag(diag::err_drv_unsupported_option_argument)
2091 << A->getOption().getName() << Val;
2095 case options::OPT_ffinite_math_only:
2099 case options::OPT_fno_finite_math_only:
2104 case options::OPT_funsafe_math_optimizations:
2105 AssociativeMath =
true;
2106 ReciprocalMath =
true;
2107 SignedZeros =
false;
2108 TrappingMath =
false;
2110 case options::OPT_fno_unsafe_math_optimizations:
2111 AssociativeMath =
false;
2112 ReciprocalMath =
false;
2114 TrappingMath =
true;
2116 DenormalFPMath =
"";
2119 case options::OPT_Ofast:
2124 case options::OPT_ffast_math:
2128 AssociativeMath =
true;
2129 ReciprocalMath =
true;
2130 SignedZeros =
false;
2131 TrappingMath =
false;
2133 FPContract =
"fast";
2135 case options::OPT_fno_fast_math:
2142 AssociativeMath =
false;
2143 ReciprocalMath =
false;
2145 TrappingMath =
true;
2147 DenormalFPMath =
"";
2157 CmdArgs.push_back(
"-menable-no-infs");
2160 CmdArgs.push_back(
"-menable-no-nans");
2163 CmdArgs.push_back(
"-fmath-errno");
2165 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2167 CmdArgs.push_back(
"-menable-unsafe-fp-math");
2170 CmdArgs.push_back(
"-fno-signed-zeros");
2172 if (AssociativeMath && !SignedZeros && !TrappingMath)
2173 CmdArgs.push_back(
"-mreassociate");
2176 CmdArgs.push_back(
"-freciprocal-math");
2179 CmdArgs.push_back(
"-fno-trapping-math");
2181 if (!DenormalFPMath.empty())
2183 Args.MakeArgString(
"-fdenormal-fp-math=" + DenormalFPMath));
2185 if (!FPContract.empty())
2186 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
2193 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
2194 ReciprocalMath && !SignedZeros && !TrappingMath)
2195 CmdArgs.push_back(
"-ffast-math");
2198 if (!HonorINFs && !HonorNaNs)
2199 CmdArgs.push_back(
"-ffinite-math-only");
2201 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2202 CmdArgs.push_back(
"-mfpmath");
2203 CmdArgs.push_back(A->getValue());
2208 const llvm::Triple &Triple,
2211 CmdArgs.push_back(
"-analyzer-store=region");
2214 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
2216 CmdArgs.push_back(
"-analyzer-eagerly-assume");
2219 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2220 CmdArgs.push_back(
"-analyzer-checker=core");
2221 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
2223 if (!Triple.isWindowsMSVCEnvironment()) {
2224 CmdArgs.push_back(
"-analyzer-checker=unix");
2227 CmdArgs.push_back(
"-analyzer-checker=unix.API");
2228 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
2229 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
2230 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
2231 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
2232 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
2236 if (Triple.isPS4CPU()) {
2237 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
2238 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
2241 if (Triple.isOSDarwin())
2242 CmdArgs.push_back(
"-analyzer-checker=osx");
2244 CmdArgs.push_back(
"-analyzer-checker=deadcode");
2247 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
2249 if (!Triple.isPS4CPU()) {
2250 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
2251 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
2252 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
2253 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
2254 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
2255 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
2259 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
2260 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
2264 CmdArgs.push_back(
"-analyzer-output");
2265 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2266 CmdArgs.push_back(A->getValue());
2268 CmdArgs.push_back(
"plist");
2273 CmdArgs.push_back(
"-w");
2276 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2280 ArgStringList &CmdArgs,
bool KernelOrKext) {
2285 if (EffectiveTriple.isNVPTX())
2289 unsigned StackProtectorLevel = 0;
2290 unsigned DefaultStackProtectorLevel =
2293 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2294 options::OPT_fstack_protector_all,
2295 options::OPT_fstack_protector_strong,
2296 options::OPT_fstack_protector)) {
2297 if (A->getOption().matches(options::OPT_fstack_protector))
2298 StackProtectorLevel =
2300 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
2302 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2305 StackProtectorLevel = DefaultStackProtectorLevel;
2308 if (StackProtectorLevel) {
2309 CmdArgs.push_back(
"-stack-protector");
2310 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2314 for (
const Arg *A : Args.filtered(options::OPT__param)) {
2315 StringRef Str(A->getValue());
2316 if (Str.startswith(
"ssp-buffer-size=")) {
2317 if (StackProtectorLevel) {
2318 CmdArgs.push_back(
"-stack-protector-buffer-size");
2320 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
2328 const unsigned ForwardedArguments[] = {
2329 options::OPT_cl_opt_disable,
2330 options::OPT_cl_strict_aliasing,
2331 options::OPT_cl_single_precision_constant,
2332 options::OPT_cl_finite_math_only,
2333 options::OPT_cl_kernel_arg_info,
2334 options::OPT_cl_unsafe_math_optimizations,
2335 options::OPT_cl_fast_relaxed_math,
2336 options::OPT_cl_mad_enable,
2337 options::OPT_cl_no_signed_zeros,
2338 options::OPT_cl_denorms_are_zero,
2339 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
2342 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
2343 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
2344 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
2347 for (
const auto &Arg : ForwardedArguments)
2348 if (
const auto *A = Args.getLastArg(Arg))
2349 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
2353 ArgStringList &CmdArgs) {
2354 bool ARCMTEnabled =
false;
2355 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2356 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2357 options::OPT_ccc_arcmt_modify,
2358 options::OPT_ccc_arcmt_migrate)) {
2359 ARCMTEnabled =
true;
2360 switch (A->getOption().getID()) {
2361 default: llvm_unreachable(
"missed a case");
2362 case options::OPT_ccc_arcmt_check:
2363 CmdArgs.push_back(
"-arcmt-check");
2365 case options::OPT_ccc_arcmt_modify:
2366 CmdArgs.push_back(
"-arcmt-modify");
2368 case options::OPT_ccc_arcmt_migrate:
2369 CmdArgs.push_back(
"-arcmt-migrate");
2370 CmdArgs.push_back(
"-mt-migrate-directory");
2371 CmdArgs.push_back(A->getValue());
2373 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2374 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2379 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2380 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2381 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2384 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2386 D.
Diag(diag::err_drv_argument_not_allowed_with)
2387 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
2389 CmdArgs.push_back(
"-mt-migrate-directory");
2390 CmdArgs.push_back(A->getValue());
2392 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2393 options::OPT_objcmt_migrate_subscripting,
2394 options::OPT_objcmt_migrate_property)) {
2396 CmdArgs.push_back(
"-objcmt-migrate-literals");
2397 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
2398 CmdArgs.push_back(
"-objcmt-migrate-property");
2400 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2401 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2402 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2405 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2406 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2407 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2408 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2409 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2410 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2411 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
2412 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2413 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2414 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2415 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2416 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2417 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2418 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2419 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
2420 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
2425 const ArgList &Args, ArgStringList &CmdArgs) {
2428 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
2429 !Args.hasArg(options::OPT_mkernel));
2431 CmdArgs.push_back(
"-fno-builtin");
2434 if (Args.hasArg(options::OPT_ffreestanding))
2435 UseBuiltins =
false;
2438 for (
const auto &Arg : Args) {
2439 const Option &O = Arg->getOption();
2440 if (!O.matches(options::OPT_fno_builtin_))
2450 StringRef FuncName = Arg->getValue();
2451 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
2457 if (TC.
getArch() == llvm::Triple::le32)
2458 CmdArgs.push_back(
"-fno-math-builtin");
2462 const ArgList &Args,
const InputInfo &Input,
2464 ArgStringList &CmdArgs,
bool &HaveModules) {
2468 bool HaveClangModules =
false;
2469 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
2470 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2471 options::OPT_fno_cxx_modules,
true);
2473 CmdArgs.push_back(
"-fmodules");
2474 HaveClangModules =
true;
2478 HaveModules = HaveClangModules;
2479 if (Args.hasArg(options::OPT_fmodules_ts)) {
2480 CmdArgs.push_back(
"-fmodules-ts");
2486 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
2487 options::OPT_fno_implicit_module_maps, HaveClangModules))
2488 CmdArgs.push_back(
"-fimplicit-module-maps");
2491 if (Args.hasFlag(options::OPT_fmodules_decluse,
2492 options::OPT_fno_modules_decluse,
false))
2493 CmdArgs.push_back(
"-fmodules-decluse");
2497 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
2498 options::OPT_fno_modules_strict_decluse,
false))
2499 CmdArgs.push_back(
"-fmodules-strict-decluse");
2502 if (!Args.hasFlag(options::OPT_fimplicit_modules,
2503 options::OPT_fno_implicit_modules, HaveClangModules)) {
2505 CmdArgs.push_back(
"-fno-implicit-modules");
2506 }
else if (HaveModules) {
2510 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
2511 Path = A->getValue();
2517 llvm::sys::path::replace_extension(Path,
".cache");
2518 llvm::sys::path::append(Path,
"modules");
2519 }
else if (Path.empty()) {
2521 llvm::sys::path::system_temp_directory(
false, Path);
2522 llvm::sys::path::append(Path,
"org.llvm.clang.");
2524 llvm::sys::path::append(Path,
"ModuleCache");
2527 const char Arg[] =
"-fmodules-cache-path=";
2528 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
2529 CmdArgs.push_back(Args.MakeArgString(Path));
2534 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
2535 CmdArgs.push_back(Args.MakeArgString(
2536 std::string(
"-fprebuilt-module-path=") + A->getValue()));
2543 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
2547 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
2551 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
2553 llvm::sys::path::append(BuiltinModuleMap,
"include");
2554 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
2555 if (llvm::sys::fs::exists(BuiltinModuleMap))
2557 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
2565 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
2567 Args.ClaimAllArgs(options::OPT_fmodule_file);
2573 llvm::sys::path::replace_extension(VFSDir,
".cache");
2577 llvm::sys::path::append(VFSDir,
"vfs");
2578 CmdArgs.push_back(
"-module-dependency-dir");
2579 CmdArgs.push_back(Args.MakeArgString(VFSDir));
2582 if (HaveClangModules)
2583 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
2586 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
2587 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
2588 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
2590 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
2592 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
2593 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
2594 D.
Diag(diag::err_drv_argument_not_allowed_with)
2595 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
2597 llvm::sys::fs::file_status Status;
2598 if (llvm::sys::fs::status(A->getValue(), Status))
2599 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
2601 Args.MakeArgString(
"-fbuild-session-timestamp=" +
2602 Twine((uint64_t)Status.getLastModificationTime()
2607 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
2608 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
2609 options::OPT_fbuild_session_file))
2610 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
2612 Args.AddLastArg(CmdArgs,
2613 options::OPT_fmodules_validate_once_per_build_session);
2616 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
2617 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
2621 ArgStringList &CmdArgs) {
2623 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
2624 options::OPT_fno_signed_char,
2625 options::OPT_funsigned_char,
2626 options::OPT_fno_unsigned_char)) {
2627 if (A->getOption().matches(options::OPT_funsigned_char) ||
2628 A->getOption().matches(options::OPT_fno_signed_char)) {
2629 CmdArgs.push_back(
"-fno-signed-char");
2632 CmdArgs.push_back(
"-fno-signed-char");
2635 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
2636 options::OPT_fno_short_wchar)) {
2637 if (A->getOption().matches(options::OPT_fshort_wchar)) {
2638 CmdArgs.push_back(
"-fwchar-type=short");
2639 CmdArgs.push_back(
"-fno-signed-wchar");
2641 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
2642 CmdArgs.push_back(
"-fwchar-type=int");
2643 if (IsARM && !(T.isOSWindows() || T.getOS() == llvm::Triple::NetBSD ||
2644 T.getOS() == llvm::Triple::OpenBSD))
2645 CmdArgs.push_back(
"-fno-signed-wchar");
2647 CmdArgs.push_back(
"-fsigned-wchar");
2653 const llvm::Triple &
T,
const ArgList &Args,
2655 const InputInfo &Input, ArgStringList &CmdArgs) {
2656 const llvm::Triple::ArchType Arch = TC.
getArch();
2662 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2663 options::OPT_fno_objc_legacy_dispatch,
2666 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
2668 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
2674 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
2675 !T.isMacOSXVersionLT(10, 7) &&
2677 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
2684 CmdArgs.push_back(
"-fobjc-arc");
2691 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
2693 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
2698 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2699 options::OPT_fno_objc_arc_exceptions,
2701 CmdArgs.push_back(
"-fobjc-arc-exceptions");
2706 if (Args.hasArg(options::OPT_fno_objc_arc)) {
2707 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
2708 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
2713 if (InferCovariantReturns)
2714 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
2719 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
2723 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
2724 D.
Diag(diag::err_objc_weak_unsupported);
2726 WeakArg->render(Args, CmdArgs);
2732 ArgStringList &CmdArgs) {
2733 bool CaretDefault =
true;
2734 bool ColumnDefault =
true;
2736 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
2737 options::OPT__SLASH_diagnostics_column,
2738 options::OPT__SLASH_diagnostics_caret)) {
2739 switch (A->getOption().getID()) {
2740 case options::OPT__SLASH_diagnostics_caret:
2741 CaretDefault =
true;
2742 ColumnDefault =
true;
2744 case options::OPT__SLASH_diagnostics_column:
2745 CaretDefault =
false;
2746 ColumnDefault =
true;
2748 case options::OPT__SLASH_diagnostics_classic:
2749 CaretDefault =
false;
2750 ColumnDefault =
false;
2756 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2757 options::OPT_fno_caret_diagnostics, CaretDefault))
2758 CmdArgs.push_back(
"-fno-caret-diagnostics");
2761 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
2762 options::OPT_fno_diagnostics_fixit_info))
2763 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
2766 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
2767 options::OPT_fno_diagnostics_show_option))
2768 CmdArgs.push_back(
"-fdiagnostics-show-option");
2771 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2772 CmdArgs.push_back(
"-fdiagnostics-show-category");
2773 CmdArgs.push_back(A->getValue());
2776 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
2777 options::OPT_fno_diagnostics_show_hotness,
false))
2778 CmdArgs.push_back(
"-fdiagnostics-show-hotness");
2781 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2783 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
2784 CmdArgs.push_back(Args.MakeArgString(Opt));
2787 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2788 CmdArgs.push_back(
"-fdiagnostics-format");
2789 CmdArgs.push_back(A->getValue());
2792 if (
const Arg *A = Args.getLastArg(
2793 options::OPT_fdiagnostics_show_note_include_stack,
2794 options::OPT_fno_diagnostics_show_note_include_stack)) {
2795 const Option &O = A->getOption();
2796 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
2797 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
2799 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
2806 for (
const Arg *A : Args) {
2807 const Option &O = A->getOption();
2808 if (!O.matches(options::OPT_fcolor_diagnostics) &&
2809 !O.matches(options::OPT_fdiagnostics_color) &&
2810 !O.matches(options::OPT_fno_color_diagnostics) &&
2811 !O.matches(options::OPT_fno_diagnostics_color) &&
2812 !O.matches(options::OPT_fdiagnostics_color_EQ))
2815 if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2816 StringRef
Value(A->getValue());
2818 D.
Diag(diag::err_drv_clang_unsupported)
2819 << (
"-fdiagnostics-color=" +
Value).str();
2825 CmdArgs.push_back(
"-fcolor-diagnostics");
2827 if (Args.hasArg(options::OPT_fansi_escape_codes))
2828 CmdArgs.push_back(
"-fansi-escape-codes");
2830 if (!Args.hasFlag(options::OPT_fshow_source_location,
2831 options::OPT_fno_show_source_location))
2832 CmdArgs.push_back(
"-fno-show-source-location");
2834 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
2835 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
2837 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
2839 CmdArgs.push_back(
"-fno-show-column");
2841 if (!Args.hasFlag(options::OPT_fspell_checking,
2842 options::OPT_fno_spell_checking))
2843 CmdArgs.push_back(
"-fno-spell-checking");
2847 const llvm::Triple &
T,
const ArgList &Args,
2848 bool EmitCodeView,
bool IsWindowsMSVC,
2849 ArgStringList &CmdArgs,
2851 const Arg *&SplitDWARFArg) {
2852 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
2853 options::OPT_fno_debug_info_for_profiling,
false))
2854 CmdArgs.push_back(
"-fdebug-info-for-profiling");
2865 unsigned DWARFVersion = 0;
2868 bool SplitDWARFInlining =
2869 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
2870 options::OPT_fno_split_dwarf_inlining,
true);
2872 Args.ClaimAllArgs(options::OPT_g_Group);
2874 SplitDWARFArg = Args.getLastArg(options::OPT_gsplit_dwarf);
2876 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2878 if (A->getOption().matches(options::OPT_gN_Group)) {
2888 if (SplitDWARFArg) {
2889 if (A->getIndex() > SplitDWARFArg->getIndex()) {
2892 SplitDWARFInlining))
2893 SplitDWARFArg =
nullptr;
2894 }
else if (SplitDWARFInlining)
2905 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
2906 if (A->getOption().matches(options::OPT_glldb))
2907 DebuggerTuning = llvm::DebuggerKind::LLDB;
2908 else if (A->getOption().matches(options::OPT_gsce))
2909 DebuggerTuning = llvm::DebuggerKind::SCE;
2911 DebuggerTuning = llvm::DebuggerKind::GDB;
2916 Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
2917 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
2922 if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {
2924 CmdArgs.push_back(
"-gcodeview");
2925 }
else if (DWARFVersion == 0 &&
2932 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2939 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
2940 !(IsWindowsMSVC && EmitCodeView) &&
2941 DebuggerTuning != llvm::DebuggerKind::SCE))
2942 CmdArgs.push_back(
"-dwarf-column-info");
2947 Args.hasArg(options::OPT_gmodules)) {
2949 CmdArgs.push_back(
"-dwarf-ext-refs");
2950 CmdArgs.push_back(
"-fmodule-format=obj");
2956 if (T.isOSLinux()) {
2957 if (!SplitDWARFInlining)
2958 CmdArgs.push_back(
"-fno-split-dwarf-inlining");
2960 if (SplitDWARFArg) {
2963 CmdArgs.push_back(
"-enable-split-dwarf");
2972 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
2973 options::OPT_fno_standalone_debug,
2982 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
2984 CmdArgs.push_back(
"-debug-info-macro");
2987 if (Args.hasArg(options::OPT_ggnu_pubnames))
2988 CmdArgs.push_back(
"-ggnu-pubnames");
2993 if (Args.hasArg(options::OPT_gdwarf_aranges) ||
2994 DebuggerTuning == llvm::DebuggerKind::SCE) {
2995 CmdArgs.push_back(
"-backend-option");
2996 CmdArgs.push_back(
"-generate-arange-section");
2999 if (Args.hasFlag(options::OPT_fdebug_types_section,
3000 options::OPT_fno_debug_types_section,
false)) {
3001 CmdArgs.push_back(
"-backend-option");
3002 CmdArgs.push_back(
"-generate-type-units");
3007 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3008 CmdArgs.push_back(
"-debug-forward-template-params");
3011 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3012 CmdArgs.push_back(
"-dwarf-explicit-import");
3019 const ArgList &Args,
const char *LinkingOutput)
const {
3020 const llvm::Triple &RawTriple = getToolChain().getTriple();
3021 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
3022 const std::string &TripleStr = Triple.getTriple();
3025 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3026 const Driver &D = getToolChain().getDriver();
3027 ArgStringList CmdArgs;
3030 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
3038 assert((IsCuda || (IsOpenMPDevice && Inputs.size() == 2) ||
3039 Inputs.size() == 1) &&
3040 "Unable to handle multiple inputs.");
3042 const llvm::Triple *AuxTriple =
3043 IsCuda ? getToolChain().getAuxTriple() :
nullptr;
3045 bool IsWindowsGNU = RawTriple.isWindowsGNUEnvironment();
3046 bool IsWindowsCygnus = RawTriple.isWindowsCygwinEnvironment();
3047 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
3048 bool IsIAMCU = RawTriple.isOSIAMCU();
3054 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
3055 IsWindowsGNU |= AuxTriple && AuxTriple->isWindowsGNUEnvironment();
3056 IsWindowsCygnus |= AuxTriple && AuxTriple->isWindowsCygwinEnvironment();
3061 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
3066 CmdArgs.push_back(
"-cc1");
3069 CmdArgs.push_back(
"-triple");
3070 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3072 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
3073 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
3074 Args.ClaimAllArgs(options::OPT_MJ);
3080 std::string NormalizedTriple;
3090 CmdArgs.push_back(
"-aux-triple");
3091 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3094 if (IsOpenMPDevice) {
3096 std::string NormalizedTriple =
3100 CmdArgs.push_back(
"-aux-triple");
3101 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3104 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3105 Triple.getArch() == llvm::Triple::thumb)) {
3106 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
3108 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
3110 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
3117 getToolChain().addClangWarningOptions(CmdArgs);
3120 RewriteKind rewriteKind = RK_None;
3122 if (isa<AnalyzeJobAction>(JA)) {
3123 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
3124 CmdArgs.push_back(
"-analyze");
3125 }
else if (isa<MigrateJobAction>(JA)) {
3126 CmdArgs.push_back(
"-migrate");
3127 }
else if (isa<PreprocessJobAction>(JA)) {
3128 if (Output.
getType() == types::TY_Dependencies)
3129 CmdArgs.push_back(
"-Eonly");
3131 CmdArgs.push_back(
"-E");
3132 if (Args.hasArg(options::OPT_rewrite_objc) &&
3133 !Args.hasArg(options::OPT_g_Group))
3134 CmdArgs.push_back(
"-P");
3136 }
else if (isa<AssembleJobAction>(JA)) {
3137 CmdArgs.push_back(
"-emit-obj");
3142 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
3143 }
else if (isa<PrecompileJobAction>(JA)) {
3147 if (JA.
getType() == types::TY_Nothing)
3148 CmdArgs.push_back(
"-fsyntax-only");
3149 else if (JA.
getType() == types::TY_ModuleFile)
3150 CmdArgs.push_back(
"-emit-module-interface");
3152 CmdArgs.push_back(
"-emit-pch");
3154 CmdArgs.push_back(
"-emit-pth");
3155 }
else if (isa<VerifyPCHJobAction>(JA)) {
3156 CmdArgs.push_back(
"-verify-pch");
3158 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3159 "Invalid action for clang tool.");
3160 if (JA.
getType() == types::TY_Nothing) {
3161 CmdArgs.push_back(
"-fsyntax-only");
3162 }
else if (JA.
getType() == types::TY_LLVM_IR ||
3163 JA.
getType() == types::TY_LTO_IR) {
3164 CmdArgs.push_back(
"-emit-llvm");
3165 }
else if (JA.
getType() == types::TY_LLVM_BC ||
3166 JA.
getType() == types::TY_LTO_BC) {
3167 CmdArgs.push_back(
"-emit-llvm-bc");
3168 }
else if (JA.
getType() == types::TY_PP_Asm) {
3169 CmdArgs.push_back(
"-S");
3170 }
else if (JA.
getType() == types::TY_AST) {
3171 CmdArgs.push_back(
"-emit-pch");
3172 }
else if (JA.
getType() == types::TY_ModuleFile) {
3173 CmdArgs.push_back(
"-module-file-info");
3174 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
3175 CmdArgs.push_back(
"-rewrite-objc");
3176 rewriteKind = RK_NonFragile;
3177 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
3178 CmdArgs.push_back(
"-rewrite-objc");
3179 rewriteKind = RK_Fragile;
3181 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
3188 if (JA.
getType() == types::TY_LLVM_BC)
3189 CmdArgs.push_back(
"-emit-llvm-uselists");
3192 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
3197 if (!(RawTriple.isOSDarwin() || RawTriple.isPS4()) ||
3199 CmdArgs.push_back(
"-flto-unit");
3203 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
3205 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3207 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
3212 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
3214 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
3216 CmdArgs.push_back(
"-disable-llvm-passes");
3219 CmdArgs.push_back(
"-fembed-bitcode=marker");
3225 CmdArgs.push_back(
"-disable-free");
3229 CmdArgs.push_back(
"-disable-llvm-verifier");
3231 CmdArgs.push_back(
"-discard-value-names");
3236 CmdArgs.push_back(
"-main-file-name");
3237 CmdArgs.push_back(getBaseInputName(Args, Input));
3241 if (Args.hasArg(options::OPT_static))
3242 CmdArgs.push_back(
"-static-define");
3244 if (isa<AnalyzeJobAction>(JA))
3249 llvm::Reloc::Model RelocationModel;
3252 std::tie(RelocationModel, PICLevel, IsPIE) =
3257 if ((RelocationModel == llvm::Reloc::ROPI ||
3258 RelocationModel == llvm::Reloc::ROPI_RWPI) &&
3260 !Args.hasArg(options::OPT_fallow_unsupported))
3261 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
3264 CmdArgs.push_back(
"-mrelocation-model");
3265 CmdArgs.push_back(RMName);
3268 CmdArgs.push_back(
"-pic-level");
3269 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
3271 CmdArgs.push_back(
"-pic-is-pie");
3274 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3275 CmdArgs.push_back(
"-meabi");
3276 CmdArgs.push_back(A->getValue());
3279 CmdArgs.push_back(
"-mthread-model");
3280 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
3281 if (!getToolChain().isThreadModelSupported(A->getValue()))
3282 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
3283 << A->getValue() << A->getAsString(Args);
3284 CmdArgs.push_back(A->getValue());
3287 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3289 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3291 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3292 options::OPT_fno_merge_all_constants))
3293 CmdArgs.push_back(
"-fno-merge-all-constants");
3297 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3298 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
3299 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3300 options::OPT_frewrite_map_file_EQ)) {
3301 StringRef Map = A->getValue();
3302 if (!llvm::sys::fs::exists(Map)) {
3303 D.
Diag(diag::err_drv_no_such_file) << Map;
3305 CmdArgs.push_back(
"-frewrite-map-file");
3306 CmdArgs.push_back(A->getValue());
3312 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3313 StringRef
v = A->getValue();
3314 CmdArgs.push_back(
"-mllvm");
3315 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
3319 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
3321 CmdArgs.push_back(
"-fno-jump-tables");
3323 if (Args.hasFlag(options::OPT_fprofile_sample_accurate,
3324 options::OPT_fno_profile_sample_accurate,
false))
3325 CmdArgs.push_back(
"-fprofile-sample-accurate");
3327 if (!Args.hasFlag(options::OPT_fpreserve_as_comments,
3328 options::OPT_fno_preserve_as_comments,
true))
3329 CmdArgs.push_back(
"-fno-preserve-as-comments");
3331 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3332 CmdArgs.push_back(
"-mregparm");
3333 CmdArgs.push_back(A->getValue());
3336 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3337 options::OPT_freg_struct_return)) {
3338 if (getToolChain().getArch() != llvm::Triple::x86) {
3339 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3340 << A->getSpelling() << RawTriple.str();
3341 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3342 CmdArgs.push_back(
"-fpcc-struct-return");
3344 assert(A->getOption().matches(options::OPT_freg_struct_return));
3345 CmdArgs.push_back(
"-freg-struct-return");
3349 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
3350 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
3353 CmdArgs.push_back(
"-mdisable-fp-elim");
3354 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3355 options::OPT_fno_zero_initialized_in_bss))
3356 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
3361 OptSpecifier StrictAliasingAliasOption =
3362 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
3365 bool TBAAOnByDefault = !D.
IsCLMode();
3366 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
3367 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
3368 CmdArgs.push_back(
"-relaxed-aliasing");
3369 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3370 options::OPT_fno_struct_path_tbaa))
3371 CmdArgs.push_back(
"-no-struct-path-tbaa");
3372 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3374 CmdArgs.push_back(
"-fstrict-enums");
3375 if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
3377 CmdArgs.push_back(
"-fno-strict-return");
3378 if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
3379 options::OPT_fno_allow_editor_placeholders,
false))
3380 CmdArgs.push_back(
"-fallow-editor-placeholders");
3381 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
3382 options::OPT_fno_strict_vtable_pointers,
3384 CmdArgs.push_back(
"-fstrict-vtable-pointers");
3385 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3386 options::OPT_fno_optimize_sibling_calls))
3387 CmdArgs.push_back(
"-mdisable-tail-calls");
3389 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
3390 options::OPT_fno_fine_grained_bitfield_accesses);
3393 if (Args.hasArg(options::OPT_fsplit_stack))
3394 CmdArgs.push_back(
"-split-stacks");
3400 bool IsIntegratedAssemblerDefault =
3401 getToolChain().IsIntegratedAssemblerDefault();
3402 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
3403 IsIntegratedAssemblerDefault) ||
3404 Args.hasArg(options::OPT_dA))
3405 CmdArgs.push_back(
"-masm-verbose");
3407 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3408 IsIntegratedAssemblerDefault))
3409 CmdArgs.push_back(
"-no-integrated-as");
3411 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3412 CmdArgs.push_back(
"-mdebug-pass");
3413 CmdArgs.push_back(
"Structure");
3415 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3416 CmdArgs.push_back(
"-mdebug-pass");
3417 CmdArgs.push_back(
"Arguments");
3423 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
3424 CmdArgs.push_back(
"-mconstructor-aliases");
3428 if (KernelOrKext && RawTriple.isOSDarwin())
3429 CmdArgs.push_back(
"-fforbid-guard-variables");
3431 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
3433 CmdArgs.push_back(
"-mms-bitfields");
3436 if (Args.hasFlag(options::OPT_mpie_copy_relocations,
3437 options::OPT_mno_pie_copy_relocations,
3439 CmdArgs.push_back(
"-mpie-copy-relocations");
3442 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
3443 CmdArgs.push_back(
"-fno-plt");
3450 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
3453 CmdArgs.push_back(
"-ffreestanding");
3458 bool AsynchronousUnwindTables =
3459 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3460 options::OPT_fno_asynchronous_unwind_tables,
3461 (getToolChain().IsUnwindTablesDefault(Args) ||
3462 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3464 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3465 AsynchronousUnwindTables))
3466 CmdArgs.push_back(
"-munwind-tables");
3468 getToolChain().addClangTargetOptions(Args, CmdArgs,
3471 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3472 CmdArgs.push_back(
"-mlimit-float-precision");
3473 CmdArgs.push_back(A->getValue());
3477 (void)Args.hasArg(options::OPT_mtune_EQ);
3479 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
3480 CmdArgs.push_back(
"-mcode-model");
3481 CmdArgs.push_back(A->getValue());
3485 std::string CPU =
getCPUName(Args, Triple,
false);
3487 CmdArgs.push_back(
"-target-cpu");
3488 CmdArgs.push_back(Args.MakeArgString(CPU));
3491 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
3495 bool EmitCodeView =
false;
3500 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
3502 const Arg *SplitDWARFArg =
nullptr;
3504 IsWindowsMSVC, CmdArgs, DebugInfoKind, SplitDWARFArg);
3508 bool SplitDWARF = SplitDWARFArg && RawTriple.isOSLinux() &&
3509 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
3510 isa<BackendJobAction>(JA));
3511 const char *SplitDWARFOut;
3513 CmdArgs.push_back(
"-split-dwarf-file");
3515 CmdArgs.push_back(SplitDWARFOut);
3519 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3520 CmdArgs.push_back(
"-target-linker-version");
3521 CmdArgs.push_back(A->getValue());
3525 CmdArgs.push_back(
"-momit-leaf-frame-pointer");
3529 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3531 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
3532 getToolChain().getArch() == llvm::Triple::x86) {
3533 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3534 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
3535 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
3536 << Unsupported->getOption().getName();
3539 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
3540 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
3541 << Unsupported->getOption().getName()
3542 <<
"please use -maltivec and include altivec.h explicitly";
3543 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
3544 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
3545 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
3548 Args.AddAllArgs(CmdArgs, options::OPT_v);
3549 Args.AddLastArg(CmdArgs, options::OPT_H);
3551 CmdArgs.push_back(
"-header-include-file");
3555 Args.AddLastArg(CmdArgs, options::OPT_P);
3556 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
3559 CmdArgs.push_back(
"-diagnostic-log-file");
3566 if (Args.hasFlag(options::OPT_ffunction_sections,
3567 options::OPT_fno_function_sections, UseSeparateSections)) {
3568 CmdArgs.push_back(
"-ffunction-sections");
3571 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
3572 UseSeparateSections)) {
3573 CmdArgs.push_back(
"-fdata-sections");
3576 if (!Args.hasFlag(options::OPT_funique_section_names,
3577 options::OPT_fno_unique_section_names,
true))
3578 CmdArgs.push_back(
"-fno-unique-section-names");
3580 if (
auto *A = Args.getLastArg(
3581 options::OPT_finstrument_functions,
3582 options::OPT_finstrument_functions_after_inlining,
3583 options::OPT_finstrument_function_entry_bare))
3584 A->render(Args, CmdArgs);
3588 if (
auto *ABICompatArg = Args.getLastArg(options::OPT_fclang_abi_compat_EQ))
3589 ABICompatArg->render(Args, CmdArgs);
3592 if (RawTriple.isPS4CPU())
3596 if (Args.hasArg(options::OPT_nostdinc)) {
3597 CmdArgs.push_back(
"-nostdsysteminc");
3598 CmdArgs.push_back(
"-nobuiltininc");
3600 if (Args.hasArg(options::OPT_nostdlibinc))
3601 CmdArgs.push_back(
"-nostdsysteminc");
3602 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3603 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3607 CmdArgs.push_back(
"-resource-dir");
3610 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3619 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
3625 Args.ClaimAllArgs(options::OPT_D);
3628 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3629 if (A->getOption().matches(options::OPT_O4)) {
3630 CmdArgs.push_back(
"-O3");
3631 D.
Diag(diag::warn_O4_is_O3);
3633 A->render(Args, CmdArgs);
3639 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3640 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
3645 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
3646 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
3652 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
3654 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
3655 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
3656 CmdArgs.push_back(
"-pedantic");
3657 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
3658 Args.AddLastArg(CmdArgs, options::OPT_w);
3665 bool ImplyVCPPCXXVer =
false;
3666 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3667 if (Std->getOption().matches(options::OPT_ansi))
3669 CmdArgs.push_back(
"-std=c++98");
3671 CmdArgs.push_back(
"-std=c89");
3673 Std->render(Args, CmdArgs);
3676 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3677 options::OPT_ftrigraphs,
3678 options::OPT_fno_trigraphs))
3680 A->render(Args, CmdArgs);
3689 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
3691 else if (IsWindowsMSVC)
3692 ImplyVCPPCXXVer =
true;
3694 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3695 options::OPT_fno_trigraphs);
3711 Args.getLastArg(options::OPT_Wwrite_strings,
3712 options::OPT_Wno_write_strings, options::OPT_w);
3714 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
3715 CmdArgs.push_back(
"-fconst-strings");
3722 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3724 CmdArgs.push_back(
"-fdeprecated-macro");
3728 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3729 if (Asm->getOption().matches(options::OPT_fasm))
3730 CmdArgs.push_back(
"-fgnu-keywords");
3732 CmdArgs.push_back(
"-fno-gnu-keywords");
3736 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
3739 CmdArgs.push_back(
"-fno-autolink");
3744 for (
const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
3745 StringRef Map = A->getValue();
3746 if (Map.find(
'=') == StringRef::npos)
3747 D.
Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map;
3749 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
3753 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3754 options::OPT_ftemplate_depth_EQ)) {
3755 CmdArgs.push_back(
"-ftemplate-depth");
3756 CmdArgs.push_back(A->getValue());
3759 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3760 CmdArgs.push_back(
"-foperator-arrow-depth");
3761 CmdArgs.push_back(A->getValue());
3764 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3765 CmdArgs.push_back(
"-fconstexpr-depth");
3766 CmdArgs.push_back(A->getValue());
3769 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3770 CmdArgs.push_back(
"-fconstexpr-steps");
3771 CmdArgs.push_back(A->getValue());
3774 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3775 CmdArgs.push_back(
"-fbracket-depth");
3776 CmdArgs.push_back(A->getValue());
3779 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3780 options::OPT_Wlarge_by_value_copy_def)) {
3781 if (A->getNumValues()) {
3782 StringRef
bytes = A->getValue();
3783 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
3785 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
3788 if (Args.hasArg(options::OPT_relocatable_pch))
3789 CmdArgs.push_back(
"-relocatable-pch");
3791 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3792 CmdArgs.push_back(
"-fconstant-string-class");
3793 CmdArgs.push_back(A->getValue());
3796 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3797 CmdArgs.push_back(
"-ftabstop");
3798 CmdArgs.push_back(A->getValue());
3801 CmdArgs.push_back(
"-ferror-limit");
3802 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
3803 CmdArgs.push_back(A->getValue());
3805 CmdArgs.push_back(
"19");
3807 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3808 CmdArgs.push_back(
"-fmacro-backtrace-limit");
3809 CmdArgs.push_back(A->getValue());
3812 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3813 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
3814 CmdArgs.push_back(A->getValue());
3817 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3818 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
3819 CmdArgs.push_back(A->getValue());
3822 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3823 CmdArgs.push_back(
"-fspell-checking-limit");
3824 CmdArgs.push_back(A->getValue());
3828 CmdArgs.push_back(
"-fmessage-length");
3829 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
3830 CmdArgs.push_back(A->getValue());
3834 unsigned N = llvm::sys::Process::StandardErrColumns();
3835 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
3839 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3840 options::OPT_fvisibility_ms_compat)) {
3841 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3842 CmdArgs.push_back(
"-fvisibility");
3843 CmdArgs.push_back(A->getValue());
3845 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3846 CmdArgs.push_back(
"-fvisibility");
3847 CmdArgs.push_back(
"hidden");
3848 CmdArgs.push_back(
"-ftype-visibility");
3849 CmdArgs.push_back(
"default");
3853 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
3855 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3858 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
3859 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
3860 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3863 bool EmulatedTLSDefault = Triple.isAndroid() || Triple.isOSOpenBSD() ||
3864 Triple.isWindowsCygwinEnvironment();
3865 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
3866 EmulatedTLSDefault))
3867 CmdArgs.push_back(
"-femulated-tls");
3869 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
3870 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
3872 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3873 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3877 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
3878 options::OPT_fno_openmp,
false) &&
3885 CmdArgs.push_back(
"-fopenmp");
3890 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
3891 options::OPT_fnoopenmp_use_tls,
true))
3892 CmdArgs.push_back(
"-fnoopenmp-use-tls");
3893 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
3905 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
3906 options::OPT_fno_openmp_simd);
3907 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
3910 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3911 Sanitize.
addArgs(getToolChain(), Args, CmdArgs, InputType);
3913 const XRayArgs &XRay = getToolChain().getXRayArgs();
3914 XRay.
addArgs(getToolChain(), Args, CmdArgs, InputType);
3916 if (getToolChain().SupportsProfiling())
3917 Args.AddLastArg(CmdArgs, options::OPT_pg);
3919 if (getToolChain().SupportsProfiling())
3920 Args.AddLastArg(CmdArgs, options::OPT_mfentry);
3923 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3924 options::OPT_fno_lax_vector_conversions))
3925 CmdArgs.push_back(
"-fno-lax-vector-conversions");
3927 if (Args.getLastArg(options::OPT_fapple_kext) ||
3928 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
3929 CmdArgs.push_back(
"-fapple-kext");
3931 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3932 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3933 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3934 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3935 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3937 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3938 CmdArgs.push_back(
"-ftrapv-handler");
3939 CmdArgs.push_back(A->getValue());
3942 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3946 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
3947 if (A->getOption().matches(options::OPT_fwrapv))
3948 CmdArgs.push_back(
"-fwrapv");
3949 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3950 options::OPT_fno_strict_overflow)) {
3951 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3952 CmdArgs.push_back(
"-fwrapv");
3955 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3956 options::OPT_fno_reroll_loops))
3957 if (A->getOption().matches(options::OPT_freroll_loops))
3958 CmdArgs.push_back(
"-freroll-loops");
3960 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3961 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3962 options::OPT_fno_unroll_loops);
3964 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3969 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3971 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
3973 if (Args.hasArg(options::OPT_mstack_alignment)) {
3974 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3975 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
3978 if (Args.hasArg(options::OPT_mstack_probe_size)) {
3979 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
3982 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
3984 CmdArgs.push_back(
"-mstack-probe-size=0");
3987 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3988 options::OPT_mno_restrict_it)) {
3989 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3990 CmdArgs.push_back(
"-backend-option");
3991 CmdArgs.push_back(
"-arm-restrict-it");
3993 CmdArgs.push_back(
"-backend-option");
3994 CmdArgs.push_back(
"-arm-no-restrict-it");
3996 }
else if (Triple.isOSWindows() &&
3997 (Triple.getArch() == llvm::Triple::arm ||
3998 Triple.getArch() == llvm::Triple::thumb)) {
4000 CmdArgs.push_back(
"-backend-option");
4001 CmdArgs.push_back(
"-arm-restrict-it");
4010 StringRef fname = A->getValue();
4011 if (!llvm::sys::fs::exists(fname))
4012 D.
Diag(diag::err_drv_no_such_file) << fname;
4014 A->render(Args, CmdArgs);
4019 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4020 options::OPT_fno_assume_sane_operator_new))
4021 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4024 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
4025 getToolChain().IsBlocksDefault()) ||
4026 (Args.hasArg(options::OPT_fgnu_runtime) &&
4027 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4028 !Args.hasArg(options::OPT_fno_blocks))) {
4029 CmdArgs.push_back(
"-fblocks");
4031 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4032 !getToolChain().hasBlocksRuntime())
4033 CmdArgs.push_back(
"-fblocks-runtime-optional");
4037 if (getToolChain().IsEncodeExtendedBlockSignatureDefault())
4038 CmdArgs.push_back(
"-fencode-extended-block-signature");
4040 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
4043 CmdArgs.push_back(
"-fcoroutines-ts");
4046 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
4047 options::OPT_fno_double_square_bracket_attributes);
4049 bool HaveModules =
false;
4053 if (Args.hasFlag(options::OPT_fno_access_control,
4054 options::OPT_faccess_control,
false))
4055 CmdArgs.push_back(
"-fno-access-control");
4058 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4059 options::OPT_felide_constructors,
false))
4060 CmdArgs.push_back(
"-fno-elide-constructors");
4067 CmdArgs.push_back(
"-fno-rtti");
4070 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4071 getToolChain().getArch() == llvm::Triple::hexagon))
4072 CmdArgs.push_back(
"-fshort-enums");
4078 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
4079 !RawTriple.isOSWindows() &&
4080 RawTriple.getOS() != llvm::Triple::Solaris &&
4081 getToolChain().getArch() != llvm::Triple::hexagon &&
4082 getToolChain().getArch() != llvm::Triple::xcore &&
4083 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
4084 RawTriple.hasEnvironment())) ||
4086 CmdArgs.push_back(
"-fno-use-cxa-atexit");
4089 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
4091 CmdArgs.push_back(
"-fms-extensions");
4094 if (Args.hasFlag(options::OPT_fuse_line_directives,
4095 options::OPT_fno_use_line_directives,
false))
4096 CmdArgs.push_back(
"-fuse-line-directives");
4099 if (Args.hasFlag(options::OPT_fms_compatibility,
4100 options::OPT_fno_ms_compatibility,
4102 Args.hasFlag(options::OPT_fms_extensions,
4103 options::OPT_fno_ms_extensions,
true))))
4104 CmdArgs.push_back(
"-fms-compatibility");
4106 VersionTuple MSVT = getToolChain().computeMSVCVersion(&D, Args);
4109 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.
getAsString()));
4111 bool IsMSVC2015Compatible = MSVT.
getMajor() >= 19;
4112 if (ImplyVCPPCXXVer) {
4113 StringRef LanguageStandard;
4114 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
4115 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
4116 .Case(
"c++14",
"-std=c++14")
4117 .Case(
"c++17",
"-std=c++17")
4118 .Case(
"c++latest",
"-std=c++2a")
4120 if (LanguageStandard.empty())
4121 D.
Diag(clang::diag::warn_drv_unused_argument)
4122 << StdArg->getAsString(Args);
4125 if (LanguageStandard.empty()) {
4126 if (IsMSVC2015Compatible)
4127 LanguageStandard =
"-std=c++14";
4129 LanguageStandard =
"-std=c++11";
4132 CmdArgs.push_back(LanguageStandard.data());
4136 if (Args.hasFlag(options::OPT_fborland_extensions,
4137 options::OPT_fno_borland_extensions,
false))
4138 CmdArgs.push_back(
"-fborland-extensions");
4141 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
4143 CmdArgs.push_back(
"-fdeclspec");
4144 else if (Args.hasArg(options::OPT_fno_declspec))
4145 CmdArgs.push_back(
"-fno-declspec");
4149 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4150 options::OPT_fno_threadsafe_statics,
4151 !IsWindowsMSVC || IsMSVC2015Compatible))
4152 CmdArgs.push_back(
"-fno-threadsafe-statics");
4158 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
4159 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
4160 CmdArgs.push_back(
"-fdelayed-template-parsing");
4164 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
4165 options::OPT_fno_gnu_keywords))
4166 A->render(Args, CmdArgs);
4168 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
4170 CmdArgs.push_back(
"-fgnu89-inline");
4172 if (Args.hasArg(options::OPT_fno_inline))
4173 CmdArgs.push_back(
"-fno-inline");
4175 if (Arg* InlineArg = Args.getLastArg(options::OPT_finline_functions,
4176 options::OPT_finline_hint_functions,
4177 options::OPT_fno_inline_functions))
4178 InlineArg->render(Args, CmdArgs);
4180 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager,
4181 options::OPT_fno_experimental_new_pass_manager);
4183 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
4185 rewriteKind != RK_None, Input, CmdArgs);
4187 if (Args.hasFlag(options::OPT_fapplication_extension,
4188 options::OPT_fno_application_extension,
false))
4189 CmdArgs.push_back(
"-fapplication-extension");
4197 Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
4198 options::OPT_fseh_exceptions,
4199 options::OPT_fdwarf_exceptions);
4201 const Option &Opt = A->getOption();
4202 if (Opt.matches(options::OPT_fsjlj_exceptions))
4203 CmdArgs.push_back(
"-fsjlj-exceptions");
4204 if (Opt.matches(options::OPT_fseh_exceptions))
4205 CmdArgs.push_back(
"-fseh-exceptions");
4206 if (Opt.matches(options::OPT_fdwarf_exceptions))
4207 CmdArgs.push_back(
"-fdwarf-exceptions");
4209 switch (getToolChain().GetExceptionModel(Args)) {
4212 case llvm::ExceptionHandling::DwarfCFI:
4213 CmdArgs.push_back(
"-fdwarf-exceptions");
4215 case llvm::ExceptionHandling::SjLj:
4216 CmdArgs.push_back(
"-fsjlj-exceptions");
4218 case llvm::ExceptionHandling::WinEH:
4219 CmdArgs.push_back(
"-fseh-exceptions");
4225 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4226 options::OPT_fno_assume_sane_operator_new))
4227 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4232 if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
4233 options::OPT_fno_relaxed_template_template_args,
false))
4234 CmdArgs.push_back(
"-frelaxed-template-template-args");
4238 if (Args.hasFlag(options::OPT_fsized_deallocation,
4239 options::OPT_fno_sized_deallocation,
false))
4240 CmdArgs.push_back(
"-fsized-deallocation");
4244 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
4245 options::OPT_fno_aligned_allocation,
4246 options::OPT_faligned_new_EQ)) {
4247 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
4248 CmdArgs.push_back(
"-fno-aligned-allocation");
4250 CmdArgs.push_back(
"-faligned-allocation");
4255 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
4256 options::OPT_faligned_new_EQ))
4258 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
4262 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4263 options::OPT_fno_constant_cfstrings) ||
4264 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4265 options::OPT_mno_constant_cfstrings))
4266 CmdArgs.push_back(
"-fno-constant-cfstrings");
4269 if (Args.hasFlag(options::OPT_fpascal_strings,
4270 options::OPT_fno_pascal_strings,
false))
4271 CmdArgs.push_back(
"-fpascal-strings");
4275 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
4276 std::string PackStructStr =
"-fpack-struct=";
4277 PackStructStr += A->getValue();
4278 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
4279 }
else if (Args.hasFlag(options::OPT_fpack_struct,
4280 options::OPT_fno_pack_struct,
false)) {
4281 CmdArgs.push_back(
"-fpack-struct=1");
4285 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4286 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4287 if (!SkipMaxTypeAlign) {
4288 std::string MaxTypeAlignStr =
"-fmax-type-align=";
4289 MaxTypeAlignStr += A->getValue();
4290 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4292 }
else if (RawTriple.isOSDarwin()) {
4293 if (!SkipMaxTypeAlign) {
4294 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
4295 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4301 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
4303 CmdArgs.push_back(
"-fno-common");
4307 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
4308 options::OPT_funsigned_bitfields))
4309 D.
Diag(diag::warn_drv_clang_unsupported)
4310 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4313 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
4314 D.
Diag(diag::err_drv_clang_unsupported)
4315 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4318 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4319 StringRef value = inputCharset->getValue();
4320 if (!value.equals_lower(
"utf-8"))
4321 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4326 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4327 StringRef value = execCharset->getValue();
4328 if (!value.equals_lower(
"utf-8"))
4329 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4336 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4338 CmdArgs.push_back(
"-fasm-blocks");
4341 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4342 options::OPT_fno_gnu_inline_asm,
true))
4343 CmdArgs.push_back(
"-fno-gnu-inline-asm");
4349 OptSpecifier VectorizeAliasOption =
4350 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
4351 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4352 options::OPT_fno_vectorize, EnableVec))
4353 CmdArgs.push_back(
"-vectorize-loops");
4357 OptSpecifier SLPVectAliasOption =
4358 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
4359 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4360 options::OPT_fno_slp_vectorize, EnableSLPVec))
4361 CmdArgs.push_back(
"-vectorize-slp");
4365 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4366 A->render(Args, CmdArgs);
4368 if (Arg *A = Args.getLastArg(
4369 options::OPT_fsanitize_undefined_strip_path_components_EQ))
4370 A->render(Args, CmdArgs);
4374 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4375 options::OPT_fno_dollars_in_identifiers)) {
4376 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
4377 CmdArgs.push_back(
"-fdollars-in-identifiers");
4379 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
4384 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4385 options::OPT_fno_unit_at_a_time)) {
4386 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
4387 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4390 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4391 options::OPT_fno_apple_pragma_pack,
false))
4392 CmdArgs.push_back(
"-fapple-pragma-pack");
4394 if (Args.hasFlag(options::OPT_fsave_optimization_record,
4395 options::OPT_foptimization_record_file_EQ,
4396 options::OPT_fno_save_optimization_record,
false)) {
4397 CmdArgs.push_back(
"-opt-record-file");
4399 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
4401 CmdArgs.push_back(A->getValue());
4405 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
4406 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
4407 F = FinalOutput->getValue();
4412 F = llvm::sys::path::stem(Input.getBaseInput());
4419 llvm::sys::path::replace_extension(F,
"");
4421 Triple.normalize());
4427 llvm::sys::path::replace_extension(F,
"opt.yaml");
4428 CmdArgs.push_back(Args.MakeArgString(F));
4432 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
4433 options::OPT_fno_rewrite_imports,
false);
4435 CmdArgs.push_back(
"-frewrite-imports");
4441 if (Args.hasFlag(options::OPT_frewrite_includes,
4442 options::OPT_fno_rewrite_includes,
false) ||
4444 CmdArgs.push_back(
"-frewrite-includes");
4447 if (Arg *A = Args.getLastArg(options::OPT_traditional,
4448 options::OPT_traditional_cpp)) {
4449 if (isa<PreprocessJobAction>(JA))
4450 CmdArgs.push_back(
"-traditional-cpp");
4452 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
4455 Args.AddLastArg(CmdArgs, options::OPT_dM);
4456 Args.AddLastArg(CmdArgs, options::OPT_dD);
4459 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4460 CmdArgs.push_back(
"-serialize-diagnostic-file");
4461 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
4464 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4465 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
4468 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
4470 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
4473 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
4474 CmdArgs.push_back(
"-load");
4475 CmdArgs.push_back(A->getValue());
4480 if (
const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ)) {
4481 StringRef SaveStats = A->getValue();
4484 bool DoSaveStats =
false;
4485 if (SaveStats ==
"obj") {
4488 llvm::sys::path::remove_filename(StatsFile);
4491 }
else if (SaveStats ==
"cwd") {
4494 D.
Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
4498 StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());
4499 llvm::sys::path::append(StatsFile, BaseName);
4500 llvm::sys::path::replace_extension(StatsFile,
"stats");
4501 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") +
4511 !isa<PreprocessJobAction>(JA)) {
4512 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
4514 if (StringRef(Arg->getValue()) !=
"-finclude-default-header")
4515 CmdArgs.push_back(Arg->getValue());
4519 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
4521 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
4527 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
4528 CmdArgs.push_back(
"-disable-llvm-optzns");
4530 A->render(Args, CmdArgs);
4544 isa<CompileJobAction>(JA))
4545 CmdArgs.push_back(
"-disable-llvm-passes");
4547 if (Output.
getType() == types::TY_Dependencies) {
4550 CmdArgs.push_back(
"-o");
4553 assert(Output.
isNothing() &&
"Invalid output.");
4558 if (Input.isFilename())
4559 CmdArgs.push_back(Input.getFilename());
4561 Input.getInputArg().renderAsInput(Args, CmdArgs);
4563 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4572 if (getToolChain().UseDwarfDebugFlags() ||
4573 Args.hasFlag(options::OPT_grecord_gcc_switches,
4574 options::OPT_gno_record_gcc_switches,
false)) {
4575 ArgStringList OriginalArgs;
4576 for (
const auto &Arg : Args)
4577 Arg->render(Args, OriginalArgs);
4581 for (
const char *OriginalArg : OriginalArgs) {
4585 Flags += EscapedArg;
4587 CmdArgs.push_back(
"-dwarf-debug-flags");
4588 CmdArgs.push_back(Args.MakeArgString(Flags));
4593 if (IsCuda && Inputs.size() > 1)
4594 for (
auto I = std::next(Inputs.begin()), E = Inputs.end(); I != E; ++I) {
4595 CmdArgs.push_back(
"-fcuda-include-gpubinary");
4596 CmdArgs.push_back(I->getFilename());
4604 if (IsOpenMPDevice) {
4605 CmdArgs.push_back(
"-fopenmp-is-device");
4606 if (Inputs.size() == 2) {
4607 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
4608 CmdArgs.push_back(Args.MakeArgString(Inputs.back().getFilename()));
4617 Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ);
4618 assert(Tgts && Tgts->getNumValues() &&
4619 "OpenMP offloading has to have targets specified.");
4620 for (
unsigned i = 0; i < Tgts->getNumValues(); ++i) {
4625 llvm::Triple
T(Tgts->getValue(i));
4626 TargetInfo +=
T.getTriple();
4628 CmdArgs.push_back(Args.MakeArgString(TargetInfo.str()));
4631 bool WholeProgramVTables =
4632 Args.hasFlag(options::OPT_fwhole_program_vtables,
4633 options::OPT_fno_whole_program_vtables,
false);
4634 if (WholeProgramVTables) {
4636 D.
Diag(diag::err_drv_argument_only_allowed_with)
4637 <<
"-fwhole-program-vtables" 4639 CmdArgs.push_back(
"-fwhole-program-vtables");
4642 if (Arg *A = Args.getLastArg(options::OPT_fexperimental_isel,
4643 options::OPT_fno_experimental_isel)) {
4644 CmdArgs.push_back(
"-mllvm");
4645 if (A->getOption().matches(options::OPT_fexperimental_isel)) {
4646 CmdArgs.push_back(
"-global-isel=1");
4651 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
4652 bool IsOptLevelSupported =
false;
4654 Arg *A = Args.getLastArg(options::OPT_O_Group);
4655 if (Triple.getArch() == llvm::Triple::aarch64) {
4656 if (!A || A->getOption().matches(options::OPT_O0))
4657 IsOptLevelSupported =
true;
4659 if (!IsArchSupported || !IsOptLevelSupported) {
4660 CmdArgs.push_back(
"-mllvm");
4661 CmdArgs.push_back(
"-global-isel-abort=2");
4663 if (!IsArchSupported)
4664 D.
Diag(diag::warn_drv_experimental_isel_incomplete) << Triple.getArchName();
4666 D.
Diag(diag::warn_drv_experimental_isel_incomplete_opt);
4669 CmdArgs.push_back(
"-global-isel=0");
4674 if (Args.hasArg(options::OPT__SLASH_fallback) &&
4675 Output.
getType() == types::TY_Object &&
4676 (InputType == types::TY_C || InputType == types::TY_CXX)) {
4678 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4679 C.
addCommand(llvm::make_unique<FallbackCommand>(
4680 JA, *
this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
4681 }
else if (Args.hasArg(options::OPT__SLASH_fallback) &&
4682 isa<PrecompileJobAction>(JA)) {
4685 C.
addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *
this, Exec,
4688 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
4694 if (SplitDWARF && Output.
getType() == types::TY_Object)
4695 SplitDebugInfo(getToolChain(), C, *
this, JA, Args, Output, SplitDWARFOut);
4697 if (Arg *A = Args.getLastArg(options::OPT_pg))
4698 if (Args.hasArg(options::OPT_fomit_frame_pointer))
4699 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer" 4700 << A->getAsString(Args);
4707 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
4711 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4712 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
4715 Args.ClaimAllArgs(options::OPT_emit_llvm);
4722 :
Tool(
"clang",
"clang frontend", TC, RF_Full) {}
4729 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
4730 ArgStringList &cmdArgs,
4731 RewriteKind rewriteKind)
const {
4734 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
4735 options::OPT_fobjc_runtime_EQ);
4740 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4742 StringRef value = runtimeArg->getValue();
4748 runtimeArg->render(args, cmdArgs);
4757 unsigned objcABIVersion = 1;
4759 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
4760 StringRef value = abiArg->getValue();
4763 else if (value ==
"2")
4765 else if (value ==
"3")
4771 bool nonFragileABIIsDefault =
4772 (rewriteKind == RK_NonFragile ||
4773 (rewriteKind == RK_None &&
4775 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4776 options::OPT_fno_objc_nonfragile_abi,
4777 nonFragileABIIsDefault)) {
4779 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 4780 unsigned nonFragileABIVersion = 1;
4782 unsigned nonFragileABIVersion = 2;
4786 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
4787 StringRef value = abiArg->getValue();
4789 nonFragileABIVersion = 1;
4790 else if (value ==
"2")
4791 nonFragileABIVersion = 2;
4797 objcABIVersion = 1 + nonFragileABIVersion;
4805 bool isNonFragile = objcABIVersion != 1;
4811 switch (rewriteKind) {
4824 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4836 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
4846 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
4851 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
4859 bool Asynch =
false;
4860 bool NoUnwindC =
false;
4874 std::vector<std::string> EHArgs =
4875 Args.getAllArgValues(options::OPT__SLASH_EH);
4876 for (
auto EHVal : EHArgs) {
4877 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
4895 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
4901 if (EHArgs.empty() &&
4902 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
4905 EH.NoUnwindC =
true;
4911 void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
4912 ArgStringList &CmdArgs,
4914 bool *EmitCodeView)
const {
4915 unsigned RTOptionID = options::OPT__SLASH_MT;
4917 if (Args.hasArg(options::OPT__SLASH_LDd))
4920 RTOptionID = options::OPT__SLASH_MTd;
4922 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4923 RTOptionID = A->getOption().getID();
4925 StringRef FlagForCRT;
4926 switch (RTOptionID) {
4927 case options::OPT__SLASH_MD:
4928 if (Args.hasArg(options::OPT__SLASH_LDd))
4929 CmdArgs.push_back(
"-D_DEBUG");
4930 CmdArgs.push_back(
"-D_MT");
4931 CmdArgs.push_back(
"-D_DLL");
4932 FlagForCRT =
"--dependent-lib=msvcrt";
4934 case options::OPT__SLASH_MDd:
4935 CmdArgs.push_back(
"-D_DEBUG");
4936 CmdArgs.push_back(
"-D_MT");
4937 CmdArgs.push_back(
"-D_DLL");
4938 FlagForCRT =
"--dependent-lib=msvcrtd";
4940 case options::OPT__SLASH_MT:
4941 if (Args.hasArg(options::OPT__SLASH_LDd))
4942 CmdArgs.push_back(
"-D_DEBUG");
4943 CmdArgs.push_back(
"-D_MT");
4944 CmdArgs.push_back(
"-flto-visibility-public-std");
4945 FlagForCRT =
"--dependent-lib=libcmt";
4947 case options::OPT__SLASH_MTd:
4948 CmdArgs.push_back(
"-D_DEBUG");
4949 CmdArgs.push_back(
"-D_MT");
4950 CmdArgs.push_back(
"-flto-visibility-public-std");
4951 FlagForCRT =
"--dependent-lib=libcmtd";
4954 llvm_unreachable(
"Unexpected option ID.");
4957 if (Args.hasArg(options::OPT__SLASH_Zl)) {
4958 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4960 CmdArgs.push_back(FlagForCRT.data());
4965 CmdArgs.push_back(
"--dependent-lib=oldnames");
4970 if ((!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP)) ||
4971 (Args.hasArg(options::OPT__SLASH_P) &&
4972 Args.hasArg(options::OPT__SLASH_EP) && !Args.hasArg(options::OPT_E)))
4973 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4974 A->render(Args, CmdArgs);
4977 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4979 CmdArgs.push_back(
"-fno-rtti-data");
4983 if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
4985 CmdArgs.push_back(
"-stack-protector");
4990 if (Arg *DebugInfoArg =
4991 Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
4992 options::OPT_gline_tables_only)) {
4993 *EmitCodeView =
true;
4994 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
4998 CmdArgs.push_back(
"-gcodeview");
5000 *EmitCodeView =
false;
5005 if (EH.Synch || EH.Asynch) {
5007 CmdArgs.push_back(
"-fcxx-exceptions");
5008 CmdArgs.push_back(
"-fexceptions");
5010 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
5011 CmdArgs.push_back(
"-fexternc-nounwind");
5014 if (Args.hasArg(options::OPT__SLASH_EP)) {
5015 CmdArgs.push_back(
"-E");
5016 CmdArgs.push_back(
"-P");
5019 unsigned VolatileOptionID;
5020 if (
getToolChain().getArch() == llvm::Triple::x86_64 ||
5022 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5024 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5026 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5027 VolatileOptionID = A->getOption().getID();
5029 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5030 CmdArgs.push_back(
"-fms-volatile");
5032 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5033 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5034 if (MostGeneralArg && BestCaseArg)
5035 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5036 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5038 if (MostGeneralArg) {
5039 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5040 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5041 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5043 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5044 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5045 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5046 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5047 << FirstConflict->getAsString(Args)
5048 << SecondConflict->getAsString(Args);
5051 CmdArgs.push_back(
"-fms-memptr-rep=single");
5052 else if (MultipleArg)
5053 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
5055 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
5060 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
5061 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
5062 options::OPT__SLASH_Gregcall)) {
5063 unsigned DCCOptId = CCArg->getOption().getID();
5064 const char *DCCFlag =
nullptr;
5065 bool ArchSupported =
true;
5068 case options::OPT__SLASH_Gd:
5069 DCCFlag =
"-fdefault-calling-conv=cdecl";
5071 case options::OPT__SLASH_Gr:
5072 ArchSupported = Arch == llvm::Triple::x86;
5073 DCCFlag =
"-fdefault-calling-conv=fastcall";
5075 case options::OPT__SLASH_Gz:
5076 ArchSupported = Arch == llvm::Triple::x86;
5077 DCCFlag =
"-fdefault-calling-conv=stdcall";
5079 case options::OPT__SLASH_Gv:
5080 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
5081 DCCFlag =
"-fdefault-calling-conv=vectorcall";
5083 case options::OPT__SLASH_Gregcall:
5084 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
5085 DCCFlag =
"-fdefault-calling-conv=regcall";
5090 if (ArchSupported && DCCFlag)
5091 CmdArgs.push_back(DCCFlag);
5094 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5095 A->render(Args, CmdArgs);
5097 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5098 CmdArgs.push_back(
"-fdiagnostics-format");
5099 if (Args.hasArg(options::OPT__SLASH_fallback))
5100 CmdArgs.push_back(
"msvc-fallback");
5102 CmdArgs.push_back(
"msvc");
5109 return CLFallback.get();
5115 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
5122 if (
const char *
End = strrchr(Str,
'.'))
5123 return Args.MakeArgString(std::string(Str,
End));
5133 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
5134 std::string Str(OutputOpt->getValue());
5135 Res = Str.substr(0, Str.rfind(
'.'));
5139 return Args.MakeArgString(Res +
".d");
5145 ArgStringList &CmdArgs)
const {
5151 CmdArgs.push_back(
"-target-abi");
5152 CmdArgs.push_back(ABIName.data());
5156 ArgStringList &CmdArgs)
const {
5157 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
5158 StringRef
Value = A->getValue();
5159 if (Value ==
"intel" || Value ==
"att") {
5160 CmdArgs.push_back(
"-mllvm");
5161 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
5164 << A->getOption().getName() <<
Value;
5171 const ArgList &Args,
5172 const char *LinkingOutput)
const {
5173 ArgStringList CmdArgs;
5175 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
5179 const std::string &TripleStr = Triple.getTriple();
5183 Args.ClaimAllArgs(options::OPT_w);
5185 Args.ClaimAllArgs(options::OPT_emit_llvm);
5192 CmdArgs.push_back(
"-cc1as");
5195 CmdArgs.push_back(
"-triple");
5196 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5200 CmdArgs.push_back(
"-filetype");
5201 CmdArgs.push_back(
"obj");
5205 CmdArgs.push_back(
"-main-file-name");
5209 std::string CPU =
getCPUName(Args, Triple,
true);
5211 CmdArgs.push_back(
"-target-cpu");
5212 CmdArgs.push_back(Args.MakeArgString(CPU));
5219 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5222 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5225 const Action *SourceAction = &JA;
5227 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
5228 SourceAction = SourceAction->
getInputs()[0];
5233 bool WantDebug =
false;
5234 unsigned DwarfVersion = 0;
5235 Args.ClaimAllArgs(options::OPT_g_Group);
5236 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
5237 WantDebug = !A->getOption().matches(options::OPT_g0) &&
5238 !A->getOption().matches(options::OPT_ggdb0);
5242 if (DwarfVersion == 0)
5247 if (SourceAction->
getType() == types::TY_Asm ||
5248 SourceAction->
getType() == types::TY_PP_Asm) {
5260 CmdArgs.push_back(
"-dwarf-debug-producer");
5264 Args.AddAllArgs(CmdArgs, options::OPT_I);
5267 llvm::DebuggerKind::Default);
5273 llvm::Reloc::Model RelocationModel;
5276 std::tie(RelocationModel, PICLevel, IsPIE) =
5281 CmdArgs.push_back(
"-mrelocation-model");
5282 CmdArgs.push_back(RMName);
5288 ArgStringList OriginalArgs;
5289 for (
const auto &Arg : Args)
5290 Arg->render(Args, OriginalArgs);
5295 for (
const char *OriginalArg : OriginalArgs) {
5299 Flags += EscapedArg;
5301 CmdArgs.push_back(
"-dwarf-debug-flags");
5302 CmdArgs.push_back(Args.MakeArgString(Flags));
5312 case llvm::Triple::mips:
5313 case llvm::Triple::mipsel:
5314 case llvm::Triple::mips64:
5315 case llvm::Triple::mips64el:
5316 AddMIPSTargetArgs(Args, CmdArgs);
5319 case llvm::Triple::x86:
5320 case llvm::Triple::x86_64:
5321 AddX86TargetArgs(Args, CmdArgs);
5324 case llvm::Triple::arm:
5325 case llvm::Triple::armeb:
5326 case llvm::Triple::thumb:
5327 case llvm::Triple::thumbeb:
5330 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
5331 options::OPT_mno_default_build_attributes,
true)) {
5332 CmdArgs.push_back(
"-mllvm");
5333 CmdArgs.push_back(
"-arm-add-build-attributes");
5343 Args.ClaimAllArgs(options::OPT_W_Group);
5348 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
5350 assert(Output.
isFilename() &&
"Unexpected lipo output.");
5351 CmdArgs.push_back(
"-o");
5354 assert(Input.isFilename() &&
"Invalid input.");
5355 CmdArgs.push_back(Input.getFilename());
5358 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
5363 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
5374 const llvm::opt::ArgList &TCArgs,
5375 const char *LinkingOutput)
const {
5377 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
5385 ArgStringList CmdArgs;
5388 CmdArgs.push_back(TCArgs.MakeArgString(
5391 assert(JA.
getInputs().size() == Inputs.size() &&
5392 "Not have inputs for all dependence actions??");
5396 Triples +=
"-targets=";
5397 for (
unsigned I = 0; I < Inputs.size(); ++I) {
5406 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
5408 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
5409 assert(CurTC ==
nullptr &&
"Expected one dependence!");
5416 Triples += CurTC->
getTriple().normalize();
5418 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
5422 TCArgs.MakeArgString(Twine(
"-outputs=") + Output.
getFilename()));
5427 for (
unsigned I = 0; I < Inputs.size(); ++I) {
5433 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
5435 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
5436 assert(CurTC ==
nullptr &&
"Expected one dependence!");
5442 CmdArgs.push_back(TCArgs.MakeArgString(UB));
5453 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
5454 const char *LinkingOutput)
const {
5456 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
5465 ArgStringList CmdArgs;
5467 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
5471 CmdArgs.push_back(TCArgs.MakeArgString(
5476 Triples +=
"-targets=";
5477 auto DepInfo = UA.getDependentActionsInfo();
5478 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
5482 auto &Dep = DepInfo[I];
5485 Triples += Dep.DependentToolChain->getTriple().normalize();
5488 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
5492 TCArgs.MakeArgString(Twine(
"-inputs=") + Input.getFilename()));
5497 for (
unsigned I = 0; I < Outputs.size(); ++I) {
5500 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
5502 CmdArgs.push_back(TCArgs.MakeArgString(UB));
5503 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)
Represents a version number in the form major[.minor[.subminor[.build]]].
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC)
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
unsigned CCPrintHeaders
Set CC_PRINT_HEADERS mode, which causes the frontend to log header include information to CCPrintHead...
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type, or null if unspecified.
unsigned CCCUsePCH
Use lazy precompiled headers for PCH support.
static void addExceptionArgs(const ArgList &Args, types::ID InputType, const ToolChain &TC, bool KernelOrKext, const ObjCRuntime &objcRuntime, ArgStringList &CmdArgs)
Adds exception related arguments to the driver command arguments.
void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args, InputList &Inputs) const
BuildInputs - Construct the list of inputs and their types from the given arguments.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Defines types useful for describing an Objective-C runtime.
static void forAllAssociatedToolChains(Compilation &C, const JobAction &JA, const ToolChain &RegularToolChain, llvm::function_ref< void(const ToolChain &)> Work)
Apply Work on the current tool chain RegularToolChain and any other offloading tool chain that is ass...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticBuilder Diag(unsigned DiagID) const
static void QuoteTarget(StringRef Target, SmallVectorImpl< char > &Res)
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args)
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
static bool shouldUseFramePointer(const ArgList &Args, const llvm::Triple &Triple)
static bool UseRelaxAll(Compilation &C, const ArgList &Args)
Check if -relax-all should be passed to the internal assembler.
static StringRef bytes(const std::vector< T, Allocator > &v)
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
bool embedBitcodeMarkerOnly() const
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, bool OFastEnabled, const ArgList &Args, ArgStringList &CmdArgs)
bool isOffloading(OffloadKind OKind) const
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
Action - Represent an abstract compilation step to perform.
static const char * RelocationModelName(llvm::Reloc::Model Model)
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
static void addPGOAndCoverageFlags(Compilation &C, const Driver &D, const InputInfo &Output, const ArgList &Args, ArgStringList &CmdArgs)
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, llvm::StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
types::ID getType() const
bool isDeviceOffloading(OffloadKind OKind) const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
OffloadKind getOffloadingDeviceKind() const
static void RenderSSPOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed, or INVALID if this input is not preprocessed.
static void RenderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, bool EmitCodeView, bool IsWindowsMSVC, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind &DebugInfoKind, const Arg *&SplitDWARFArg)
static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
const ToolChain & getDefaultToolChain() const
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...
const FunctionProtoType * T
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.
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
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)
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
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).
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
bool isSaveTempsEnabled() const
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
static void appendUserToPath(SmallVectorImpl< char > &Result)
'#include ""' paths, added by 'gcc -iquote'.
Dataflow Directional Tag Classes.
const char * CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
static void RenderObjCOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, ObjCRuntime &Runtime, bool InferCovariantReturns, const InputInfo &Input, ArgStringList &CmdArgs)
The basic abstraction for the target Objective-C runtime.
Emit location information but do not generate debug info in the output.
unsigned getMajor() const
Retrieve the major version number.
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)
std::string getAsString() const
Retrieve a string representation of the version number.
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args)
/EH controls whether to run destructor cleanups when exceptions are thrown.
std::string ClangExecutable
The original path to the clang executable.
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Compilation - A set of tasks to perform for a single driver invocation.
const Driver & getDriver() const
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
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 void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 option to specify the debug compilation directory.
static void ParseMRecip(const Driver &D, const ArgList &Args, ArgStringList &OutStrings)
The -mrecip flag requires processing of many optional parameters.
static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec)
Vectorize at all optimization levels greater than 1 except for -Oz.
static bool maybeConsumeDash(const std::string &EH, size_t &I)
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
const char * getClangProgramPath() const
Get the path to the main clang executable.
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
static bool shouldUseLeafFramePointer(const ArgList &Args, const llvm::Triple &Triple)
static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input)
static bool ContainsCompileAction(const Action *A)
Check whether the given input tree contains any compilation actions.
static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A)
static bool ShouldDisableDwarfDirectory(const ArgList &Args, const ToolChain &TC)
bool isLLVMIR(ID Id)
Is this LLVM IR.
static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
const char * getOffloadingArch() const
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs)
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
bool allowsWeak() const
Does this runtime allow the use of __weak?
std::string ResourceDir
The path to the compiler resource directory.