26 #include "clang/Config/config.h"
31 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/Option/ArgList.h"
33 #include "llvm/Support/CodeGen.h"
34 #include "llvm/Support/Compression.h"
35 #include "llvm/Support/FileSystem.h"
36 #include "llvm/Support/Path.h"
37 #include "llvm/Support/Process.h"
38 #include "llvm/Support/TargetParser.h"
39 #include "llvm/Support/YAMLParser.h"
45 using namespace clang::driver;
46 using namespace clang::driver::tools;
47 using namespace clang;
48 using namespace llvm::opt;
52 Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
53 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
54 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
55 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
56 << A->getBaseArg().getAsString(Args)
57 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
64 if (Args.hasArg(options::OPT_static))
66 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
67 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
92 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
97 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
113 Res.push_back(Target[i]);
122 llvm::function_ref<
void(
const ToolChain &)> Work) {
124 Work(RegularToolChain);
135 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
151 const char RefinementStepToken =
':';
152 Position = In.find(RefinementStepToken);
153 if (Position != StringRef::npos) {
154 StringRef Option = A.getOption().getName();
155 StringRef RefStep = In.substr(Position + 1);
163 if (RefStep.size() != 1) {
164 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
167 char RefStepChar = RefStep[0];
168 if (RefStepChar < '0' || RefStepChar >
'9') {
169 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
178 ArgStringList &OutStrings) {
179 StringRef DisabledPrefixIn =
"!";
180 StringRef DisabledPrefixOut =
"!";
181 StringRef EnabledPrefixOut =
"";
182 StringRef Out =
"-mrecip=";
184 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
188 unsigned NumOptions = A->getNumValues();
189 if (NumOptions == 0) {
191 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
196 if (NumOptions == 1) {
197 StringRef Val = A->getValue(0);
201 StringRef ValBase = Val.slice(0, RefStepLoc);
202 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
203 OutStrings.push_back(Args.MakeArgString(Out + Val));
212 llvm::StringMap<bool> OptionStrings;
213 OptionStrings.insert(std::make_pair(
"divd",
false));
214 OptionStrings.insert(std::make_pair(
"divf",
false));
215 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
216 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
217 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
218 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
219 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
220 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
222 for (
unsigned i = 0; i != NumOptions; ++i) {
223 StringRef Val = A->getValue(i);
225 bool IsDisabled = Val.startswith(DisabledPrefixIn);
234 StringRef ValBase = Val.slice(0, RefStep);
235 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
236 if (OptionIter == OptionStrings.end()) {
238 OptionIter = OptionStrings.find(ValBase.str() +
'f');
239 if (OptionIter == OptionStrings.end()) {
241 D.
Diag(diag::err_drv_unknown_argument) << Val;
247 if (OptionStrings[ValBase.str() +
'd']) {
248 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
253 if (OptionIter->second ==
true) {
255 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
260 OptionIter->second =
true;
263 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
264 OptionStrings[ValBase.str() +
'd'] =
true;
267 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
268 Out = Args.MakeArgString(Out + Prefix + Val);
269 if (i != NumOptions - 1)
270 Out = Args.MakeArgString(Out +
",");
273 OutStrings.push_back(Args.MakeArgString(Out));
277 std::vector<StringRef> &Features) {
279 options::OPT_m_hexagon_Features_Group);
281 bool UseLongCalls =
false;
282 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
283 options::OPT_mno_long_calls)) {
284 if (A->getOption().matches(options::OPT_mlong_calls))
288 Features.push_back(UseLongCalls ?
"+long-calls" :
"-long-calls");
292 std::vector<StringRef> &Features) {
297 std::vector<StringRef> &Features) {
298 if (
const Arg *dAbi = Args.getLastArg(options::OPT_mamdgpu_debugger_abi)) {
299 StringRef value = dAbi->getValue();
300 if (value ==
"1.0") {
301 Features.push_back(
"+amdgpu-debugger-insert-nops");
302 Features.push_back(
"+amdgpu-debugger-reserve-regs");
303 Features.push_back(
"+amdgpu-debugger-emit-prologue");
305 D.
Diag(diag::err_drv_clang_unsupported) << dAbi->getAsString(Args);
310 Args, Features, options::OPT_m_amdgpu_Features_Group);
314 const ArgList &Args, ArgStringList &CmdArgs,
317 std::vector<StringRef> Features;
318 switch (Triple.getArch()) {
321 case llvm::Triple::mips:
322 case llvm::Triple::mipsel:
323 case llvm::Triple::mips64:
324 case llvm::Triple::mips64el:
328 case llvm::Triple::arm:
329 case llvm::Triple::armeb:
330 case llvm::Triple::thumb:
331 case llvm::Triple::thumbeb:
335 case llvm::Triple::ppc:
336 case llvm::Triple::ppc64:
337 case llvm::Triple::ppc64le:
340 case llvm::Triple::systemz:
343 case llvm::Triple::aarch64:
344 case llvm::Triple::aarch64_be:
347 case llvm::Triple::x86:
348 case llvm::Triple::x86_64:
351 case llvm::Triple::hexagon:
354 case llvm::Triple::wasm32:
355 case llvm::Triple::wasm64:
358 case llvm::Triple::sparc:
359 case llvm::Triple::sparcel:
360 case llvm::Triple::sparcv9:
363 case llvm::Triple::r600:
364 case llvm::Triple::amdgcn:
370 llvm::StringMap<unsigned> LastOpt;
371 for (
unsigned I = 0, N = Features.size();
I < N; ++
I) {
372 StringRef
Name = Features[
I];
373 assert(Name[0] ==
'-' || Name[0] ==
'+');
374 LastOpt[Name.drop_front(1)] =
I;
377 for (
unsigned I = 0, N = Features.size();
I < N; ++
I) {
379 StringRef
Name = Features[
I];
380 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
381 assert(LastI != LastOpt.end());
382 unsigned Last = LastI->second;
386 CmdArgs.push_back(
"-target-feature");
387 CmdArgs.push_back(Name.data());
393 const llvm::Triple &Triple) {
400 if (!Triple.isMacOSX())
403 return (!Triple.isMacOSXVersionLT(10, 5) &&
404 (Triple.getArch() == llvm::Triple::x86_64 ||
405 Triple.getArch() == llvm::Triple::arm));
415 ArgStringList &CmdArgs) {
417 const llvm::Triple &Triple = TC.
getTriple();
422 Args.ClaimAllArgs(options::OPT_fexceptions);
423 Args.ClaimAllArgs(options::OPT_fno_exceptions);
424 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
425 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
426 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
427 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
432 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
438 Args.hasFlag(options::OPT_fobjc_exceptions,
439 options::OPT_fno_objc_exceptions,
true)) {
440 CmdArgs.push_back(
"-fobjc-exceptions");
447 bool CXXExceptionsEnabled =
448 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
449 Arg *ExceptionArg = Args.getLastArg(
450 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
451 options::OPT_fexceptions, options::OPT_fno_exceptions);
453 CXXExceptionsEnabled =
454 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
455 ExceptionArg->getOption().matches(options::OPT_fexceptions);
457 if (CXXExceptionsEnabled) {
458 if (Triple.isPS4CPU()) {
460 assert(ExceptionArg &&
461 "On the PS4 exceptions should only be enabled if passing "
465 assert(RTTIArg &&
"RTTI disabled explicitly but no RTTIArg!");
466 D.
Diag(diag::err_drv_argument_not_allowed_with)
467 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
469 D.
Diag(diag::warn_drv_enabling_rtti_with_exceptions);
473 CmdArgs.push_back(
"-fcxx-exceptions");
480 CmdArgs.push_back(
"-fexceptions");
490 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
496 bool UseDwarfDirectory =
497 Args.hasFlag(options::OPT_fdwarf_directory_asm,
499 return !UseDwarfDirectory;
505 assert(A.getOption().matches(options::OPT_gN_Group) &&
506 "Not a -g option that specifies a debug-info level");
507 if (A.getOption().matches(options::OPT_g0) ||
508 A.getOption().matches(options::OPT_ggdb0))
510 if (A.getOption().matches(options::OPT_gline_tables_only) ||
511 A.getOption().matches(options::OPT_ggdb1))
517 switch (Triple.getArch()){
520 case llvm::Triple::arm:
521 case llvm::Triple::thumb:
524 return Triple.isOSDarwin();
529 const llvm::Triple &Triple) {
530 switch (Triple.getArch()) {
531 case llvm::Triple::xcore:
532 case llvm::Triple::wasm32:
533 case llvm::Triple::wasm64:
541 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI) {
542 switch (Triple.getArch()) {
544 case llvm::Triple::mips64:
545 case llvm::Triple::mips64el:
546 case llvm::Triple::mips:
547 case llvm::Triple::mipsel:
548 case llvm::Triple::ppc:
549 case llvm::Triple::ppc64:
550 case llvm::Triple::ppc64le:
551 case llvm::Triple::systemz:
552 case llvm::Triple::x86:
553 case llvm::Triple::x86_64:
560 if (Triple.isOSWindows()) {
561 switch (Triple.getArch()) {
562 case llvm::Triple::x86:
564 case llvm::Triple::x86_64:
565 return Triple.isOSBinFormatMachO();
566 case llvm::Triple::arm:
567 case llvm::Triple::thumb:
581 const llvm::Triple &Triple) {
582 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
583 options::OPT_fomit_frame_pointer))
584 return A->getOption().matches(options::OPT_fno_omit_frame_pointer) ||
587 if (Args.hasArg(options::OPT_pg))
594 const llvm::Triple &Triple) {
595 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
596 options::OPT_momit_leaf_frame_pointer))
597 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
599 if (Args.hasArg(options::OPT_pg))
602 if (Triple.isPS4CPU())
611 if (!llvm::sys::fs::current_path(cwd)) {
612 CmdArgs.push_back(
"-fdebug-compilation-dir");
613 CmdArgs.push_back(Args.MakeArgString(cwd));
620 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
621 if (A->getOption().matches(options::OPT_O4) ||
622 A->getOption().matches(options::OPT_Ofast))
625 if (A->getOption().matches(options::OPT_O0))
628 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
631 StringRef
S(A->getValue());
639 unsigned OptLevel = 0;
640 if (
S.getAsInteger(10, OptLevel))
651 ArgStringList &CmdArgs) {
654 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
657 CmdArgs.push_back(
"-x");
658 if (Args.hasArg(options::OPT_rewrite_objc))
664 const char *ClangType;
666 case types::TY_CXXModule:
669 case types::TY_PP_CXXModule:
670 ClangType =
"c++-cpp-output";
676 CmdArgs.push_back(ClangType);
682 const char *Username = getenv(
"LOGNAME");
684 const char *Username = getenv(
"USERNAME");
689 for (
const char *
P = Username; *
P; ++
P, ++Len) {
696 if (Username && Len > 0) {
697 Result.append(Username, Username + Len);
704 std::string UID = llvm::utostr(getuid());
707 std::string UID =
"9999";
709 Result.append(UID.begin(), UID.end());
713 const InputInfo &Output,
const ArgList &Args,
714 ArgStringList &CmdArgs) {
716 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
717 options::OPT_fprofile_generate_EQ,
718 options::OPT_fno_profile_generate);
719 if (PGOGenerateArg &&
720 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
721 PGOGenerateArg =
nullptr;
723 auto *ProfileGenerateArg = Args.getLastArg(
724 options::OPT_fprofile_instr_generate,
725 options::OPT_fprofile_instr_generate_EQ,
726 options::OPT_fno_profile_instr_generate);
727 if (ProfileGenerateArg &&
728 ProfileGenerateArg->getOption().matches(
729 options::OPT_fno_profile_instr_generate))
730 ProfileGenerateArg =
nullptr;
732 if (PGOGenerateArg && ProfileGenerateArg)
733 D.
Diag(diag::err_drv_argument_not_allowed_with)
734 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
738 if (PGOGenerateArg && ProfileUseArg)
739 D.
Diag(diag::err_drv_argument_not_allowed_with)
740 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
742 if (ProfileGenerateArg && ProfileUseArg)
743 D.
Diag(diag::err_drv_argument_not_allowed_with)
744 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
746 if (ProfileGenerateArg) {
747 if (ProfileGenerateArg->getOption().matches(
748 options::OPT_fprofile_instr_generate_EQ))
749 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
750 ProfileGenerateArg->getValue()));
752 CmdArgs.push_back(
"-fprofile-instrument=clang");
755 if (PGOGenerateArg) {
756 CmdArgs.push_back(
"-fprofile-instrument=llvm");
757 if (PGOGenerateArg->getOption().matches(
758 options::OPT_fprofile_generate_EQ)) {
760 llvm::sys::path::append(Path,
"default_%m.profraw");
762 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
767 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
768 CmdArgs.push_back(Args.MakeArgString(
769 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
770 else if ((ProfileUseArg->getOption().matches(
771 options::OPT_fprofile_use_EQ) ||
772 ProfileUseArg->getOption().matches(
773 options::OPT_fprofile_instr_use))) {
775 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
776 if (Path.empty() || llvm::sys::fs::is_directory(Path))
777 llvm::sys::path::append(Path,
"default.profdata");
779 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
783 if (Args.hasArg(options::OPT_ftest_coverage) ||
784 Args.hasArg(options::OPT_coverage))
785 CmdArgs.push_back(
"-femit-coverage-notes");
786 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
788 Args.hasArg(options::OPT_coverage))
789 CmdArgs.push_back(
"-femit-coverage-data");
791 if (Args.hasFlag(options::OPT_fcoverage_mapping,
792 options::OPT_fno_coverage_mapping,
false)) {
793 if (!ProfileGenerateArg)
794 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
795 <<
"-fcoverage-mapping"
796 <<
"-fprofile-instr-generate";
798 CmdArgs.push_back(
"-fcoverage-mapping");
801 if (C.
getArgs().hasArg(options::OPT_c) ||
802 C.
getArgs().hasArg(options::OPT_S)) {
804 CmdArgs.push_back(
"-coverage-notes-file");
806 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
807 OutputFilename = FinalOutput->getValue();
809 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
811 if (llvm::sys::path::is_relative(CoverageFilename)) {
813 if (!llvm::sys::fs::current_path(Pwd)) {
814 llvm::sys::path::append(Pwd, CoverageFilename);
815 CoverageFilename.swap(Pwd);
818 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
819 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
825 if (Args.hasArg(options::OPT_fprofile_arcs) ||
826 Args.hasArg(options::OPT_coverage)) {
827 CmdArgs.push_back(
"-coverage-data-file");
828 if (Arg *FProfileDir = Args.getLastArg(options::OPT_fprofile_dir)) {
829 CoverageFilename = FProfileDir->getValue();
830 llvm::sys::path::append(CoverageFilename, OutputFilename);
832 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
833 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
841 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
844 for (
const auto &AI : A->
inputs())
854 bool RelaxDefault =
true;
856 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
857 RelaxDefault = A->getOption().matches(options::OPT_O0);
860 RelaxDefault =
false;
869 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
877 return llvm::StringSwitch<unsigned>(ArgValue)
878 .Case(
"-gdwarf-2", 2)
879 .Case(
"-gdwarf-3", 3)
880 .Case(
"-gdwarf-4", 4)
881 .Case(
"-gdwarf-5", 5)
887 unsigned DwarfVersion,
888 llvm::DebuggerKind DebuggerTuning) {
889 switch (DebugInfoKind) {
891 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
894 CmdArgs.push_back(
"-debug-info-kind=limited");
897 CmdArgs.push_back(
"-debug-info-kind=standalone");
902 if (DwarfVersion > 0)
904 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
905 switch (DebuggerTuning) {
906 case llvm::DebuggerKind::GDB:
907 CmdArgs.push_back(
"-debugger-tuning=gdb");
909 case llvm::DebuggerKind::LLDB:
910 CmdArgs.push_back(
"-debugger-tuning=lldb");
912 case llvm::DebuggerKind::SCE:
913 CmdArgs.push_back(
"-debugger-tuning=sce");
921 ArgStringList &CmdArgs,
923 const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ);
927 if (A->getOption().getID() == options::OPT_gz) {
928 if (llvm::zlib::isAvailable())
929 CmdArgs.push_back(
"-compress-debug-sections");
931 D.
Diag(diag::warn_debug_compression_unavailable);
935 StringRef
Value = A->getValue();
936 if (Value ==
"none") {
937 CmdArgs.push_back(
"-compress-debug-sections=none");
938 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
939 if (llvm::zlib::isAvailable()) {
941 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
943 D.
Diag(diag::warn_debug_compression_unavailable);
946 D.
Diag(diag::err_drv_unsupported_option_argument)
947 << A->getOption().getName() <<
Value;
953 case llvm::Reloc::Static:
955 case llvm::Reloc::PIC_:
957 case llvm::Reloc::DynamicNoPIC:
958 return "dynamic-no-pic";
959 case llvm::Reloc::ROPI:
961 case llvm::Reloc::RWPI:
963 case llvm::Reloc::ROPI_RWPI:
966 llvm_unreachable(
"Unknown Reloc::Model kind");
970 const Driver &D,
const ArgList &Args,
971 ArgStringList &CmdArgs,
975 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
979 Args.AddLastArg(CmdArgs, options::OPT_C);
980 Args.AddLastArg(CmdArgs, options::OPT_CC);
983 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
984 (A = Args.getLastArg(options::OPT_MD)) ||
985 (A = Args.getLastArg(options::OPT_MMD))) {
988 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
989 DepFile = MF->getValue();
991 }
else if (Output.
getType() == types::TY_Dependencies) {
993 }
else if (A->getOption().matches(options::OPT_M) ||
994 A->getOption().matches(options::OPT_MM)) {
997 DepFile = getDependencyFileName(Args, Inputs);
1000 CmdArgs.push_back(
"-dependency-file");
1001 CmdArgs.push_back(DepFile);
1004 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
1005 const char *DepTarget;
1009 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1010 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1011 DepTarget = OutputOpt->getValue();
1017 llvm::sys::path::replace_extension(
P,
"o");
1018 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1021 if (!A->getOption().matches(options::OPT_MD) && !A->getOption().matches(options::OPT_MMD)) {
1022 CmdArgs.push_back(
"-w");
1024 CmdArgs.push_back(
"-MT");
1027 CmdArgs.push_back(Args.MakeArgString(Quoted));
1030 if (A->getOption().matches(options::OPT_M) ||
1031 A->getOption().matches(options::OPT_MD))
1032 CmdArgs.push_back(
"-sys-header-deps");
1033 if ((isa<PrecompileJobAction>(JA) &&
1034 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1035 Args.hasArg(options::OPT_fmodule_file_deps))
1036 CmdArgs.push_back(
"-module-file-deps");
1039 if (Args.hasArg(options::OPT_MG)) {
1040 if (!A || A->getOption().matches(options::OPT_MD) ||
1041 A->getOption().matches(options::OPT_MMD))
1042 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1043 CmdArgs.push_back(
"-MG");
1046 Args.AddLastArg(CmdArgs, options::OPT_MP);
1047 Args.AddLastArg(CmdArgs, options::OPT_MV);
1050 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1053 if (A->getOption().matches(options::OPT_MQ)) {
1054 CmdArgs.push_back(
"-MT");
1057 CmdArgs.push_back(Args.MakeArgString(Quoted));
1061 A->render(Args, CmdArgs);
1070 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1077 int YcIndex = -1, YuIndex = -1;
1080 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1081 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1082 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1086 if (!A->getOption().matches(options::OPT_include))
1088 if (YcArg && strcmp(A->getValue(), YcArg->getValue()) == 0)
1090 if (YuArg && strcmp(A->getValue(), YuArg->getValue()) == 0)
1094 if (isa<PrecompileJobAction>(JA) && YcIndex != -1) {
1097 assert(Inputs.size() == 1 &&
"Need one input when building pch");
1098 CmdArgs.push_back(Args.MakeArgString(Twine(
"-find-pch-source=") +
1099 Inputs[0].second->getValue()));
1102 bool RenderedImplicitInclude =
false;
1104 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1107 if (getToolChain().getDriver().IsCLMode() &&
1108 A->getOption().matches(options::OPT_include)) {
1121 int PchIndex = YcIndex != -1 ? YcIndex : YuIndex;
1122 if (PchIndex != -1) {
1123 if (isa<PrecompileJobAction>(JA)) {
1125 assert(YcIndex != -1 && PchIndex == YcIndex);
1130 if (AI < PchIndex) {
1134 if (AI == PchIndex) {
1136 CmdArgs.push_back(
"-include-pch");
1143 }
else if (A->getOption().matches(options::OPT_include)) {
1145 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1146 RenderedImplicitInclude =
true;
1151 bool FoundPTH =
false;
1152 bool FoundPCH =
false;
1158 llvm::sys::path::replace_extension(P,
"pch");
1159 if (llvm::sys::fs::exists(P))
1164 llvm::sys::path::replace_extension(P,
"pth");
1165 if (llvm::sys::fs::exists(P))
1169 if (!FoundPCH && !FoundPTH) {
1170 llvm::sys::path::replace_extension(P,
"gch");
1171 if (llvm::sys::fs::exists(P)) {
1177 if (FoundPCH || FoundPTH) {
1178 if (IsFirstImplicitInclude) {
1181 CmdArgs.push_back(
"-include-pch");
1183 CmdArgs.push_back(
"-include-pth");
1184 CmdArgs.push_back(Args.MakeArgString(P));
1188 D.
Diag(diag::warn_drv_pch_not_first_include) << P
1189 << A->getAsString(Args);
1192 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1203 A->render(Args, CmdArgs);
1206 Args.AddAllArgs(CmdArgs,
1207 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1208 options::OPT_F, options::OPT_index_header_map});
1216 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1217 options::OPT_Xpreprocessor);
1220 if (Arg *A = Args.getLastArg(options::OPT_I_))
1221 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1226 if (sysroot !=
"") {
1227 if (!Args.hasArg(options::OPT_isysroot)) {
1228 CmdArgs.push_back(
"-isysroot");
1229 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
1246 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1255 [&Args, &CmdArgs](
const ToolChain &TC) {
1262 [&Args, &CmdArgs](
const ToolChain &TC) {
1267 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1273 switch (Triple.getArch()) {
1277 case llvm::Triple::aarch64:
1278 case llvm::Triple::aarch64_be:
1279 case llvm::Triple::arm:
1280 case llvm::Triple::armeb:
1281 case llvm::Triple::thumb:
1282 case llvm::Triple::thumbeb:
1283 if (Triple.isOSDarwin() || Triple.isOSWindows())
1287 case llvm::Triple::ppc:
1288 case llvm::Triple::ppc64:
1289 if (Triple.isOSDarwin())
1293 case llvm::Triple::hexagon:
1294 case llvm::Triple::ppc64le:
1295 case llvm::Triple::systemz:
1296 case llvm::Triple::xcore:
1302 switch (Triple.getArch()) {
1306 case llvm::Triple::xcore:
1307 case llvm::Triple::wasm32:
1308 case llvm::Triple::wasm64:
1313 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1314 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1318 const char *ABIName =
nullptr;
1319 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1320 ABIName = A->getValue();
1322 std::string CPU =
getCPUName(Args, Triple,
false);
1323 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1326 CmdArgs.push_back(
"-target-abi");
1327 CmdArgs.push_back(ABIName);
1334 CmdArgs.push_back(
"-msoft-float");
1335 CmdArgs.push_back(
"-mfloat-abi");
1336 CmdArgs.push_back(
"soft");
1339 CmdArgs.push_back(
"-mfloat-abi");
1340 CmdArgs.push_back(
"soft");
1344 CmdArgs.push_back(
"-mfloat-abi");
1345 CmdArgs.push_back(
"hard");
1349 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1350 options::OPT_mno_global_merge)) {
1351 CmdArgs.push_back(
"-backend-option");
1352 if (A->getOption().matches(options::OPT_mno_global_merge))
1353 CmdArgs.push_back(
"-arm-global-merge=false");
1355 CmdArgs.push_back(
"-arm-global-merge=true");
1358 if (!Args.hasFlag(options::OPT_mimplicit_float,
1359 options::OPT_mno_implicit_float,
true))
1360 CmdArgs.push_back(
"-no-implicit-float");
1363 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1364 ArgStringList &CmdArgs)
const {
1365 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1367 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1368 Args.hasArg(options::OPT_mkernel) ||
1369 Args.hasArg(options::OPT_fapple_kext))
1370 CmdArgs.push_back(
"-disable-red-zone");
1372 if (!Args.hasFlag(options::OPT_mimplicit_float,
1373 options::OPT_mno_implicit_float,
true))
1374 CmdArgs.push_back(
"-no-implicit-float");
1376 const char *ABIName =
nullptr;
1377 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1378 ABIName = A->getValue();
1379 else if (Triple.isOSDarwin())
1380 ABIName =
"darwinpcs";
1384 CmdArgs.push_back(
"-target-abi");
1385 CmdArgs.push_back(ABIName);
1387 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1388 options::OPT_mno_fix_cortex_a53_835769)) {
1389 CmdArgs.push_back(
"-backend-option");
1390 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1391 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1393 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1394 }
else if (Triple.isAndroid()) {
1396 CmdArgs.push_back(
"-backend-option");
1397 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1401 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1402 options::OPT_mno_global_merge)) {
1403 CmdArgs.push_back(
"-backend-option");
1404 if (A->getOption().matches(options::OPT_mno_global_merge))
1405 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1407 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1411 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1412 ArgStringList &CmdArgs)
const {
1413 const Driver &D = getToolChain().getDriver();
1416 const llvm::Triple &Triple = getToolChain().getTriple();
1419 CmdArgs.push_back(
"-target-abi");
1420 CmdArgs.push_back(ABIName.data());
1425 CmdArgs.push_back(
"-msoft-float");
1426 CmdArgs.push_back(
"-mfloat-abi");
1427 CmdArgs.push_back(
"soft");
1431 CmdArgs.push_back(
"-mfloat-abi");
1432 CmdArgs.push_back(
"hard");
1435 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1436 if (A->getOption().matches(options::OPT_mxgot)) {
1437 CmdArgs.push_back(
"-mllvm");
1438 CmdArgs.push_back(
"-mxgot");
1442 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1443 options::OPT_mno_ldc1_sdc1)) {
1444 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1445 CmdArgs.push_back(
"-mllvm");
1446 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1450 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1451 options::OPT_mno_check_zero_division)) {
1452 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1453 CmdArgs.push_back(
"-mllvm");
1454 CmdArgs.push_back(
"-mno-check-zero-division");
1458 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1459 StringRef
v = A->getValue();
1460 CmdArgs.push_back(
"-mllvm");
1461 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1465 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1466 StringRef Val = StringRef(A->getValue());
1468 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1469 CmdArgs.push_back(
"-mllvm");
1470 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1472 D.
Diag(diag::err_drv_unsupported_option_argument)
1473 << A->getOption().getName() << Val;
1475 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1479 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1480 ArgStringList &CmdArgs)
const {
1482 const char *ABIName =
nullptr;
1483 if (getToolChain().getTriple().isOSLinux())
1484 switch (getToolChain().getArch()) {
1485 case llvm::Triple::ppc64: {
1489 bool HasQPX =
false;
1490 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1491 HasQPX = A->getValue() == StringRef(
"a2q");
1492 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1494 ABIName =
"elfv1-qpx";
1501 case llvm::Triple::ppc64le:
1508 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1512 if (StringRef(A->getValue()) !=
"altivec")
1513 ABIName = A->getValue();
1520 CmdArgs.push_back(
"-msoft-float");
1521 CmdArgs.push_back(
"-mfloat-abi");
1522 CmdArgs.push_back(
"soft");
1526 CmdArgs.push_back(
"-mfloat-abi");
1527 CmdArgs.push_back(
"hard");
1531 CmdArgs.push_back(
"-target-abi");
1532 CmdArgs.push_back(ABIName);
1536 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1537 ArgStringList &CmdArgs)
const {
1543 CmdArgs.push_back(
"-msoft-float");
1544 CmdArgs.push_back(
"-mfloat-abi");
1545 CmdArgs.push_back(
"soft");
1549 CmdArgs.push_back(
"-mfloat-abi");
1550 CmdArgs.push_back(
"hard");
1554 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
1555 ArgStringList &CmdArgs)
const {
1556 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false))
1557 CmdArgs.push_back(
"-mbackchain");
1560 void Clang::AddX86TargetArgs(
const ArgList &Args,
1561 ArgStringList &CmdArgs)
const {
1562 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1563 Args.hasArg(options::OPT_mkernel) ||
1564 Args.hasArg(options::OPT_fapple_kext))
1565 CmdArgs.push_back(
"-disable-red-zone");
1569 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1570 Args.hasArg(options::OPT_fapple_kext));
1571 if (Arg *A = Args.getLastArg(
1572 options::OPT_msoft_float, options::OPT_mno_soft_float,
1573 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
1574 const Option &O = A->getOption();
1575 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1576 O.matches(options::OPT_msoft_float));
1578 if (NoImplicitFloat)
1579 CmdArgs.push_back(
"-no-implicit-float");
1581 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1582 StringRef
Value = A->getValue();
1583 if (Value ==
"intel" || Value ==
"att") {
1584 CmdArgs.push_back(
"-mllvm");
1585 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
1587 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1588 << A->getOption().getName() <<
Value;
1593 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
1594 CmdArgs.push_back(
"-mfloat-abi");
1595 CmdArgs.push_back(
"soft");
1596 CmdArgs.push_back(
"-mstack-alignment=4");
1600 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
1601 ArgStringList &CmdArgs)
const {
1602 CmdArgs.push_back(
"-mqdsp6-compat");
1603 CmdArgs.push_back(
"-Wreturn-type");
1606 std::string N = llvm::utostr(G.getValue());
1607 std::string Opt = std::string(
"-hexagon-small-data-threshold=") + N;
1608 CmdArgs.push_back(
"-mllvm");
1609 CmdArgs.push_back(Args.MakeArgString(Opt));
1612 if (!Args.hasArg(options::OPT_fno_short_enums))
1613 CmdArgs.push_back(
"-fshort-enums");
1614 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1615 CmdArgs.push_back(
"-mllvm");
1616 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
1618 CmdArgs.push_back(
"-mllvm");
1619 CmdArgs.push_back(
"-machine-sink-split=0");
1622 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
1623 ArgStringList &CmdArgs)
const {
1624 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1625 StringRef CPUName = A->getValue();
1627 CmdArgs.push_back(
"-target-cpu");
1628 CmdArgs.push_back(Args.MakeArgString(CPUName));
1630 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1631 StringRef Value = A->getValue();
1635 if (Value.getAsInteger(10, Mregparm)) {
1636 if (Mregparm != 4) {
1637 getToolChain().getDriver().Diag(
1638 diag::err_drv_unsupported_option_argument)
1639 << A->getOption().getName() <<
Value;
1645 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
1646 ArgStringList &CmdArgs)
const {
1648 if (!Args.hasArg(options::OPT_fvisibility_EQ,
1649 options::OPT_fvisibility_ms_compat)) {
1650 CmdArgs.push_back(
"-fvisibility");
1651 CmdArgs.push_back(
"hidden");
1656 StringRef Target,
const InputInfo &Output,
1659 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH))
1662 using llvm::yaml::escape;
1663 const Driver &D = getToolChain().getDriver();
1665 if (!CompilationDatabase) {
1667 auto File = llvm::make_unique<llvm::raw_fd_ostream>(
Filename, EC, llvm::sys::fs::F_Text);
1669 D.
Diag(clang::diag::err_drv_compilationdatabase) << Filename
1673 CompilationDatabase = std::move(File);
1675 auto &CDB = *CompilationDatabase;
1677 if (llvm::sys::fs::current_path(Buf))
1679 CDB <<
"{ \"directory\": \"" << escape(Buf) <<
"\"";
1680 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
1681 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
1685 CDB <<
", \"" << escape(Buf) <<
"\"";
1686 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
1689 CDB <<
", \"" << escape(Buf) <<
"\"";
1691 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
1692 for (
auto &A: Args) {
1693 auto &O = A->getOption();
1695 if (O.getID() == options::OPT_x)
1698 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
1701 if (O.getKind() == Option::InputClass)
1705 A->render(Args, ASL);
1707 CDB <<
", \"" << escape(it) <<
"\"";
1711 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
1715 const ArgList &Args,
1716 ArgStringList &CmdArgs,
1719 CmdArgs.push_back(
"-mrelax-all");
1723 bool DefaultIncrementalLinkerCompatible =
1725 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
1726 options::OPT_mno_incremental_linker_compatible,
1727 DefaultIncrementalLinkerCompatible))
1728 CmdArgs.push_back(
"-mincremental-linker-compatible");
1731 case llvm::Triple::arm:
1732 case llvm::Triple::armeb:
1733 case llvm::Triple::thumb:
1734 case llvm::Triple::thumbeb:
1735 if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) {
1736 StringRef Value = A->getValue();
1737 if (Value ==
"always" || Value ==
"never" || Value ==
"arm" ||
1739 CmdArgs.push_back(
"-mllvm");
1740 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" + Value));
1742 D.
Diag(diag::err_drv_unsupported_option_argument)
1743 << A->getOption().getName() <<
Value;
1756 bool TakeNextArg =
false;
1758 bool UseRelaxRelocations = ENABLE_X86_RELAX_RELOCATIONS;
1759 const char *MipsTargetFeature =
nullptr;
1761 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
1764 for (StringRef Value : A->getValues()) {
1766 CmdArgs.push_back(Value.data());
1767 TakeNextArg =
false;
1772 Value ==
"-mbig-obj")
1778 case llvm::Triple::mips:
1779 case llvm::Triple::mipsel:
1780 case llvm::Triple::mips64:
1781 case llvm::Triple::mips64el:
1782 if (Value ==
"--trap") {
1783 CmdArgs.push_back(
"-target-feature");
1784 CmdArgs.push_back(
"+use-tcc-in-div");
1787 if (Value ==
"--break") {
1788 CmdArgs.push_back(
"-target-feature");
1789 CmdArgs.push_back(
"-use-tcc-in-div");
1792 if (Value.startswith(
"-msoft-float")) {
1793 CmdArgs.push_back(
"-target-feature");
1794 CmdArgs.push_back(
"+soft-float");
1797 if (Value.startswith(
"-mhard-float")) {
1798 CmdArgs.push_back(
"-target-feature");
1799 CmdArgs.push_back(
"-soft-float");
1803 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
1804 .Case(
"-mips1",
"+mips1")
1805 .Case(
"-mips2",
"+mips2")
1806 .Case(
"-mips3",
"+mips3")
1807 .Case(
"-mips4",
"+mips4")
1808 .Case(
"-mips5",
"+mips5")
1809 .Case(
"-mips32",
"+mips32")
1810 .Case(
"-mips32r2",
"+mips32r2")
1811 .Case(
"-mips32r3",
"+mips32r3")
1812 .Case(
"-mips32r5",
"+mips32r5")
1813 .Case(
"-mips32r6",
"+mips32r6")
1814 .Case(
"-mips64",
"+mips64")
1815 .Case(
"-mips64r2",
"+mips64r2")
1816 .Case(
"-mips64r3",
"+mips64r3")
1817 .Case(
"-mips64r5",
"+mips64r5")
1818 .Case(
"-mips64r6",
"+mips64r6")
1820 if (MipsTargetFeature)
1824 if (Value ==
"-force_cpusubtype_ALL") {
1826 }
else if (Value ==
"-L") {
1827 CmdArgs.push_back(
"-msave-temp-labels");
1828 }
else if (Value ==
"--fatal-warnings") {
1829 CmdArgs.push_back(
"-massembler-fatal-warnings");
1830 }
else if (Value ==
"--noexecstack") {
1831 CmdArgs.push_back(
"-mnoexecstack");
1832 }
else if (Value.startswith(
"-compress-debug-sections") ||
1833 Value.startswith(
"--compress-debug-sections") ||
1834 Value ==
"-nocompress-debug-sections" ||
1835 Value ==
"--nocompress-debug-sections") {
1836 CmdArgs.push_back(Value.data());
1837 }
else if (Value ==
"-mrelax-relocations=yes" ||
1838 Value ==
"--mrelax-relocations=yes") {
1839 UseRelaxRelocations =
true;
1840 }
else if (Value ==
"-mrelax-relocations=no" ||
1841 Value ==
"--mrelax-relocations=no") {
1842 UseRelaxRelocations =
false;
1843 }
else if (Value.startswith(
"-I")) {
1844 CmdArgs.push_back(Value.data());
1849 }
else if (Value.startswith(
"-gdwarf-")) {
1852 if (DwarfVersion == 0) {
1853 CmdArgs.push_back(Value.data());
1859 }
else if (Value.startswith(
"-mcpu") || Value.startswith(
"-mfpu") ||
1860 Value.startswith(
"-mhwdiv") || Value.startswith(
"-march")) {
1862 }
else if (Value ==
"-defsym") {
1863 if (A->getNumValues() != 2) {
1864 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
1867 const char *
S = A->getValue(1);
1868 auto Pair = StringRef(S).split(
'=');
1869 auto Sym = Pair.first;
1870 auto SVal = Pair.second;
1872 if (Sym.empty() || SVal.empty()) {
1873 D.
Diag(diag::err_drv_defsym_invalid_format) <<
S;
1877 if (SVal.getAsInteger(0, IVal)) {
1878 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
1881 CmdArgs.push_back(Value.data());
1884 D.
Diag(diag::err_drv_unsupported_option_argument)
1885 << A->getOption().getName() <<
Value;
1889 if (UseRelaxRelocations)
1890 CmdArgs.push_back(
"--mrelax-relocations");
1891 if (MipsTargetFeature !=
nullptr) {
1892 CmdArgs.push_back(
"-target-feature");
1893 CmdArgs.push_back(MipsTargetFeature);
1899 const ArgList &Args,
const char *LinkingOutput)
const {
1900 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1901 const std::string &TripleStr = Triple.getTriple();
1904 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
1905 const Driver &D = getToolChain().getDriver();
1906 ArgStringList CmdArgs;
1909 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
1917 assert((IsCuda || (IsOpenMPDevice && Inputs.size() == 2) ||
1918 Inputs.size() == 1) &&
1919 "Unable to handle multiple inputs.");
1921 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
1922 bool IsWindowsCygnus =
1923 getToolChain().getTriple().isWindowsCygwinEnvironment();
1924 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
1925 bool IsPS4CPU = getToolChain().getTriple().isPS4CPU();
1926 bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
1932 const llvm::Triple *AuxTriple = getToolChain().getAuxTriple();
1933 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
1934 IsWindowsGNU |= AuxTriple && AuxTriple->isWindowsGNUEnvironment();
1935 IsWindowsCygnus |= AuxTriple && AuxTriple->isWindowsCygwinEnvironment();
1940 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
1945 CmdArgs.push_back(
"-cc1");
1948 CmdArgs.push_back(
"-triple");
1949 CmdArgs.push_back(Args.MakeArgString(TripleStr));
1951 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
1952 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output,
Input, Args);
1953 Args.ClaimAllArgs(options::OPT_MJ);
1959 std::string NormalizedTriple;
1969 CmdArgs.push_back(
"-aux-triple");
1970 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
1973 if (IsOpenMPDevice) {
1975 std::string NormalizedTriple =
1979 CmdArgs.push_back(
"-aux-triple");
1980 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
1983 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
1984 Triple.getArch() == llvm::Triple::thumb)) {
1985 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
1987 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
1989 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
1996 getToolChain().addClangWarningOptions(CmdArgs);
1999 RewriteKind rewriteKind = RK_None;
2001 if (isa<AnalyzeJobAction>(JA)) {
2002 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
2003 CmdArgs.push_back(
"-analyze");
2004 }
else if (isa<MigrateJobAction>(JA)) {
2005 CmdArgs.push_back(
"-migrate");
2006 }
else if (isa<PreprocessJobAction>(JA)) {
2007 if (Output.
getType() == types::TY_Dependencies)
2008 CmdArgs.push_back(
"-Eonly");
2010 CmdArgs.push_back(
"-E");
2011 if (Args.hasArg(options::OPT_rewrite_objc) &&
2012 !Args.hasArg(options::OPT_g_Group))
2013 CmdArgs.push_back(
"-P");
2015 }
else if (isa<AssembleJobAction>(JA)) {
2016 CmdArgs.push_back(
"-emit-obj");
2021 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
2022 }
else if (isa<PrecompileJobAction>(JA)) {
2026 if (JA.
getType() == types::TY_Nothing)
2027 CmdArgs.push_back(
"-fsyntax-only");
2028 else if (JA.
getType() == types::TY_ModuleFile)
2029 CmdArgs.push_back(
"-emit-module-interface");
2031 CmdArgs.push_back(
"-emit-pch");
2033 CmdArgs.push_back(
"-emit-pth");
2034 }
else if (isa<VerifyPCHJobAction>(JA)) {
2035 CmdArgs.push_back(
"-verify-pch");
2037 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2038 "Invalid action for clang tool.");
2039 if (JA.
getType() == types::TY_Nothing) {
2040 CmdArgs.push_back(
"-fsyntax-only");
2041 }
else if (JA.
getType() == types::TY_LLVM_IR ||
2042 JA.
getType() == types::TY_LTO_IR) {
2043 CmdArgs.push_back(
"-emit-llvm");
2044 }
else if (JA.
getType() == types::TY_LLVM_BC ||
2045 JA.
getType() == types::TY_LTO_BC) {
2046 CmdArgs.push_back(
"-emit-llvm-bc");
2047 }
else if (JA.
getType() == types::TY_PP_Asm) {
2048 CmdArgs.push_back(
"-S");
2049 }
else if (JA.
getType() == types::TY_AST) {
2050 CmdArgs.push_back(
"-emit-pch");
2051 }
else if (JA.
getType() == types::TY_ModuleFile) {
2052 CmdArgs.push_back(
"-module-file-info");
2053 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
2054 CmdArgs.push_back(
"-rewrite-objc");
2055 rewriteKind = RK_NonFragile;
2056 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
2057 CmdArgs.push_back(
"-rewrite-objc");
2058 rewriteKind = RK_Fragile;
2060 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
2067 if (JA.
getType() == types::TY_LLVM_BC)
2068 CmdArgs.push_back(
"-emit-llvm-uselists");
2071 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
2076 if (!(getToolChain().getTriple().isOSDarwin() ||
2077 getToolChain().getTriple().isPS4()) ||
2079 CmdArgs.push_back(
"-flto-unit");
2083 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
2085 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
2087 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
2092 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
2094 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2096 CmdArgs.push_back(
"-disable-llvm-passes");
2099 CmdArgs.push_back(
"-fembed-bitcode=marker");
2105 CmdArgs.push_back(
"-disable-free");
2109 CmdArgs.push_back(
"-disable-llvm-verifier");
2111 CmdArgs.push_back(
"-discard-value-names");
2116 CmdArgs.push_back(
"-main-file-name");
2117 CmdArgs.push_back(getBaseInputName(Args, Input));
2121 if (Args.hasArg(options::OPT_static))
2122 CmdArgs.push_back(
"-static-define");
2124 if (isa<AnalyzeJobAction>(JA)) {
2126 CmdArgs.push_back(
"-analyzer-store=region");
2129 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
2131 CmdArgs.push_back(
"-analyzer-eagerly-assume");
2134 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2135 CmdArgs.push_back(
"-analyzer-checker=core");
2136 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
2138 if (!IsWindowsMSVC) {
2139 CmdArgs.push_back(
"-analyzer-checker=unix");
2142 CmdArgs.push_back(
"-analyzer-checker=unix.API");
2143 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
2144 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
2145 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
2146 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
2147 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
2152 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
2153 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
2156 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
2157 CmdArgs.push_back(
"-analyzer-checker=osx");
2159 CmdArgs.push_back(
"-analyzer-checker=deadcode");
2162 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
2166 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
2167 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
2168 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
2169 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
2170 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
2171 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
2175 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
2177 "-analyzer-checker=nullability.NullReturnedFromNonnull");
2182 CmdArgs.push_back(
"-analyzer-output");
2183 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2184 CmdArgs.push_back(A->getValue());
2186 CmdArgs.push_back(
"plist");
2191 CmdArgs.push_back(
"-w");
2194 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2199 llvm::Reloc::Model RelocationModel;
2202 std::tie(RelocationModel, PICLevel, IsPIE) =
2207 if ((RelocationModel == llvm::Reloc::ROPI ||
2208 RelocationModel == llvm::Reloc::ROPI_RWPI) &&
2210 !Args.hasArg(options::OPT_fallow_unsupported))
2211 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
2214 CmdArgs.push_back(
"-mrelocation-model");
2215 CmdArgs.push_back(RMName);
2218 CmdArgs.push_back(
"-pic-level");
2219 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
2221 CmdArgs.push_back(
"-pic-is-pie");
2224 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
2225 CmdArgs.push_back(
"-meabi");
2226 CmdArgs.push_back(A->getValue());
2229 CmdArgs.push_back(
"-mthread-model");
2230 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
2231 CmdArgs.push_back(A->getValue());
2233 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
2235 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
2237 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2238 options::OPT_fno_merge_all_constants))
2239 CmdArgs.push_back(
"-fno-merge-all-constants");
2243 if (Args.hasArg(options::OPT_frewrite_map_file) ||
2244 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
2245 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
2246 options::OPT_frewrite_map_file_EQ)) {
2247 StringRef
Map = A->getValue();
2248 if (!llvm::sys::fs::exists(Map)) {
2249 D.
Diag(diag::err_drv_no_such_file) <<
Map;
2251 CmdArgs.push_back(
"-frewrite-map-file");
2252 CmdArgs.push_back(A->getValue());
2258 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2259 StringRef v = A->getValue();
2260 CmdArgs.push_back(
"-mllvm");
2261 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
2265 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
2267 CmdArgs.push_back(
"-fno-jump-tables");
2269 if (!Args.hasFlag(options::OPT_fpreserve_as_comments,
2270 options::OPT_fno_preserve_as_comments,
true))
2271 CmdArgs.push_back(
"-fno-preserve-as-comments");
2273 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2274 CmdArgs.push_back(
"-mregparm");
2275 CmdArgs.push_back(A->getValue());
2278 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2279 options::OPT_freg_struct_return)) {
2280 if (getToolChain().getArch() != llvm::Triple::x86) {
2281 D.
Diag(diag::err_drv_unsupported_opt_for_target)
2282 << A->getSpelling() << getToolChain().getTriple().str();
2283 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2284 CmdArgs.push_back(
"-fpcc-struct-return");
2286 assert(A->getOption().matches(options::OPT_freg_struct_return));
2287 CmdArgs.push_back(
"-freg-struct-return");
2291 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
2292 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
2295 CmdArgs.push_back(
"-mdisable-fp-elim");
2296 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2297 options::OPT_fno_zero_initialized_in_bss))
2298 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
2303 OptSpecifier StrictAliasingAliasOption =
2304 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
2307 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
2308 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
2309 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
2310 CmdArgs.push_back(
"-relaxed-aliasing");
2311 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2312 options::OPT_fno_struct_path_tbaa))
2313 CmdArgs.push_back(
"-no-struct-path-tbaa");
2314 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2316 CmdArgs.push_back(
"-fstrict-enums");
2317 if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
2319 CmdArgs.push_back(
"-fno-strict-return");
2320 if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
2321 options::OPT_fno_allow_editor_placeholders,
false))
2322 CmdArgs.push_back(
"-fallow-editor-placeholders");
2323 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
2324 options::OPT_fno_strict_vtable_pointers,
2326 CmdArgs.push_back(
"-fstrict-vtable-pointers");
2327 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2328 options::OPT_fno_optimize_sibling_calls))
2329 CmdArgs.push_back(
"-mdisable-tail-calls");
2332 if (Args.hasArg(options::OPT_fsplit_stack))
2333 CmdArgs.push_back(
"-split-stacks");
2340 bool HonorInfs =
true;
2341 bool HonorNans =
true;
2343 bool MathErrno = getToolChain().IsMathErrnoDefault();
2344 bool AssociativeMath =
false;
2345 bool ReciprocalMath =
false;
2346 bool SignedZeros =
true;
2347 bool TrappingMath =
true;
2348 StringRef DenormalFpMath =
"";
2349 StringRef FpContract =
"";
2351 for (Arg *A : Args) {
2352 switch (A->getOption().getID()) {
2358 case options::OPT_fhonor_infinities: HonorInfs =
true;
break;
2359 case options::OPT_fno_honor_infinities: HonorInfs =
false;
break;
2360 case options::OPT_fhonor_nans: HonorNans =
true;
break;
2361 case options::OPT_fno_honor_nans: HonorNans =
false;
break;
2362 case options::OPT_fmath_errno: MathErrno =
true;
break;
2363 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2364 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2365 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2366 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2367 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2368 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2369 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2370 case options::OPT_ftrapping_math: TrappingMath =
true;
break;
2371 case options::OPT_fno_trapping_math: TrappingMath =
false;
break;
2373 case options::OPT_fdenormal_fp_math_EQ:
2374 DenormalFpMath = A->getValue();
2378 case options::OPT_ffp_contract: {
2379 StringRef Val = A->getValue();
2380 if (Val ==
"fast" || Val ==
"on" || Val ==
"off") {
2383 D.
Diag(diag::err_drv_unsupported_option_argument)
2384 << A->getOption().getName() << Val;
2389 case options::OPT_ffinite_math_only:
2393 case options::OPT_fno_finite_math_only:
2398 case options::OPT_funsafe_math_optimizations:
2399 AssociativeMath =
true;
2400 ReciprocalMath =
true;
2401 SignedZeros =
false;
2402 TrappingMath =
false;
2404 case options::OPT_fno_unsafe_math_optimizations:
2405 AssociativeMath =
false;
2406 ReciprocalMath =
false;
2408 TrappingMath =
true;
2410 DenormalFpMath =
"";
2413 case options::OPT_Ofast:
2418 case options::OPT_ffast_math:
2422 AssociativeMath =
true;
2423 ReciprocalMath =
true;
2424 SignedZeros =
false;
2425 TrappingMath =
false;
2427 FpContract =
"fast";
2429 case options::OPT_fno_fast_math:
2435 MathErrno = getToolChain().IsMathErrnoDefault();
2436 AssociativeMath =
false;
2437 ReciprocalMath =
false;
2439 TrappingMath =
true;
2441 DenormalFpMath =
"";
2450 CmdArgs.push_back(
"-menable-no-infs");
2453 CmdArgs.push_back(
"-menable-no-nans");
2456 CmdArgs.push_back(
"-fmath-errno");
2458 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2460 CmdArgs.push_back(
"-menable-unsafe-fp-math");
2463 CmdArgs.push_back(
"-fno-signed-zeros");
2466 CmdArgs.push_back(
"-freciprocal-math");
2469 CmdArgs.push_back(
"-fno-trapping-math");
2471 if (!DenormalFpMath.empty())
2472 CmdArgs.push_back(Args.MakeArgString(
"-fdenormal-fp-math="+DenormalFpMath));
2474 if (!FpContract.empty())
2475 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract="+FpContract));
2477 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
2482 if (!HonorInfs && !HonorNans && !MathErrno && AssociativeMath &&
2483 ReciprocalMath && !SignedZeros && !TrappingMath)
2484 CmdArgs.push_back(
"-ffast-math");
2487 if (!HonorInfs && !HonorNans)
2488 CmdArgs.push_back(
"-ffinite-math-only");
2492 bool IsIntegratedAssemblerDefault =
2493 getToolChain().IsIntegratedAssemblerDefault();
2494 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2495 IsIntegratedAssemblerDefault) ||
2496 Args.hasArg(options::OPT_dA))
2497 CmdArgs.push_back(
"-masm-verbose");
2499 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
2500 IsIntegratedAssemblerDefault))
2501 CmdArgs.push_back(
"-no-integrated-as");
2503 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2504 CmdArgs.push_back(
"-mdebug-pass");
2505 CmdArgs.push_back(
"Structure");
2507 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2508 CmdArgs.push_back(
"-mdebug-pass");
2509 CmdArgs.push_back(
"Arguments");
2515 if (!getToolChain().getTriple().isOSDarwin() &&
2516 !getToolChain().getTriple().isNVPTX())
2517 CmdArgs.push_back(
"-mconstructor-aliases");
2521 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
2522 CmdArgs.push_back(
"-fforbid-guard-variables");
2524 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
2526 CmdArgs.push_back(
"-mms-bitfields");
2529 if (Args.hasFlag(options::OPT_mpie_copy_relocations,
2530 options::OPT_mno_pie_copy_relocations,
2532 CmdArgs.push_back(
"-mpie-copy-relocations");
2538 bool AsynchronousUnwindTables =
2539 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2540 options::OPT_fno_asynchronous_unwind_tables,
2541 (getToolChain().IsUnwindTablesDefault(Args) ||
2542 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2544 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2545 AsynchronousUnwindTables))
2546 CmdArgs.push_back(
"-munwind-tables");
2548 getToolChain().addClangTargetOptions(Args, CmdArgs,
2551 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2552 CmdArgs.push_back(
"-mlimit-float-precision");
2553 CmdArgs.push_back(A->getValue());
2557 (void)Args.hasArg(options::OPT_mtune_EQ);
2559 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2560 CmdArgs.push_back(
"-mcode-model");
2561 CmdArgs.push_back(A->getValue());
2565 std::string CPU =
getCPUName(Args, Triple,
false);
2567 CmdArgs.push_back(
"-target-cpu");
2568 CmdArgs.push_back(Args.MakeArgString(CPU));
2571 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2572 CmdArgs.push_back(
"-mfpmath");
2573 CmdArgs.push_back(A->getValue());
2580 switch (getToolChain().getArch()) {
2584 case llvm::Triple::arm:
2585 case llvm::Triple::armeb:
2586 case llvm::Triple::thumb:
2587 case llvm::Triple::thumbeb:
2589 AddARMTargetArgs(Triple, Args, CmdArgs, KernelOrKext);
2592 case llvm::Triple::aarch64:
2593 case llvm::Triple::aarch64_be:
2594 AddAArch64TargetArgs(Args, CmdArgs);
2597 case llvm::Triple::mips:
2598 case llvm::Triple::mipsel:
2599 case llvm::Triple::mips64:
2600 case llvm::Triple::mips64el:
2601 AddMIPSTargetArgs(Args, CmdArgs);
2604 case llvm::Triple::ppc:
2605 case llvm::Triple::ppc64:
2606 case llvm::Triple::ppc64le:
2607 AddPPCTargetArgs(Args, CmdArgs);
2610 case llvm::Triple::sparc:
2611 case llvm::Triple::sparcel:
2612 case llvm::Triple::sparcv9:
2613 AddSparcTargetArgs(Args, CmdArgs);
2616 case llvm::Triple::systemz:
2617 AddSystemZTargetArgs(Args, CmdArgs);
2620 case llvm::Triple::x86:
2621 case llvm::Triple::x86_64:
2622 AddX86TargetArgs(Args, CmdArgs);
2625 case llvm::Triple::lanai:
2626 AddLanaiTargetArgs(Args, CmdArgs);
2629 case llvm::Triple::hexagon:
2630 AddHexagonTargetArgs(Args, CmdArgs);
2633 case llvm::Triple::wasm32:
2634 case llvm::Triple::wasm64:
2635 AddWebAssemblyTargetArgs(Args, CmdArgs);
2648 unsigned DwarfVersion = 0;
2649 llvm::DebuggerKind DebuggerTuning = getToolChain().getDefaultDebuggerTuning();
2652 bool EmitCodeView =
false;
2656 if (getToolChain().getDriver().IsCLMode())
2657 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
2660 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2661 CmdArgs.push_back(
"-target-linker-version");
2662 CmdArgs.push_back(A->getValue());
2666 CmdArgs.push_back(
"-momit-leaf-frame-pointer");
2670 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2672 if (
types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
2673 getToolChain().getArch() == llvm::Triple::x86) {
2674 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2675 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2676 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
2677 << Unsupported->getOption().getName();
2680 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
2681 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
2682 << Unsupported->getOption().getName()
2683 <<
"please use -maltivec and include altivec.h explicitly";
2684 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
2685 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
2686 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
2689 Args.AddAllArgs(CmdArgs, options::OPT_v);
2690 Args.AddLastArg(CmdArgs, options::OPT_H);
2692 CmdArgs.push_back(
"-header-include-file");
2696 Args.AddLastArg(CmdArgs, options::OPT_P);
2697 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2700 CmdArgs.push_back(
"-diagnostic-log-file");
2705 bool splitDwarfInlining =
2706 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
2707 options::OPT_fno_split_dwarf_inlining,
true);
2709 Args.ClaimAllArgs(options::OPT_g_Group);
2710 Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
2711 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2713 if (A->getOption().matches(options::OPT_gN_Group)) {
2723 if (SplitDwarfArg) {
2724 if (A->getIndex() > SplitDwarfArg->getIndex()) {
2727 splitDwarfInlining))
2728 SplitDwarfArg =
nullptr;
2729 }
else if (splitDwarfInlining)
2738 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
2739 options::OPT_ggdbN_Group)) {
2740 if (A->getOption().matches(options::OPT_glldb))
2741 DebuggerTuning = llvm::DebuggerKind::LLDB;
2742 else if (A->getOption().matches(options::OPT_gsce))
2743 DebuggerTuning = llvm::DebuggerKind::SCE;
2745 DebuggerTuning = llvm::DebuggerKind::GDB;
2749 if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
2750 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
2755 if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {
2757 CmdArgs.push_back(
"-gcodeview");
2758 }
else if (DwarfVersion == 0 &&
2760 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
2765 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2772 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
2773 !IsPS4CPU && !(IsWindowsMSVC && EmitCodeView)))
2774 CmdArgs.push_back(
"-dwarf-column-info");
2779 Args.hasArg(options::OPT_gmodules)) {
2781 CmdArgs.push_back(
"-dwarf-ext-refs");
2782 CmdArgs.push_back(
"-fmodule-format=obj");
2788 if (getToolChain().getTriple().isOSLinux()) {
2789 if (!splitDwarfInlining)
2790 CmdArgs.push_back(
"-fno-split-dwarf-inlining");
2791 if (SplitDwarfArg) {
2794 CmdArgs.push_back(
"-enable-split-dwarf");
2803 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
2804 options::OPT_fno_standalone_debug,
2805 getToolChain().GetDefaultStandaloneDebug());
2812 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
2814 CmdArgs.push_back(
"-debug-info-macro");
2817 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2818 CmdArgs.push_back(
"-backend-option");
2819 CmdArgs.push_back(
"-generate-gnu-dwarf-pub-sections");
2825 if (Args.hasArg(options::OPT_gdwarf_aranges) || IsPS4CPU) {
2826 CmdArgs.push_back(
"-backend-option");
2827 CmdArgs.push_back(
"-generate-arange-section");
2830 if (Args.hasFlag(options::OPT_fdebug_types_section,
2831 options::OPT_fno_debug_types_section,
false)) {
2832 CmdArgs.push_back(
"-backend-option");
2833 CmdArgs.push_back(
"-generate-type-units");
2840 if (Args.hasFlag(options::OPT_ffunction_sections,
2841 options::OPT_fno_function_sections, UseSeparateSections)) {
2842 CmdArgs.push_back(
"-ffunction-sections");
2845 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
2846 UseSeparateSections)) {
2847 CmdArgs.push_back(
"-fdata-sections");
2850 if (!Args.hasFlag(options::OPT_funique_section_names,
2851 options::OPT_fno_unique_section_names,
true))
2852 CmdArgs.push_back(
"-fno-unique-section-names");
2854 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2858 if (
auto *ABICompatArg = Args.getLastArg(options::OPT_fclang_abi_compat_EQ))
2859 ABICompatArg->render(Args, CmdArgs);
2862 if (getToolChain().getTriple().isPS4CPU())
2866 if (Args.hasArg(options::OPT_nostdinc)) {
2867 CmdArgs.push_back(
"-nostdsysteminc");
2868 CmdArgs.push_back(
"-nobuiltininc");
2870 if (Args.hasArg(options::OPT_nostdlibinc))
2871 CmdArgs.push_back(
"-nostdsysteminc");
2872 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2873 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2877 CmdArgs.push_back(
"-resource-dir");
2880 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2882 bool ARCMTEnabled =
false;
2883 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2884 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2885 options::OPT_ccc_arcmt_modify,
2886 options::OPT_ccc_arcmt_migrate)) {
2887 ARCMTEnabled =
true;
2888 switch (A->getOption().getID()) {
2890 llvm_unreachable(
"missed a case");
2891 case options::OPT_ccc_arcmt_check:
2892 CmdArgs.push_back(
"-arcmt-check");
2894 case options::OPT_ccc_arcmt_modify:
2895 CmdArgs.push_back(
"-arcmt-modify");
2897 case options::OPT_ccc_arcmt_migrate:
2898 CmdArgs.push_back(
"-arcmt-migrate");
2899 CmdArgs.push_back(
"-mt-migrate-directory");
2900 CmdArgs.push_back(A->getValue());
2902 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2903 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2908 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2909 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2910 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2913 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2915 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
2916 <<
"-ccc-arcmt-migrate";
2918 CmdArgs.push_back(
"-mt-migrate-directory");
2919 CmdArgs.push_back(A->getValue());
2921 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2922 options::OPT_objcmt_migrate_subscripting,
2923 options::OPT_objcmt_migrate_property)) {
2925 CmdArgs.push_back(
"-objcmt-migrate-literals");
2926 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
2927 CmdArgs.push_back(
"-objcmt-migrate-property");
2929 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2930 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2931 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2934 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2935 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2936 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2937 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2938 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2939 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2940 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
2941 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2942 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2943 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2944 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2945 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2946 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2947 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2948 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
2949 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
2957 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2963 Args.ClaimAllArgs(options::OPT_D);
2966 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2967 if (A->getOption().matches(options::OPT_O4)) {
2968 CmdArgs.push_back(
"-O3");
2969 D.
Diag(diag::warn_O4_is_O3);
2971 A->render(Args, CmdArgs);
2977 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
2978 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
2983 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
2984 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
2990 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
2992 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2993 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
2994 CmdArgs.push_back(
"-pedantic");
2995 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2996 Args.AddLastArg(CmdArgs, options::OPT_w);
3003 bool ImplyVCPPCXXVer =
false;
3004 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3005 if (Std->getOption().matches(options::OPT_ansi))
3007 CmdArgs.push_back(
"-std=c++98");
3009 CmdArgs.push_back(
"-std=c89");
3011 Std->render(Args, CmdArgs);
3014 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3015 options::OPT_ftrigraphs,
3016 options::OPT_fno_trigraphs))
3018 A->render(Args, CmdArgs);
3027 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
3029 else if (IsWindowsMSVC)
3030 ImplyVCPPCXXVer =
true;
3032 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3033 options::OPT_fno_trigraphs);
3049 Args.getLastArg(options::OPT_Wwrite_strings,
3050 options::OPT_Wno_write_strings, options::OPT_w);
3052 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
3053 CmdArgs.push_back(
"-fconst-strings");
3060 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3062 CmdArgs.push_back(
"-fdeprecated-macro");
3066 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3067 if (Asm->getOption().matches(options::OPT_fasm))
3068 CmdArgs.push_back(
"-fgnu-keywords");
3070 CmdArgs.push_back(
"-fno-gnu-keywords");
3074 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
3077 CmdArgs.push_back(
"-fno-autolink");
3082 for (
const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
3083 StringRef
Map = A->getValue();
3084 if (Map.find(
'=') == StringRef::npos)
3085 D.
Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) <<
Map;
3087 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
3091 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3092 options::OPT_ftemplate_depth_EQ)) {
3093 CmdArgs.push_back(
"-ftemplate-depth");
3094 CmdArgs.push_back(A->getValue());
3097 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3098 CmdArgs.push_back(
"-foperator-arrow-depth");
3099 CmdArgs.push_back(A->getValue());
3102 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3103 CmdArgs.push_back(
"-fconstexpr-depth");
3104 CmdArgs.push_back(A->getValue());
3107 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3108 CmdArgs.push_back(
"-fconstexpr-steps");
3109 CmdArgs.push_back(A->getValue());
3112 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3113 CmdArgs.push_back(
"-fbracket-depth");
3114 CmdArgs.push_back(A->getValue());
3117 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3118 options::OPT_Wlarge_by_value_copy_def)) {
3119 if (A->getNumValues()) {
3120 StringRef
bytes = A->getValue();
3121 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
3123 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
3126 if (Args.hasArg(options::OPT_relocatable_pch))
3127 CmdArgs.push_back(
"-relocatable-pch");
3129 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3130 CmdArgs.push_back(
"-fconstant-string-class");
3131 CmdArgs.push_back(A->getValue());
3134 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3135 CmdArgs.push_back(
"-ftabstop");
3136 CmdArgs.push_back(A->getValue());
3139 CmdArgs.push_back(
"-ferror-limit");
3140 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
3141 CmdArgs.push_back(A->getValue());
3143 CmdArgs.push_back(
"19");
3145 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3146 CmdArgs.push_back(
"-fmacro-backtrace-limit");
3147 CmdArgs.push_back(A->getValue());
3150 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3151 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
3152 CmdArgs.push_back(A->getValue());
3155 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3156 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
3157 CmdArgs.push_back(A->getValue());
3160 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3161 CmdArgs.push_back(
"-fspell-checking-limit");
3162 CmdArgs.push_back(A->getValue());
3166 CmdArgs.push_back(
"-fmessage-length");
3167 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
3168 CmdArgs.push_back(A->getValue());
3172 unsigned N = llvm::sys::Process::StandardErrColumns();
3173 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
3177 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3178 options::OPT_fvisibility_ms_compat)) {
3179 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3180 CmdArgs.push_back(
"-fvisibility");
3181 CmdArgs.push_back(A->getValue());
3183 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3184 CmdArgs.push_back(
"-fvisibility");
3185 CmdArgs.push_back(
"hidden");
3186 CmdArgs.push_back(
"-ftype-visibility");
3187 CmdArgs.push_back(
"default");
3191 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
3193 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3196 bool IsHosted =
true;
3197 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
3199 CmdArgs.push_back(
"-ffreestanding");
3204 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
3205 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
3206 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3209 bool EmulatedTLSDefault = Triple.isAndroid() || Triple.isOSOpenBSD() ||
3210 Triple.isWindowsCygwinEnvironment();
3211 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
3212 EmulatedTLSDefault))
3213 CmdArgs.push_back(
"-femulated-tls");
3215 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
3216 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
3218 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3219 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3223 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
3224 options::OPT_fno_openmp,
false) &&
3227 switch (getToolChain().getDriver().getOpenMPRuntime(Args)) {
3231 CmdArgs.push_back(
"-fopenmp");
3236 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
3237 options::OPT_fnoopenmp_use_tls,
true))
3238 CmdArgs.push_back(
"-fnoopenmp-use-tls");
3239 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
3252 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3253 Sanitize.
addArgs(getToolChain(), Args, CmdArgs, InputType);
3255 const XRayArgs &XRay = getToolChain().getXRayArgs();
3256 XRay.
addArgs(getToolChain(), Args, CmdArgs, InputType);
3258 if (getToolChain().SupportsProfiling())
3259 Args.AddLastArg(CmdArgs, options::OPT_pg);
3261 if (getToolChain().SupportsProfiling())
3262 Args.AddLastArg(CmdArgs, options::OPT_mfentry);
3265 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3266 options::OPT_fno_lax_vector_conversions))
3267 CmdArgs.push_back(
"-fno-lax-vector-conversions");
3269 if (Args.getLastArg(options::OPT_fapple_kext) ||
3270 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
3271 CmdArgs.push_back(
"-fapple-kext");
3273 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3274 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3275 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3276 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3277 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3279 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3280 CmdArgs.push_back(
"-ftrapv-handler");
3281 CmdArgs.push_back(A->getValue());
3284 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3288 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
3289 if (A->getOption().matches(options::OPT_fwrapv))
3290 CmdArgs.push_back(
"-fwrapv");
3291 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3292 options::OPT_fno_strict_overflow)) {
3293 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3294 CmdArgs.push_back(
"-fwrapv");
3297 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3298 options::OPT_fno_reroll_loops))
3299 if (A->getOption().matches(options::OPT_freroll_loops))
3300 CmdArgs.push_back(
"-freroll-loops");
3302 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3303 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3304 options::OPT_fno_unroll_loops);
3306 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3309 unsigned StackProtectorLevel = 0;
3312 if (!Triple.isNVPTX()) {
3313 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3314 options::OPT_fstack_protector_all,
3315 options::OPT_fstack_protector_strong,
3316 options::OPT_fstack_protector)) {
3317 if (A->getOption().matches(options::OPT_fstack_protector)) {
3318 StackProtectorLevel = std::max<unsigned>(
3320 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3321 }
else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3323 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3326 StackProtectorLevel =
3327 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3330 if (Triple.isOSDarwin() && !IsHosted)
3331 StackProtectorLevel = 0;
3334 if (StackProtectorLevel) {
3335 CmdArgs.push_back(
"-stack-protector");
3336 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3340 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3341 StringRef Str(A->getValue());
3342 if (Str.startswith(
"ssp-buffer-size=")) {
3343 if (StackProtectorLevel) {
3344 CmdArgs.push_back(
"-stack-protector-buffer-size");
3346 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3353 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3355 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
3357 if (Args.hasArg(options::OPT_mstack_alignment)) {
3358 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3359 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
3362 if (Args.hasArg(options::OPT_mstack_probe_size)) {
3363 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
3366 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
3368 CmdArgs.push_back(
"-mstack-probe-size=0");
3371 switch (getToolChain().getArch()) {
3372 case llvm::Triple::aarch64:
3373 case llvm::Triple::aarch64_be:
3374 case llvm::Triple::arm:
3375 case llvm::Triple::armeb:
3376 case llvm::Triple::thumb:
3377 case llvm::Triple::thumbeb:
3378 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
3385 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3386 options::OPT_mno_restrict_it)) {
3387 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3388 CmdArgs.push_back(
"-backend-option");
3389 CmdArgs.push_back(
"-arm-restrict-it");
3391 CmdArgs.push_back(
"-backend-option");
3392 CmdArgs.push_back(
"-arm-no-restrict-it");
3394 }
else if (Triple.isOSWindows() &&
3395 (Triple.getArch() == llvm::Triple::arm ||
3396 Triple.getArch() == llvm::Triple::thumb)) {
3398 CmdArgs.push_back(
"-backend-option");
3399 CmdArgs.push_back(
"-arm-restrict-it");
3403 if (Args.getLastArg(options::OPT_cl_opt_disable)) {
3404 CmdArgs.push_back(
"-cl-opt-disable");
3406 if (Args.getLastArg(options::OPT_cl_strict_aliasing)) {
3407 CmdArgs.push_back(
"-cl-strict-aliasing");
3409 if (Args.getLastArg(options::OPT_cl_single_precision_constant)) {
3410 CmdArgs.push_back(
"-cl-single-precision-constant");
3412 if (Args.getLastArg(options::OPT_cl_finite_math_only)) {
3413 CmdArgs.push_back(
"-cl-finite-math-only");
3415 if (Args.getLastArg(options::OPT_cl_kernel_arg_info)) {
3416 CmdArgs.push_back(
"-cl-kernel-arg-info");
3418 if (Args.getLastArg(options::OPT_cl_unsafe_math_optimizations)) {
3419 CmdArgs.push_back(
"-cl-unsafe-math-optimizations");
3421 if (Args.getLastArg(options::OPT_cl_fast_relaxed_math)) {
3422 CmdArgs.push_back(
"-cl-fast-relaxed-math");
3424 if (Args.getLastArg(options::OPT_cl_mad_enable)) {
3425 CmdArgs.push_back(
"-cl-mad-enable");
3427 if (Args.getLastArg(options::OPT_cl_no_signed_zeros)) {
3428 CmdArgs.push_back(
"-cl-no-signed-zeros");
3430 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3431 std::string CLStdStr =
"-cl-std=";
3432 CLStdStr += A->getValue();
3433 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3435 if (Args.getLastArg(options::OPT_cl_denorms_are_zero)) {
3436 CmdArgs.push_back(
"-cl-denorms-are-zero");
3438 if (Args.getLastArg(options::OPT_cl_fp32_correctly_rounded_divide_sqrt)) {
3439 CmdArgs.push_back(
"-cl-fp32-correctly-rounded-divide-sqrt");
3445 StringRef fname = A->getValue();
3446 if (!llvm::sys::fs::exists(fname))
3447 D.
Diag(diag::err_drv_no_such_file) << fname;
3449 A->render(Args, CmdArgs);
3452 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
3453 options::OPT_fno_debug_info_for_profiling,
false))
3454 CmdArgs.push_back(
"-fdebug-info-for-profiling");
3458 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3459 !Args.hasArg(options::OPT_mkernel));
3461 CmdArgs.push_back(
"-fno-builtin");
3464 if (Args.hasArg(options::OPT_ffreestanding))
3465 UseBuiltins =
false;
3468 for (
const auto &Arg : Args) {
3469 const Option &O = Arg->getOption();
3470 if (!O.matches(options::OPT_fno_builtin_))
3479 StringRef FuncName = Arg->getValue();
3480 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
3483 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3484 options::OPT_fno_assume_sane_operator_new))
3485 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
3488 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3489 getToolChain().IsBlocksDefault()) ||
3490 (Args.hasArg(options::OPT_fgnu_runtime) &&
3491 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3492 !Args.hasArg(options::OPT_fno_blocks))) {
3493 CmdArgs.push_back(
"-fblocks");
3495 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3496 !getToolChain().hasBlocksRuntime())
3497 CmdArgs.push_back(
"-fblocks-runtime-optional");
3500 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
3503 CmdArgs.push_back(
"-fcoroutines-ts");
3509 bool HaveClangModules =
false;
3510 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3511 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3512 options::OPT_fno_cxx_modules,
true);
3514 CmdArgs.push_back(
"-fmodules");
3515 HaveClangModules =
true;
3519 bool HaveAnyModules = HaveClangModules;
3520 if (Args.hasArg(options::OPT_fmodules_ts)) {
3521 CmdArgs.push_back(
"-fmodules-ts");
3522 HaveAnyModules =
true;
3527 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3528 options::OPT_fno_implicit_module_maps, HaveClangModules)) {
3529 CmdArgs.push_back(
"-fimplicit-module-maps");
3534 if (Args.hasFlag(options::OPT_fmodules_decluse,
3535 options::OPT_fno_modules_decluse,
false)) {
3536 CmdArgs.push_back(
"-fmodules-decluse");
3541 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3542 options::OPT_fno_modules_strict_decluse,
false)) {
3543 CmdArgs.push_back(
"-fmodules-strict-decluse");
3547 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3548 options::OPT_fno_implicit_modules, HaveClangModules)) {
3550 CmdArgs.push_back(
"-fno-implicit-modules");
3551 }
else if (HaveAnyModules) {
3555 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3556 Path = A->getValue();
3561 llvm::sys::path::replace_extension(Path,
".cache");
3562 llvm::sys::path::append(Path,
"modules");
3563 }
else if (Path.empty()) {
3565 llvm::sys::path::system_temp_directory(
false, Path);
3566 llvm::sys::path::append(Path,
"org.llvm.clang.");
3568 llvm::sys::path::append(Path,
"ModuleCache");
3570 const char Arg[] =
"-fmodules-cache-path=";
3571 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3572 CmdArgs.push_back(Args.MakeArgString(Path));
3575 if (HaveAnyModules) {
3577 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path))
3578 CmdArgs.push_back(Args.MakeArgString(
3579 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3584 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3588 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3592 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3594 llvm::sys::path::append(BuiltinModuleMap,
"include");
3595 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3596 if (llvm::sys::fs::exists(BuiltinModuleMap)) {
3597 CmdArgs.push_back(Args.MakeArgString(
"-fmodule-map-file=" +
3604 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3606 Args.ClaimAllArgs(options::OPT_fmodule_file);
3612 llvm::sys::path::replace_extension(VFSDir,
".cache");
3616 llvm::sys::path::append(VFSDir,
"vfs");
3617 CmdArgs.push_back(
"-module-dependency-dir");
3618 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3621 if (HaveClangModules)
3622 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3625 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3626 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3627 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3629 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3631 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3632 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3633 D.
Diag(diag::err_drv_argument_not_allowed_with)
3634 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3636 llvm::sys::fs::file_status
Status;
3637 if (llvm::sys::fs::status(A->getValue(),
Status))
3638 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3640 Args.MakeArgString(
"-fbuild-session-timestamp=" +
3641 Twine((uint64_t)Status.getLastModificationTime()
3646 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3647 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3648 options::OPT_fbuild_session_file))
3649 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3651 Args.AddLastArg(CmdArgs,
3652 options::OPT_fmodules_validate_once_per_build_session);
3655 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3656 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
3659 if (Args.hasFlag(options::OPT_fno_access_control,
3660 options::OPT_faccess_control,
false))
3661 CmdArgs.push_back(
"-fno-access-control");
3664 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3665 options::OPT_felide_constructors,
false))
3666 CmdArgs.push_back(
"-fno-elide-constructors");
3673 CmdArgs.push_back(
"-fno-rtti");
3676 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
3677 getToolChain().getArch() == llvm::Triple::hexagon))
3678 CmdArgs.push_back(
"-fshort-enums");
3681 if (Arg *A = Args.getLastArg(
3682 options::OPT_fsigned_char, options::OPT_fno_signed_char,
3683 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
3684 if (A->getOption().matches(options::OPT_funsigned_char) ||
3685 A->getOption().matches(options::OPT_fno_signed_char)) {
3686 CmdArgs.push_back(
"-fno-signed-char");
3689 CmdArgs.push_back(
"-fno-signed-char");
3694 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3695 !IsWindowsCygnus && !IsWindowsGNU &&
3696 getToolChain().getTriple().getOS() != llvm::Triple::Solaris &&
3697 getToolChain().getArch() != llvm::Triple::hexagon &&
3698 getToolChain().getArch() != llvm::Triple::xcore &&
3699 ((getToolChain().getTriple().getVendor() !=
3700 llvm::Triple::MipsTechnologies) ||
3701 getToolChain().getTriple().hasEnvironment())) ||
3703 CmdArgs.push_back(
"-fno-use-cxa-atexit");
3706 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3708 CmdArgs.push_back(
"-fms-extensions");
3711 if (Args.hasFlag(options::OPT_fuse_line_directives,
3712 options::OPT_fno_use_line_directives,
false))
3713 CmdArgs.push_back(
"-fuse-line-directives");
3716 if (Args.hasFlag(options::OPT_fms_compatibility,
3717 options::OPT_fno_ms_compatibility,
3719 Args.hasFlag(options::OPT_fms_extensions,
3720 options::OPT_fno_ms_extensions,
true))))
3721 CmdArgs.push_back(
"-fms-compatibility");
3724 getToolChain().computeMSVCVersion(&getToolChain().getDriver(), Args);
3727 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.
getAsString()));
3729 bool IsMSVC2015Compatible = MSVT.
getMajor() >= 19;
3730 if (ImplyVCPPCXXVer) {
3731 StringRef LanguageStandard;
3732 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
3733 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
3734 .Case(
"c++14",
"-std=c++14")
3735 .Case(
"c++latest",
"-std=c++1z")
3737 if (LanguageStandard.empty())
3738 D.
Diag(clang::diag::warn_drv_unused_argument)
3739 << StdArg->getAsString(Args);
3742 if (LanguageStandard.empty()) {
3743 if (IsMSVC2015Compatible)
3744 LanguageStandard =
"-std=c++14";
3746 LanguageStandard =
"-std=c++11";
3749 CmdArgs.push_back(LanguageStandard.data());
3753 if (Args.hasFlag(options::OPT_fborland_extensions,
3754 options::OPT_fno_borland_extensions,
false))
3755 CmdArgs.push_back(
"-fborland-extensions");
3758 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
3759 getToolChain().getTriple().isPS4()))
3760 CmdArgs.push_back(
"-fdeclspec");
3761 else if (Args.hasArg(options::OPT_fno_declspec))
3762 CmdArgs.push_back(
"-fno-declspec");
3766 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3767 options::OPT_fno_threadsafe_statics,
3768 !IsWindowsMSVC || IsMSVC2015Compatible))
3769 CmdArgs.push_back(
"-fno-threadsafe-statics");
3773 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3774 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
3775 CmdArgs.push_back(
"-fdelayed-template-parsing");
3779 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3780 options::OPT_fno_gnu_keywords))
3781 A->render(Args, CmdArgs);
3783 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
3785 CmdArgs.push_back(
"-fgnu89-inline");
3787 if (Args.hasArg(options::OPT_fno_inline))
3788 CmdArgs.push_back(
"-fno-inline");
3790 if (Arg* InlineArg = Args.getLastArg(options::OPT_finline_functions,
3791 options::OPT_finline_hint_functions,
3792 options::OPT_fno_inline_functions))
3793 InlineArg->render(Args, CmdArgs);
3795 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager,
3796 options::OPT_fno_experimental_new_pass_manager);
3798 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3805 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3806 options::OPT_fno_objc_legacy_dispatch,
3808 getToolChain().getArch()))) {
3809 if (getToolChain().UseObjCMixedDispatch())
3810 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
3812 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
3819 if (getToolChain().getArch() == llvm::Triple::x86 &&
3820 getToolChain().getTriple().isMacOSX() &&
3821 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3824 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
3827 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3828 CmdArgs.push_back(
"-fencode-extended-block-signature");
3835 getToolChain().CheckObjCARC();
3837 CmdArgs.push_back(
"-fobjc-arc");
3844 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
3846 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
3851 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3852 options::OPT_fno_objc_arc_exceptions,
3854 CmdArgs.push_back(
"-fobjc-arc-exceptions");
3859 if (Args.hasArg(options::OPT_fno_objc_arc)) {
3860 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
3861 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
3866 if (rewriteKind != RK_None)
3867 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
3871 auto WeakArg = Args.getLastArg(options::OPT_fobjc_weak,
3872 options::OPT_fno_objc_weak);
3876 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
3877 D.
Diag(diag::err_objc_weak_unsupported);
3879 WeakArg->render(Args, CmdArgs);
3883 if (Args.hasFlag(options::OPT_fapplication_extension,
3884 options::OPT_fno_application_extension,
false))
3885 CmdArgs.push_back(
"-fapplication-extension");
3889 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
3892 if (Args.hasArg(options::OPT_fsjlj_exceptions) ||
3893 getToolChain().UseSjLjExceptions(Args))
3894 CmdArgs.push_back(
"-fsjlj-exceptions");
3897 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3898 options::OPT_fno_assume_sane_operator_new))
3899 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
3904 if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
3905 options::OPT_fno_relaxed_template_template_args,
false))
3906 CmdArgs.push_back(
"-frelaxed-template-template-args");
3910 if (Args.hasFlag(options::OPT_fsized_deallocation,
3911 options::OPT_fno_sized_deallocation,
false))
3912 CmdArgs.push_back(
"-fsized-deallocation");
3916 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
3917 options::OPT_fno_aligned_allocation,
3918 options::OPT_faligned_new_EQ)) {
3919 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
3920 CmdArgs.push_back(
"-fno-aligned-allocation");
3922 CmdArgs.push_back(
"-faligned-allocation");
3927 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
3928 options::OPT_faligned_new_EQ))
3930 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
3934 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3935 options::OPT_fno_constant_cfstrings) ||
3936 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3937 options::OPT_mno_constant_cfstrings))
3938 CmdArgs.push_back(
"-fno-constant-cfstrings");
3942 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3943 options::OPT_fno_short_wchar))
3944 A->render(Args, CmdArgs);
3947 if (Args.hasFlag(options::OPT_fpascal_strings,
3948 options::OPT_fno_pascal_strings,
false))
3949 CmdArgs.push_back(
"-fpascal-strings");
3953 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3954 std::string PackStructStr =
"-fpack-struct=";
3955 PackStructStr += A->getValue();
3956 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3957 }
else if (Args.hasFlag(options::OPT_fpack_struct,
3958 options::OPT_fno_pack_struct,
false)) {
3959 CmdArgs.push_back(
"-fpack-struct=1");
3963 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
3964 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
3965 if (!SkipMaxTypeAlign) {
3966 std::string MaxTypeAlignStr =
"-fmax-type-align=";
3967 MaxTypeAlignStr += A->getValue();
3968 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
3970 }
else if (getToolChain().getTriple().isOSDarwin()) {
3971 if (!SkipMaxTypeAlign) {
3972 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
3973 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
3978 bool NoCommonDefault =
3980 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
3982 CmdArgs.push_back(
"-fno-common");
3986 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3987 options::OPT_funsigned_bitfields))
3988 D.
Diag(diag::warn_drv_clang_unsupported)
3989 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3992 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
3993 D.
Diag(diag::err_drv_clang_unsupported)
3994 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3997 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
3998 StringRef value = inputCharset->getValue();
3999 if (!value.equals_lower(
"utf-8"))
4000 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4005 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4006 StringRef value = execCharset->getValue();
4007 if (!value.equals_lower(
"utf-8"))
4008 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4012 bool CaretDefault =
true;
4013 bool ColumnDefault =
true;
4014 if (Arg *DiagArg = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4015 options::OPT__SLASH_diagnostics_column,
4016 options::OPT__SLASH_diagnostics_caret)) {
4017 switch (DiagArg->getOption().getID()) {
4018 case options::OPT__SLASH_diagnostics_caret:
4019 CaretDefault =
true;
4020 ColumnDefault =
true;
4022 case options::OPT__SLASH_diagnostics_column:
4023 CaretDefault =
false;
4024 ColumnDefault =
true;
4026 case options::OPT__SLASH_diagnostics_classic:
4027 CaretDefault =
false;
4028 ColumnDefault =
false;
4034 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4035 options::OPT_fno_caret_diagnostics, CaretDefault))
4036 CmdArgs.push_back(
"-fno-caret-diagnostics");
4039 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
4040 options::OPT_fno_diagnostics_fixit_info))
4041 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
4044 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
4045 options::OPT_fno_diagnostics_show_option))
4046 CmdArgs.push_back(
"-fdiagnostics-show-option");
4049 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4050 CmdArgs.push_back(
"-fdiagnostics-show-category");
4051 CmdArgs.push_back(A->getValue());
4054 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
4055 options::OPT_fno_diagnostics_show_hotness,
false))
4056 CmdArgs.push_back(
"-fdiagnostics-show-hotness");
4059 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4060 std::string Opt = std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4061 CmdArgs.push_back(Args.MakeArgString(Opt));
4064 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4065 CmdArgs.push_back(
"-fdiagnostics-format");
4066 CmdArgs.push_back(A->getValue());
4069 if (Arg *A = Args.getLastArg(
4070 options::OPT_fdiagnostics_show_note_include_stack,
4071 options::OPT_fno_diagnostics_show_note_include_stack)) {
4072 if (A->getOption().matches(
4073 options::OPT_fdiagnostics_show_note_include_stack))
4074 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4076 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4083 for (Arg *A : Args) {
4084 const Option &O = A->getOption();
4085 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4086 !O.matches(options::OPT_fdiagnostics_color) &&
4087 !O.matches(options::OPT_fno_color_diagnostics) &&
4088 !O.matches(options::OPT_fno_diagnostics_color) &&
4089 !O.matches(options::OPT_fdiagnostics_color_EQ))
4091 if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
4092 StringRef
Value(A->getValue());
4093 if (Value !=
"always" && Value !=
"never" && Value !=
"auto")
4094 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4095 << (
"-fdiagnostics-color=" +
Value).str();
4100 CmdArgs.push_back(
"-fcolor-diagnostics");
4102 if (Args.hasArg(options::OPT_fansi_escape_codes))
4103 CmdArgs.push_back(
"-fansi-escape-codes");
4105 if (!Args.hasFlag(options::OPT_fshow_source_location,
4106 options::OPT_fno_show_source_location))
4107 CmdArgs.push_back(
"-fno-show-source-location");
4109 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4110 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4112 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4114 CmdArgs.push_back(
"-fno-show-column");
4116 if (!Args.hasFlag(options::OPT_fspell_checking,
4117 options::OPT_fno_spell_checking))
4118 CmdArgs.push_back(
"-fno-spell-checking");
4121 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4123 CmdArgs.push_back(
"-fasm-blocks");
4126 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4127 options::OPT_fno_gnu_inline_asm,
true))
4128 CmdArgs.push_back(
"-fno-gnu-inline-asm");
4134 OptSpecifier VectorizeAliasOption =
4135 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
4136 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4137 options::OPT_fno_vectorize, EnableVec))
4138 CmdArgs.push_back(
"-vectorize-loops");
4142 OptSpecifier SLPVectAliasOption =
4143 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
4144 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4145 options::OPT_fno_slp_vectorize, EnableSLPVec))
4146 CmdArgs.push_back(
"-vectorize-slp");
4148 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4149 A->render(Args, CmdArgs);
4151 if (Arg *A = Args.getLastArg(
4152 options::OPT_fsanitize_undefined_strip_path_components_EQ))
4153 A->render(Args, CmdArgs);
4157 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4158 options::OPT_fno_dollars_in_identifiers)) {
4159 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
4160 CmdArgs.push_back(
"-fdollars-in-identifiers");
4162 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
4167 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4168 options::OPT_fno_unit_at_a_time)) {
4169 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
4170 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4173 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4174 options::OPT_fno_apple_pragma_pack,
false))
4175 CmdArgs.push_back(
"-fapple-pragma-pack");
4180 if (getToolChain().getArch() == llvm::Triple::le32) {
4181 CmdArgs.push_back(
"-fno-math-builtin");
4184 if (Args.hasFlag(options::OPT_fsave_optimization_record,
4185 options::OPT_fno_save_optimization_record,
false)) {
4186 CmdArgs.push_back(
"-opt-record-file");
4188 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
4190 CmdArgs.push_back(A->getValue());
4193 if (Output.
isFilename() && (Args.hasArg(options::OPT_c) ||
4194 Args.hasArg(options::OPT_S))) {
4198 F = llvm::sys::path::stem(Input.getBaseInput());
4205 llvm::sys::path::replace_extension(F,
"");
4207 Triple.normalize());
4213 llvm::sys::path::replace_extension(F,
"opt.yaml");
4214 CmdArgs.push_back(Args.MakeArgString(F));
4222 if (getToolChain().getTriple().isOSDarwin() &&
4223 (getToolChain().getArch() == llvm::Triple::arm ||
4224 getToolChain().getArch() == llvm::Triple::thumb)) {
4225 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4226 CmdArgs.push_back(
"-fno-builtin-strcat");
4227 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4228 CmdArgs.push_back(
"-fno-builtin-strcpy");
4232 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
4233 options::OPT_fno_rewrite_imports,
false);
4235 CmdArgs.push_back(
"-frewrite-imports");
4241 if (Args.hasFlag(options::OPT_frewrite_includes,
4242 options::OPT_fno_rewrite_includes,
false) ||
4244 CmdArgs.push_back(
"-frewrite-includes");
4247 if (Arg *A = Args.getLastArg(options::OPT_traditional,
4248 options::OPT_traditional_cpp)) {
4249 if (isa<PreprocessJobAction>(JA))
4250 CmdArgs.push_back(
"-traditional-cpp");
4252 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
4255 Args.AddLastArg(CmdArgs, options::OPT_dM);
4256 Args.AddLastArg(CmdArgs, options::OPT_dD);
4259 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4260 CmdArgs.push_back(
"-serialize-diagnostic-file");
4261 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
4264 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4265 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
4268 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
4270 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
4273 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
4274 CmdArgs.push_back(
"-load");
4275 CmdArgs.push_back(A->getValue());
4280 if (
const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ)) {
4281 StringRef SaveStats = A->getValue();
4284 bool DoSaveStats =
false;
4285 if (SaveStats ==
"obj") {
4288 llvm::sys::path::remove_filename(StatsFile);
4291 }
else if (SaveStats ==
"cwd") {
4294 D.
Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
4298 StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());
4299 llvm::sys::path::append(StatsFile, BaseName);
4300 llvm::sys::path::replace_extension(StatsFile,
"stats");
4301 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") +
4311 !isa<PreprocessJobAction>(JA)) {
4312 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
4314 if (StringRef(Arg->getValue()) !=
"-finclude-default-header")
4315 CmdArgs.push_back(Arg->getValue());
4319 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
4321 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
4327 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
4328 CmdArgs.push_back(
"-disable-llvm-optzns");
4330 A->render(Args, CmdArgs);
4344 isa<CompileJobAction>(JA))
4345 CmdArgs.push_back(
"-disable-llvm-passes");
4347 if (Output.
getType() == types::TY_Dependencies) {
4350 CmdArgs.push_back(
"-o");
4353 assert(Output.
isNothing() &&
"Invalid output.");
4358 if (Input.isFilename())
4359 CmdArgs.push_back(Input.getFilename());
4361 Input.getInputArg().renderAsInput(Args, CmdArgs);
4363 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4365 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4372 if (getToolChain().UseDwarfDebugFlags() ||
4373 Args.hasFlag(options::OPT_grecord_gcc_switches,
4374 options::OPT_gno_record_gcc_switches,
false)) {
4375 ArgStringList OriginalArgs;
4376 for (
const auto &Arg : Args)
4377 Arg->render(Args, OriginalArgs);
4381 for (
const char *OriginalArg : OriginalArgs) {
4385 Flags += EscapedArg;
4387 CmdArgs.push_back(
"-dwarf-debug-flags");
4388 CmdArgs.push_back(Args.MakeArgString(Flags));
4393 bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
4394 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4395 isa<BackendJobAction>(JA));
4396 const char *SplitDwarfOut;
4398 CmdArgs.push_back(
"-split-dwarf-file");
4400 CmdArgs.push_back(SplitDwarfOut);
4405 if (IsCuda && Inputs.size() > 1)
4406 for (
auto I = std::next(Inputs.begin()),
E = Inputs.end();
I !=
E; ++
I) {
4407 CmdArgs.push_back(
"-fcuda-include-gpubinary");
4408 CmdArgs.push_back(
I->getFilename());
4416 if (IsOpenMPDevice) {
4417 CmdArgs.push_back(
"-fopenmp-is-device");
4418 if (Inputs.size() == 2) {
4419 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
4420 CmdArgs.push_back(Args.MakeArgString(Inputs.back().getFilename()));
4429 Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ);
4430 assert(Tgts && Tgts->getNumValues() &&
4431 "OpenMP offloading has to have targets specified.");
4432 for (
unsigned i = 0; i < Tgts->getNumValues(); ++i) {
4437 llvm::Triple T(Tgts->getValue(i));
4438 TargetInfo += T.getTriple();
4440 CmdArgs.push_back(Args.MakeArgString(TargetInfo.str()));
4443 bool WholeProgramVTables =
4444 Args.hasFlag(options::OPT_fwhole_program_vtables,
4445 options::OPT_fno_whole_program_vtables,
false);
4446 if (WholeProgramVTables) {
4448 D.
Diag(diag::err_drv_argument_only_allowed_with)
4449 <<
"-fwhole-program-vtables"
4451 CmdArgs.push_back(
"-fwhole-program-vtables");
4455 if (Args.hasArg(options::OPT__SLASH_fallback) &&
4456 Output.
getType() == types::TY_Object &&
4457 (InputType == types::TY_C || InputType == types::TY_CXX)) {
4459 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4460 C.
addCommand(llvm::make_unique<FallbackCommand>(
4461 JA, *
this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
4462 }
else if (Args.hasArg(options::OPT__SLASH_fallback) &&
4463 isa<PrecompileJobAction>(JA)) {
4466 C.
addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *
this, Exec,
4469 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
4475 if (SplitDwarf && Output.
getType() == types::TY_Object)
4476 SplitDebugInfo(getToolChain(), C, *
this, JA, Args, Output, SplitDwarfOut);
4478 if (Arg *A = Args.getLastArg(options::OPT_pg))
4479 if (Args.hasArg(options::OPT_fomit_frame_pointer))
4480 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
4481 << A->getAsString(Args);
4488 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
4492 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4493 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
4496 Args.ClaimAllArgs(options::OPT_emit_llvm);
4503 :
Tool(
"clang",
"clang frontend", TC, RF_Full) {}
4510 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
4511 ArgStringList &cmdArgs,
4512 RewriteKind rewriteKind)
const {
4515 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
4516 options::OPT_fobjc_runtime_EQ);
4521 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4523 StringRef value = runtimeArg->getValue();
4529 runtimeArg->render(args, cmdArgs);
4538 unsigned objcABIVersion = 1;
4540 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
4541 StringRef value = abiArg->getValue();
4544 else if (value ==
"2")
4546 else if (value ==
"3")
4552 bool nonFragileABIIsDefault =
4553 (rewriteKind == RK_NonFragile ||
4554 (rewriteKind == RK_None &&
4556 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4557 options::OPT_fno_objc_nonfragile_abi,
4558 nonFragileABIIsDefault)) {
4560 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4561 unsigned nonFragileABIVersion = 1;
4563 unsigned nonFragileABIVersion = 2;
4567 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
4568 StringRef value = abiArg->getValue();
4570 nonFragileABIVersion = 1;
4571 else if (value ==
"2")
4572 nonFragileABIVersion = 2;
4578 objcABIVersion = 1 + nonFragileABIVersion;
4586 bool isNonFragile = objcABIVersion != 1;
4592 switch (rewriteKind) {
4605 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4617 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
4627 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
4632 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
4640 bool Asynch =
false;
4641 bool NoUnwindC =
false;
4655 std::vector<std::string> EHArgs =
4656 Args.getAllArgValues(options::OPT__SLASH_EH);
4657 for (
auto EHVal : EHArgs) {
4658 for (
size_t I = 0,
E = EHVal.size();
I !=
E; ++
I) {
4676 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
4682 if (EHArgs.empty() &&
4683 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
4686 EH.NoUnwindC =
true;
4692 void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
4693 ArgStringList &CmdArgs,
4695 bool *EmitCodeView)
const {
4696 unsigned RTOptionID = options::OPT__SLASH_MT;
4698 if (Args.hasArg(options::OPT__SLASH_LDd))
4701 RTOptionID = options::OPT__SLASH_MTd;
4703 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4704 RTOptionID = A->getOption().getID();
4706 StringRef FlagForCRT;
4707 switch (RTOptionID) {
4708 case options::OPT__SLASH_MD:
4709 if (Args.hasArg(options::OPT__SLASH_LDd))
4710 CmdArgs.push_back(
"-D_DEBUG");
4711 CmdArgs.push_back(
"-D_MT");
4712 CmdArgs.push_back(
"-D_DLL");
4713 FlagForCRT =
"--dependent-lib=msvcrt";
4715 case options::OPT__SLASH_MDd:
4716 CmdArgs.push_back(
"-D_DEBUG");
4717 CmdArgs.push_back(
"-D_MT");
4718 CmdArgs.push_back(
"-D_DLL");
4719 FlagForCRT =
"--dependent-lib=msvcrtd";
4721 case options::OPT__SLASH_MT:
4722 if (Args.hasArg(options::OPT__SLASH_LDd))
4723 CmdArgs.push_back(
"-D_DEBUG");
4724 CmdArgs.push_back(
"-D_MT");
4725 CmdArgs.push_back(
"-flto-visibility-public-std");
4726 FlagForCRT =
"--dependent-lib=libcmt";
4728 case options::OPT__SLASH_MTd:
4729 CmdArgs.push_back(
"-D_DEBUG");
4730 CmdArgs.push_back(
"-D_MT");
4731 CmdArgs.push_back(
"-flto-visibility-public-std");
4732 FlagForCRT =
"--dependent-lib=libcmtd";
4735 llvm_unreachable(
"Unexpected option ID.");
4738 if (Args.hasArg(options::OPT__SLASH_Zl)) {
4739 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4741 CmdArgs.push_back(FlagForCRT.data());
4746 CmdArgs.push_back(
"--dependent-lib=oldnames");
4751 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4752 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4753 A->render(Args, CmdArgs);
4756 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4758 CmdArgs.push_back(
"-fno-rtti-data");
4762 if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
4764 CmdArgs.push_back(
"-stack-protector");
4769 if (Arg *DebugInfoArg =
4770 Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
4771 options::OPT_gline_tables_only)) {
4772 *EmitCodeView =
true;
4773 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
4777 CmdArgs.push_back(
"-gcodeview");
4779 *EmitCodeView =
false;
4784 if (EH.Synch || EH.Asynch) {
4786 CmdArgs.push_back(
"-fcxx-exceptions");
4787 CmdArgs.push_back(
"-fexceptions");
4789 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
4790 CmdArgs.push_back(
"-fexternc-nounwind");
4793 if (Args.hasArg(options::OPT__SLASH_EP)) {
4794 CmdArgs.push_back(
"-E");
4795 CmdArgs.push_back(
"-P");
4798 unsigned VolatileOptionID;
4799 if (
getToolChain().getArch() == llvm::Triple::x86_64 ||
4801 VolatileOptionID = options::OPT__SLASH_volatile_ms;
4803 VolatileOptionID = options::OPT__SLASH_volatile_iso;
4805 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
4806 VolatileOptionID = A->getOption().getID();
4808 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
4809 CmdArgs.push_back(
"-fms-volatile");
4811 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4812 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4813 if (MostGeneralArg && BestCaseArg)
4814 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
4815 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4817 if (MostGeneralArg) {
4818 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4819 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4820 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4822 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4823 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4824 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4825 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
4826 << FirstConflict->getAsString(Args)
4827 << SecondConflict->getAsString(Args);
4830 CmdArgs.push_back(
"-fms-memptr-rep=single");
4831 else if (MultipleArg)
4832 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
4834 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
4839 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
4840 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv)) {
4841 unsigned DCCOptId = CCArg->getOption().getID();
4842 const char *DCCFlag =
nullptr;
4843 bool ArchSupported =
true;
4846 case options::OPT__SLASH_Gd:
4847 DCCFlag =
"-fdefault-calling-conv=cdecl";
4849 case options::OPT__SLASH_Gr:
4850 ArchSupported = Arch == llvm::Triple::x86;
4851 DCCFlag =
"-fdefault-calling-conv=fastcall";
4853 case options::OPT__SLASH_Gz:
4854 ArchSupported = Arch == llvm::Triple::x86;
4855 DCCFlag =
"-fdefault-calling-conv=stdcall";
4857 case options::OPT__SLASH_Gv:
4858 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
4859 DCCFlag =
"-fdefault-calling-conv=vectorcall";
4864 if (ArchSupported && DCCFlag)
4865 CmdArgs.push_back(DCCFlag);
4868 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4869 A->render(Args, CmdArgs);
4871 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4872 CmdArgs.push_back(
"-fdiagnostics-format");
4873 if (Args.hasArg(options::OPT__SLASH_fallback))
4874 CmdArgs.push_back(
"msvc-fallback");
4876 CmdArgs.push_back(
"msvc");
4883 return CLFallback.get();
4889 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
4896 if (
const char *
End = strrchr(Str,
'.'))
4897 return Args.MakeArgString(std::string(Str,
End));
4907 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4908 std::string Str(OutputOpt->getValue());
4909 Res = Str.substr(0, Str.rfind(
'.'));
4913 return Args.MakeArgString(Res +
".d");
4919 ArgStringList &CmdArgs)
const {
4925 CmdArgs.push_back(
"-target-abi");
4926 CmdArgs.push_back(ABIName.data());
4930 ArgStringList &CmdArgs)
const {
4931 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
4932 StringRef Value = A->getValue();
4933 if (Value ==
"intel" || Value ==
"att") {
4934 CmdArgs.push_back(
"-mllvm");
4935 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
4938 << A->getOption().getName() <<
Value;
4945 const ArgList &Args,
4946 const char *LinkingOutput)
const {
4947 ArgStringList CmdArgs;
4949 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
4953 const std::string &TripleStr = Triple.getTriple();
4957 Args.ClaimAllArgs(options::OPT_w);
4959 Args.ClaimAllArgs(options::OPT_emit_llvm);
4966 CmdArgs.push_back(
"-cc1as");
4969 CmdArgs.push_back(
"-triple");
4970 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4974 CmdArgs.push_back(
"-filetype");
4975 CmdArgs.push_back(
"obj");
4979 CmdArgs.push_back(
"-main-file-name");
4983 std::string CPU =
getCPUName(Args, Triple,
true);
4985 CmdArgs.push_back(
"-target-cpu");
4986 CmdArgs.push_back(Args.MakeArgString(CPU));
4993 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4996 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
4999 const Action *SourceAction = &JA;
5001 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
5002 SourceAction = SourceAction->
getInputs()[0];
5007 bool WantDebug =
false;
5008 unsigned DwarfVersion = 0;
5009 Args.ClaimAllArgs(options::OPT_g_Group);
5010 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
5011 WantDebug = !A->getOption().matches(options::OPT_g0) &&
5012 !A->getOption().matches(options::OPT_ggdb0);
5016 if (DwarfVersion == 0)
5021 if (SourceAction->
getType() == types::TY_Asm ||
5022 SourceAction->
getType() == types::TY_PP_Asm) {
5034 CmdArgs.push_back(
"-dwarf-debug-producer");
5038 Args.AddAllArgs(CmdArgs, options::OPT_I);
5047 llvm::Reloc::Model RelocationModel;
5050 std::tie(RelocationModel, PICLevel, IsPIE) =
5055 CmdArgs.push_back(
"-mrelocation-model");
5056 CmdArgs.push_back(RMName);
5062 ArgStringList OriginalArgs;
5063 for (
const auto &Arg : Args)
5064 Arg->render(Args, OriginalArgs);
5069 for (
const char *OriginalArg : OriginalArgs) {
5073 Flags += EscapedArg;
5075 CmdArgs.push_back(
"-dwarf-debug-flags");
5076 CmdArgs.push_back(Args.MakeArgString(Flags));
5086 case llvm::Triple::mips:
5087 case llvm::Triple::mipsel:
5088 case llvm::Triple::mips64:
5089 case llvm::Triple::mips64el:
5093 case llvm::Triple::x86:
5094 case llvm::Triple::x86_64:
5098 case llvm::Triple::arm:
5099 case llvm::Triple::armeb:
5100 case llvm::Triple::thumb:
5101 case llvm::Triple::thumbeb:
5104 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
5105 options::OPT_mno_default_build_attributes,
true)) {
5106 CmdArgs.push_back(
"-mllvm");
5107 CmdArgs.push_back(
"-arm-add-build-attributes");
5117 Args.ClaimAllArgs(options::OPT_W_Group);
5122 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
5124 assert(Output.
isFilename() &&
"Unexpected lipo output.");
5125 CmdArgs.push_back(
"-o");
5128 assert(Input.isFilename() &&
"Invalid input.");
5129 CmdArgs.push_back(Input.getFilename());
5132 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
5137 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
5148 const llvm::opt::ArgList &TCArgs,
5149 const char *LinkingOutput)
const {
5151 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
5159 ArgStringList CmdArgs;
5162 CmdArgs.push_back(TCArgs.MakeArgString(
5165 assert(JA.
getInputs().size() == Inputs.size() &&
5166 "Not have inputs for all dependence actions??");
5170 Triples +=
"-targets=";
5171 for (
unsigned I = 0;
I < Inputs.size(); ++
I) {
5179 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
5180 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
5187 Triples += CurTC->
getTriple().normalize();
5189 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
5193 TCArgs.MakeArgString(Twine(
"-outputs=") + Output.
getFilename()));
5198 for (
unsigned I = 0;
I < Inputs.size(); ++
I) {
5201 UB += Inputs[
I].getFilename();
5203 CmdArgs.push_back(TCArgs.MakeArgString(UB));
5214 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
5215 const char *LinkingOutput)
const {
5217 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
5226 ArgStringList CmdArgs;
5228 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
5232 CmdArgs.push_back(TCArgs.MakeArgString(
5237 Triples +=
"-targets=";
5238 auto DepInfo = UA.getDependentActionsInfo();
5239 for (
unsigned I = 0;
I < DepInfo.size(); ++
I) {
5243 auto &Dep = DepInfo[
I];
5246 Triples += Dep.DependentToolChain->getTriple().normalize();
5249 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
5253 TCArgs.MakeArgString(Twine(
"-inputs=") + Input.getFilename()));
5258 for (
unsigned I = 0;
I < Outputs.size(); ++
I) {
5261 UB += Outputs[
I].getFilename();
5263 CmdArgs.push_back(TCArgs.MakeArgString(UB));
5264 CmdArgs.push_back(
"-unbundle");
const Driver & getDriver() const
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]]].
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.
Defines types useful for describing an Objective-C runtime.
bool allowsWeak() const
Does this runtime allow the use of __weak?
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...
DiagnosticBuilder Diag(unsigned DiagID) const
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
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.
types::ID getType() const
static StringRef bytes(const std::vector< T, Allocator > &v)
bool embedBitcodeInObject() const
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
OffloadKind getOffloadingDeviceKind() const
ActionClass getKind() const
Action - Represent an abstract compilation step to perform.
static const char * RelocationModelName(llvm::Reloc::Model Model)
std::string getAsString() const
Retrieve a string representation of the version number.
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.
const llvm::opt::DerivedArgList & getArgs() const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
static void getAMDGPUTargetFeatures(const Driver &D, const ArgList &Args, std::vector< StringRef > &Features)
detail::InMemoryDirectory::const_iterator I
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
bool isSaveTempsEnabled() 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.
Exposes information about the current target.
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind DebugInfoKind, unsigned DwarfVersion, llvm::DebuggerKind DebuggerTuning)
Defines the clang::LangOptions interface.
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...
bool isForDiagnostics() const
Return true if we're compiling for diagnostics.
static unsigned DwarfVersionNum(StringRef ArgValue)
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
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.
void addCommand(std::unique_ptr< Command > C)
const char * getOffloadingArch() const
unsigned Map[FirstTargetAddressSpace]
The type of a lookup table which maps from language-specific address spaces to target-specific ones...
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
'gnustep' is the modern non-fragile GNUstep runtime.
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args)
static bool isSignedCharDefault(const llvm::Triple &Triple)
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
bool embedBitcodeMarkerOnly() const
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
static bool isNoCommonDefault(const llvm::Triple &Triple)
static void EscapeSpacesAndBackslashes(const char *Arg, SmallVectorImpl< char > &Res)
static LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
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...
const_offload_toolchains_range getOffloadToolChains() const
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.
unsigned getMajor() const
Retrieve the major version number.
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
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'.
const ToolChain & getDefaultToolChain() const
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
const char * CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
The basic abstraction for the target Objective-C runtime.
Emit location information but do not generate debug info in the output.
std::string SysRoot
sysroot, if present
detail::InMemoryDirectory::const_iterator E
bool isOffloading(OffloadKind OKind) const
ActionList & getActions()
const char * getClangProgramPath() const
Get the path to the main clang executable.
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args)
/EH controls whether to run destructor cleanups when exceptions are thrown.
static void getHexagonTargetFeatures(const ArgList &Args, std::vector< StringRef > &Features)
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).
void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args, InputList &Inputs) const
BuildInputs - Construct the list of inputs and their types from the given arguments.
Compilation - A set of tasks to perform for a single driver invocation.
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
const DiagnosticsEngine & getDiags() const
const char * CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
StringRef getSysRoot() const
Returns the sysroot path.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
const char * addFailureResultFile(const char *Name, const JobAction *JA)
addFailureResultFile - Add a file to remove if we crash, and returns its argument.
bool isDeviceOffloading(OffloadKind OKind) const
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.
std::string getAsString() const
static bool shouldUseLeafFramePointer(const ArgList &Args, const llvm::Triple &Triple)
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)
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
std::string ResourceDir
The path to the compiler resource directory.