34 #include "llvm/ADT/StringExtras.h" 35 #include "llvm/Config/llvm-config.h" 36 #include "llvm/Option/ArgList.h" 37 #include "llvm/Support/CodeGen.h" 38 #include "llvm/Support/Compression.h" 39 #include "llvm/Support/FileSystem.h" 40 #include "llvm/Support/Path.h" 41 #include "llvm/Support/Process.h" 42 #include "llvm/Support/TargetParser.h" 43 #include "llvm/Support/YAMLParser.h" 51 using namespace clang;
56 Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
57 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
58 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
59 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
60 << A->getBaseArg().getAsString(Args)
61 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
68 if (Args.hasArg(options::OPT_static))
70 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
71 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
96 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
101 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
117 Res.push_back(Target[i]);
126 llvm::function_ref<
void(
const ToolChain &)> Work) {
128 Work(RegularToolChain);
143 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
158 const Arg &A,
size_t &Position) {
159 const char RefinementStepToken =
':';
160 Position = In.find(RefinementStepToken);
161 if (Position != StringRef::npos) {
162 StringRef Option = A.getOption().getName();
163 StringRef RefStep = In.substr(Position + 1);
171 if (RefStep.size() != 1) {
172 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
175 char RefStepChar = RefStep[0];
176 if (RefStepChar < '0' || RefStepChar >
'9') {
177 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
186 ArgStringList &OutStrings) {
187 StringRef DisabledPrefixIn =
"!";
188 StringRef DisabledPrefixOut =
"!";
189 StringRef EnabledPrefixOut =
"";
190 StringRef Out =
"-mrecip=";
192 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
196 unsigned NumOptions = A->getNumValues();
197 if (NumOptions == 0) {
199 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
204 if (NumOptions == 1) {
205 StringRef Val = A->getValue(0);
209 StringRef ValBase = Val.slice(0, RefStepLoc);
210 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
211 OutStrings.push_back(Args.MakeArgString(Out + Val));
220 llvm::StringMap<bool> OptionStrings;
221 OptionStrings.insert(std::make_pair(
"divd",
false));
222 OptionStrings.insert(std::make_pair(
"divf",
false));
223 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
224 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
225 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
226 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
227 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
228 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
230 for (
unsigned i = 0; i != NumOptions; ++i) {
231 StringRef Val = A->getValue(i);
233 bool IsDisabled = Val.startswith(DisabledPrefixIn);
242 StringRef ValBase = Val.slice(0, RefStep);
243 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
244 if (OptionIter == OptionStrings.end()) {
246 OptionIter = OptionStrings.find(ValBase.str() +
'f');
247 if (OptionIter == OptionStrings.end()) {
249 D.
Diag(diag::err_drv_unknown_argument) << Val;
255 if (OptionStrings[ValBase.str() +
'd']) {
256 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
261 if (OptionIter->second ==
true) {
263 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
268 OptionIter->second =
true;
271 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
272 OptionStrings[ValBase.str() +
'd'] =
true;
275 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
276 Out = Args.MakeArgString(Out + Prefix + Val);
277 if (i != NumOptions - 1)
278 Out = Args.MakeArgString(Out +
",");
281 OutStrings.push_back(Args.MakeArgString(Out));
287 ArgStringList &CmdArgs) {
288 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
292 StringRef
Value = A->getValue();
293 if (Value ==
"none") {
294 CmdArgs.push_back(
"-mprefer-vector-width=none");
297 if (Value.getAsInteger(10, Width)) {
298 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
301 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + Value));
306 std::vector<StringRef> &Features) {
311 const ArgList &Args, ArgStringList &CmdArgs,
314 std::vector<StringRef> Features;
315 switch (Triple.getArch()) {
318 case llvm::Triple::mips:
319 case llvm::Triple::mipsel:
320 case llvm::Triple::mips64:
321 case llvm::Triple::mips64el:
325 case llvm::Triple::arm:
326 case llvm::Triple::armeb:
327 case llvm::Triple::thumb:
328 case llvm::Triple::thumbeb:
332 case llvm::Triple::ppc:
333 case llvm::Triple::ppc64:
334 case llvm::Triple::ppc64le:
337 case llvm::Triple::riscv32:
338 case llvm::Triple::riscv64:
341 case llvm::Triple::systemz:
344 case llvm::Triple::aarch64:
345 case llvm::Triple::aarch64_32:
346 case llvm::Triple::aarch64_be:
349 case llvm::Triple::x86:
350 case llvm::Triple::x86_64:
353 case llvm::Triple::hexagon:
356 case llvm::Triple::wasm32:
357 case llvm::Triple::wasm64:
360 case llvm::Triple::sparc:
361 case llvm::Triple::sparcel:
362 case llvm::Triple::sparcv9:
365 case llvm::Triple::r600:
366 case llvm::Triple::amdgcn:
369 case llvm::Triple::msp430:
374 llvm::StringMap<unsigned> LastOpt;
375 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
376 StringRef Name = Features[I];
377 assert(Name[0] ==
'-' || Name[0] ==
'+');
378 LastOpt[Name.drop_front(1)] = I;
381 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
383 StringRef Name = Features[I];
384 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
385 assert(LastI != LastOpt.end());
386 unsigned Last = LastI->second;
390 CmdArgs.push_back(
"-target-feature");
391 CmdArgs.push_back(Name.data());
397 const llvm::Triple &Triple) {
404 if (!Triple.isMacOSX())
407 return (!Triple.isMacOSXVersionLT(10, 5) &&
408 (Triple.getArch() == llvm::Triple::x86_64 ||
409 Triple.getArch() == llvm::Triple::arm));
419 ArgStringList &CmdArgs) {
420 const llvm::Triple &Triple = TC.
getTriple();
425 Args.ClaimAllArgs(options::OPT_fexceptions);
426 Args.ClaimAllArgs(options::OPT_fno_exceptions);
427 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
428 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
429 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
430 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
435 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
441 Args.hasFlag(options::OPT_fobjc_exceptions,
442 options::OPT_fno_objc_exceptions,
true)) {
443 CmdArgs.push_back(
"-fobjc-exceptions");
450 bool CXXExceptionsEnabled =
451 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
452 Arg *ExceptionArg = Args.getLastArg(
453 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
454 options::OPT_fexceptions, options::OPT_fno_exceptions);
456 CXXExceptionsEnabled =
457 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
458 ExceptionArg->getOption().matches(options::OPT_fexceptions);
460 if (CXXExceptionsEnabled) {
461 CmdArgs.push_back(
"-fcxx-exceptions");
468 CmdArgs.push_back(
"-fexceptions");
483 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
489 bool UseDwarfDirectory =
490 Args.hasFlag(options::OPT_fdwarf_directory_asm,
492 return !UseDwarfDirectory;
498 assert(A.getOption().matches(options::OPT_gN_Group) &&
499 "Not a -g option that specifies a debug-info level");
500 if (A.getOption().matches(options::OPT_g0) ||
501 A.getOption().matches(options::OPT_ggdb0))
503 if (A.getOption().matches(options::OPT_gline_tables_only) ||
504 A.getOption().matches(options::OPT_ggdb1))
506 if (A.getOption().matches(options::OPT_gline_directives_only))
512 switch (Triple.getArch()){
515 case llvm::Triple::arm:
516 case llvm::Triple::thumb:
519 return Triple.isOSDarwin();
524 const llvm::Triple &Triple) {
525 if (Args.hasArg(options::OPT_pg))
528 switch (Triple.getArch()) {
529 case llvm::Triple::xcore:
530 case llvm::Triple::wasm32:
531 case llvm::Triple::wasm64:
532 case llvm::Triple::msp430:
536 case llvm::Triple::ppc:
537 case llvm::Triple::ppc64:
538 case llvm::Triple::ppc64le:
539 case llvm::Triple::riscv32:
540 case llvm::Triple::riscv64:
541 case llvm::Triple::amdgcn:
542 case llvm::Triple::r600:
548 if (Triple.isOSNetBSD()) {
552 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI ||
554 switch (Triple.getArch()) {
556 case llvm::Triple::mips64:
557 case llvm::Triple::mips64el:
558 case llvm::Triple::mips:
559 case llvm::Triple::mipsel:
560 case llvm::Triple::systemz:
561 case llvm::Triple::x86:
562 case llvm::Triple::x86_64:
569 if (Triple.isOSWindows()) {
570 switch (Triple.getArch()) {
571 case llvm::Triple::x86:
573 case llvm::Triple::x86_64:
574 return Triple.isOSBinFormatMachO();
575 case llvm::Triple::arm:
576 case llvm::Triple::thumb:
601 Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
602 options::OPT_fno_omit_frame_pointer);
603 bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer);
605 A && A->getOption().matches(options::OPT_fno_omit_frame_pointer);
606 bool KeepLeaf = Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
607 options::OPT_mno_omit_leaf_frame_pointer,
608 Triple.isAArch64() || Triple.isPS4CPU());
620 const llvm::vfs::FileSystem &VFS) {
621 if (Arg *A = Args.getLastArg(options::OPT_fdebug_compilation_dir)) {
622 CmdArgs.push_back(
"-fdebug-compilation-dir");
623 CmdArgs.push_back(A->getValue());
624 }
else if (llvm::ErrorOr<std::string> CWD =
625 VFS.getCurrentWorkingDirectory()) {
626 CmdArgs.push_back(
"-fdebug-compilation-dir");
627 CmdArgs.push_back(Args.MakeArgString(*CWD));
633 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
634 options::OPT_fdebug_prefix_map_EQ)) {
635 StringRef Map = A->getValue();
636 if (Map.find(
'=') == StringRef::npos)
637 D.
Diag(diag::err_drv_invalid_argument_to_option)
638 << Map << A->getOption().getName();
640 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
647 ArgStringList &CmdArgs) {
648 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
649 options::OPT_fmacro_prefix_map_EQ)) {
650 StringRef Map = A->getValue();
651 if (Map.find(
'=') == StringRef::npos)
652 D.
Diag(diag::err_drv_invalid_argument_to_option)
653 << Map << A->getOption().getName();
655 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
664 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
665 if (A->getOption().matches(options::OPT_O4) ||
666 A->getOption().matches(options::OPT_Ofast))
669 if (A->getOption().matches(options::OPT_O0))
672 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
675 StringRef S(A->getValue());
683 unsigned OptLevel = 0;
684 if (S.getAsInteger(10, OptLevel))
695 ArgStringList &CmdArgs) {
698 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
701 CmdArgs.push_back(
"-x");
702 if (Args.hasArg(options::OPT_rewrite_objc))
708 const char *ClangType;
710 case types::TY_CXXModule:
713 case types::TY_PP_CXXModule:
714 ClangType =
"c++-cpp-output";
720 CmdArgs.push_back(ClangType);
726 const char *Username = getenv(
"LOGNAME");
728 const char *Username = getenv(
"USERNAME");
733 for (
const char *
P = Username; *
P; ++
P, ++Len) {
740 if (Username && Len > 0) {
741 Result.append(Username, Username + Len);
748 std::string UID = llvm::utostr(getuid());
751 std::string UID =
"9999";
753 Result.append(UID.begin(), UID.end());
759 ArgStringList &CmdArgs) {
761 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
762 options::OPT_fprofile_generate_EQ,
763 options::OPT_fno_profile_generate);
764 if (PGOGenerateArg &&
765 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
766 PGOGenerateArg =
nullptr;
768 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
769 options::OPT_fcs_profile_generate_EQ,
770 options::OPT_fno_profile_generate);
771 if (CSPGOGenerateArg &&
772 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
773 CSPGOGenerateArg =
nullptr;
775 auto *ProfileGenerateArg = Args.getLastArg(
776 options::OPT_fprofile_instr_generate,
777 options::OPT_fprofile_instr_generate_EQ,
778 options::OPT_fno_profile_instr_generate);
779 if (ProfileGenerateArg &&
780 ProfileGenerateArg->getOption().matches(
781 options::OPT_fno_profile_instr_generate))
782 ProfileGenerateArg =
nullptr;
784 if (PGOGenerateArg && ProfileGenerateArg)
785 D.
Diag(diag::err_drv_argument_not_allowed_with)
786 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
790 if (PGOGenerateArg && ProfileUseArg)
791 D.
Diag(diag::err_drv_argument_not_allowed_with)
792 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
794 if (ProfileGenerateArg && ProfileUseArg)
795 D.
Diag(diag::err_drv_argument_not_allowed_with)
796 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
798 if (CSPGOGenerateArg && PGOGenerateArg)
799 D.
Diag(diag::err_drv_argument_not_allowed_with)
800 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
802 if (ProfileGenerateArg) {
803 if (ProfileGenerateArg->getOption().matches(
804 options::OPT_fprofile_instr_generate_EQ))
805 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
806 ProfileGenerateArg->getValue()));
808 CmdArgs.push_back(
"-fprofile-instrument=clang");
809 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
811 CmdArgs.push_back(Args.MakeArgString(
"--dependent-lib=" +
816 Arg *PGOGenArg =
nullptr;
817 if (PGOGenerateArg) {
818 assert(!CSPGOGenerateArg);
819 PGOGenArg = PGOGenerateArg;
820 CmdArgs.push_back(
"-fprofile-instrument=llvm");
822 if (CSPGOGenerateArg) {
823 assert(!PGOGenerateArg);
824 PGOGenArg = CSPGOGenerateArg;
825 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
828 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
829 CmdArgs.push_back(Args.MakeArgString(
"--dependent-lib=" +
832 if (PGOGenArg->getOption().matches(
833 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
834 : options::OPT_fcs_profile_generate_EQ)) {
836 llvm::sys::path::append(Path,
"default_%m.profraw");
838 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
843 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
844 CmdArgs.push_back(Args.MakeArgString(
845 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
846 else if ((ProfileUseArg->getOption().matches(
847 options::OPT_fprofile_use_EQ) ||
848 ProfileUseArg->getOption().matches(
849 options::OPT_fprofile_instr_use))) {
851 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
852 if (Path.empty() || llvm::sys::fs::is_directory(Path))
853 llvm::sys::path::append(Path,
"default.profdata");
855 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
859 bool EmitCovNotes = Args.hasArg(options::OPT_ftest_coverage) ||
860 Args.hasArg(options::OPT_coverage);
861 bool EmitCovData = Args.hasFlag(options::OPT_fprofile_arcs,
862 options::OPT_fno_profile_arcs,
false) ||
863 Args.hasArg(options::OPT_coverage);
865 CmdArgs.push_back(
"-femit-coverage-notes");
867 CmdArgs.push_back(
"-femit-coverage-data");
869 if (Args.hasFlag(options::OPT_fcoverage_mapping,
870 options::OPT_fno_coverage_mapping,
false)) {
871 if (!ProfileGenerateArg)
872 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
873 <<
"-fcoverage-mapping" 874 <<
"-fprofile-instr-generate";
876 CmdArgs.push_back(
"-fcoverage-mapping");
879 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
880 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
881 if (!Args.hasArg(options::OPT_coverage))
882 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
883 <<
"-fprofile-exclude-files=" 886 StringRef
v = Arg->getValue();
888 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" + v)));
891 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
892 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
893 if (!Args.hasArg(options::OPT_coverage))
894 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
895 <<
"-fprofile-filter-files=" 898 StringRef
v = Arg->getValue();
899 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" + v)));
906 Arg *FProfileDir =
nullptr;
907 if (Args.hasArg(options::OPT_fprofile_arcs) ||
908 Args.hasArg(options::OPT_coverage))
909 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
916 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
917 (EmitCovNotes || EmitCovData) && Output.
isFilename()) {
919 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT__SLASH_Fo))
920 OutputFilename = FinalOutput->getValue();
921 else if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o))
922 OutputFilename = FinalOutput->getValue();
924 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
926 if (llvm::sys::path::is_relative(CoverageFilename))
927 (
void)D.
getVFS().makeAbsolute(CoverageFilename);
928 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
930 CmdArgs.push_back(
"-coverage-notes-file");
931 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
935 CoverageFilename = FProfileDir->getValue();
936 llvm::sys::path::append(CoverageFilename, OutputFilename);
938 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
939 CmdArgs.push_back(
"-coverage-data-file");
940 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
947 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
950 for (
const auto &AI : A->
inputs())
960 bool RelaxDefault =
true;
962 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
963 RelaxDefault = A->getOption().matches(options::OPT_O0);
966 RelaxDefault =
false;
975 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
983 return llvm::StringSwitch<unsigned>(ArgValue)
984 .Case(
"-gdwarf-2", 2)
985 .Case(
"-gdwarf-3", 3)
986 .Case(
"-gdwarf-4", 4)
987 .Case(
"-gdwarf-5", 5)
993 unsigned DwarfVersion,
994 llvm::DebuggerKind DebuggerTuning) {
995 switch (DebugInfoKind) {
997 CmdArgs.push_back(
"-debug-info-kind=line-directives-only");
1000 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
1003 CmdArgs.push_back(
"-debug-info-kind=constructor");
1006 CmdArgs.push_back(
"-debug-info-kind=limited");
1009 CmdArgs.push_back(
"-debug-info-kind=standalone");
1014 if (DwarfVersion > 0)
1016 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
1017 switch (DebuggerTuning) {
1018 case llvm::DebuggerKind::GDB:
1019 CmdArgs.push_back(
"-debugger-tuning=gdb");
1021 case llvm::DebuggerKind::LLDB:
1022 CmdArgs.push_back(
"-debugger-tuning=lldb");
1024 case llvm::DebuggerKind::SCE:
1025 CmdArgs.push_back(
"-debugger-tuning=sce");
1034 assert(A &&
"Expected non-nullptr argument.");
1037 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
1043 ArgStringList &CmdArgs,
1046 const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ);
1050 if (A->getOption().getID() == options::OPT_gz) {
1051 if (llvm::zlib::isAvailable())
1052 CmdArgs.push_back(
"--compress-debug-sections");
1054 D.
Diag(diag::warn_debug_compression_unavailable);
1058 StringRef
Value = A->getValue();
1059 if (Value ==
"none") {
1060 CmdArgs.push_back(
"--compress-debug-sections=none");
1061 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
1062 if (llvm::zlib::isAvailable()) {
1064 Args.MakeArgString(
"--compress-debug-sections=" + Twine(Value)));
1066 D.
Diag(diag::warn_debug_compression_unavailable);
1069 D.
Diag(diag::err_drv_unsupported_option_argument)
1070 << A->getOption().getName() <<
Value;
1077 case llvm::Reloc::Static:
1079 case llvm::Reloc::PIC_:
1081 case llvm::Reloc::DynamicNoPIC:
1082 return "dynamic-no-pic";
1083 case llvm::Reloc::ROPI:
1085 case llvm::Reloc::RWPI:
1087 case llvm::Reloc::ROPI_RWPI:
1090 llvm_unreachable(
"Unknown Reloc::Model kind");
1094 const Driver &D,
const ArgList &Args,
1095 ArgStringList &CmdArgs,
1098 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
1102 Args.AddLastArg(CmdArgs, options::OPT_C);
1103 Args.AddLastArg(CmdArgs, options::OPT_CC);
1106 Arg *ArgM = Args.getLastArg(options::OPT_MM);
1108 ArgM = Args.getLastArg(options::OPT_M);
1109 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1111 ArgMD = Args.getLastArg(options::OPT_MD);
1115 CmdArgs.push_back(
"-w");
1121 const char *DepFile;
1122 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1123 DepFile = MF->getValue();
1125 }
else if (Output.
getType() == types::TY_Dependencies) {
1127 }
else if (!ArgMD) {
1130 DepFile = getDependencyFileName(Args, Inputs);
1133 CmdArgs.push_back(
"-dependency-file");
1134 CmdArgs.push_back(DepFile);
1136 bool HasTarget =
false;
1137 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1140 if (A->getOption().matches(options::OPT_MT)) {
1141 A->render(Args, CmdArgs);
1143 CmdArgs.push_back(
"-MT");
1146 CmdArgs.push_back(Args.MakeArgString(Quoted));
1152 const char *DepTarget;
1156 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1157 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1158 DepTarget = OutputOpt->getValue();
1164 llvm::sys::path::replace_extension(P,
"o");
1165 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1168 CmdArgs.push_back(
"-MT");
1171 CmdArgs.push_back(Args.MakeArgString(Quoted));
1174 if (ArgM->getOption().matches(options::OPT_M) ||
1175 ArgM->getOption().matches(options::OPT_MD))
1176 CmdArgs.push_back(
"-sys-header-deps");
1177 if ((isa<PrecompileJobAction>(JA) &&
1178 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1179 Args.hasArg(options::OPT_fmodule_file_deps))
1180 CmdArgs.push_back(
"-module-file-deps");
1183 if (Args.hasArg(options::OPT_MG)) {
1184 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1185 ArgM->getOption().matches(options::OPT_MMD))
1186 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1187 CmdArgs.push_back(
"-MG");
1190 Args.AddLastArg(CmdArgs, options::OPT_MP);
1191 Args.AddLastArg(CmdArgs, options::OPT_MV);
1198 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1203 getToolChain().getTriple().isNVPTX()){
1204 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1208 llvm::sys::path::append(P,
"include");
1209 llvm::sys::path::append(P,
"openmp_wrappers");
1210 CmdArgs.push_back(
"-internal-isystem");
1211 CmdArgs.push_back(Args.MakeArgString(P));
1214 CmdArgs.push_back(
"-include");
1215 CmdArgs.push_back(
"__clang_openmp_math_declares.h");
1224 if (getToolChain().getDriver().IsCLMode()) {
1225 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1226 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1229 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1231 if (YcArg || YuArg) {
1232 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1233 if (!isa<PrecompileJobAction>(JA)) {
1234 CmdArgs.push_back(
"-include-pch");
1236 C, !ThroughHeader.empty()
1238 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1241 if (ThroughHeader.empty()) {
1242 CmdArgs.push_back(Args.MakeArgString(
1243 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1246 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1251 bool RenderedImplicitInclude =
false;
1252 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1253 if (A->getOption().matches(options::OPT_include)) {
1255 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1256 RenderedImplicitInclude =
true;
1258 bool FoundPCH =
false;
1263 llvm::sys::path::replace_extension(P,
"pch");
1264 if (llvm::sys::fs::exists(P))
1268 llvm::sys::path::replace_extension(P,
"gch");
1269 if (llvm::sys::fs::exists(P)) {
1275 if (IsFirstImplicitInclude) {
1277 CmdArgs.push_back(
"-include-pch");
1278 CmdArgs.push_back(Args.MakeArgString(P));
1282 D.
Diag(diag::warn_drv_pch_not_first_include) << P
1283 << A->getAsString(Args);
1286 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1293 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1300 A->render(Args, CmdArgs);
1303 Args.AddAllArgs(CmdArgs,
1304 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1305 options::OPT_F, options::OPT_index_header_map});
1313 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1314 options::OPT_Xpreprocessor);
1317 if (Arg *A = Args.getLastArg(options::OPT_I_))
1318 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1323 if (sysroot !=
"") {
1324 if (!Args.hasArg(options::OPT_isysroot)) {
1325 CmdArgs.push_back(
"-isysroot");
1326 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
1343 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1351 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1353 C, JA, getToolChain(),
1354 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1363 [&Args, &CmdArgs](
const ToolChain &TC) {
1368 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1376 switch (Triple.getArch()) {
1380 case llvm::Triple::aarch64:
1381 case llvm::Triple::aarch64_32:
1382 case llvm::Triple::aarch64_be:
1383 case llvm::Triple::arm:
1384 case llvm::Triple::armeb:
1385 case llvm::Triple::thumb:
1386 case llvm::Triple::thumbeb:
1387 if (Triple.isOSDarwin() || Triple.isOSWindows())
1391 case llvm::Triple::ppc:
1392 case llvm::Triple::ppc64:
1393 if (Triple.isOSDarwin())
1397 case llvm::Triple::hexagon:
1398 case llvm::Triple::ppc64le:
1399 case llvm::Triple::riscv32:
1400 case llvm::Triple::riscv64:
1401 case llvm::Triple::systemz:
1402 case llvm::Triple::xcore:
1408 switch (Triple.getArch()) {
1410 if (Triple.isOSFuchsia())
1414 case llvm::Triple::xcore:
1415 case llvm::Triple::wasm32:
1416 case llvm::Triple::wasm64:
1422 const ArgList &Args) {
1425 if (!Triple.isOSDarwin())
1429 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1433 const llvm::Triple &Triple) {
1438 bool hasExplicitOutputFile =
1439 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1440 if (hasMultipleInvocations && hasExplicitOutputFile) {
1441 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1442 <<
"-foptimization-record-file";
1449 const llvm::Triple &Triple,
1452 StringRef Format =
"yaml";
1453 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1454 Format = A->getValue();
1456 CmdArgs.push_back(
"-opt-record-file");
1458 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1460 CmdArgs.push_back(A->getValue());
1462 bool hasMultipleArchs =
1463 Triple.isOSDarwin() &&
1464 Args.getAllArgValues(options::OPT_arch).size() > 1;
1468 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1469 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1470 F = FinalOutput->getValue();
1472 if (Format !=
"yaml" &&
1473 Triple.isOSDarwin() &&
1487 llvm::sys::path::replace_extension(F,
"");
1489 Triple.normalize());
1499 if (hasMultipleArchs) {
1503 llvm::sys::path::replace_extension(F,
"");
1506 F += Triple.getArchName();
1508 llvm::sys::path::replace_extension(F, OldExtension);
1512 Extension +=
"opt.";
1513 Extension += Format;
1515 llvm::sys::path::replace_extension(F, Extension);
1516 CmdArgs.push_back(Args.MakeArgString(F));
1520 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1521 CmdArgs.push_back(
"-opt-record-passes");
1522 CmdArgs.push_back(A->getValue());
1525 if (!Format.empty()) {
1526 CmdArgs.push_back(
"-opt-record-format");
1527 CmdArgs.push_back(Format.data());
1532 void RenderARMABI(
const llvm::Triple &Triple,
const ArgList &Args,
1533 ArgStringList &CmdArgs) {
1537 const char *ABIName =
nullptr;
1538 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1539 ABIName = A->getValue();
1541 std::string CPU =
getCPUName(Args, Triple,
false);
1542 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1545 CmdArgs.push_back(
"-target-abi");
1546 CmdArgs.push_back(ABIName);
1550 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1551 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1552 RenderARMABI(Triple, Args, CmdArgs);
1559 CmdArgs.push_back(
"-msoft-float");
1560 CmdArgs.push_back(
"-mfloat-abi");
1561 CmdArgs.push_back(
"soft");
1564 CmdArgs.push_back(
"-mfloat-abi");
1565 CmdArgs.push_back(
"soft");
1569 CmdArgs.push_back(
"-mfloat-abi");
1570 CmdArgs.push_back(
"hard");
1574 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1575 options::OPT_mno_global_merge)) {
1576 CmdArgs.push_back(
"-mllvm");
1577 if (A->getOption().matches(options::OPT_mno_global_merge))
1578 CmdArgs.push_back(
"-arm-global-merge=false");
1580 CmdArgs.push_back(
"-arm-global-merge=true");
1583 if (!Args.hasFlag(options::OPT_mimplicit_float,
1584 options::OPT_mno_implicit_float,
true))
1585 CmdArgs.push_back(
"-no-implicit-float");
1587 if (Args.getLastArg(options::OPT_mcmse))
1588 CmdArgs.push_back(
"-mcmse");
1591 void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1592 const ArgList &Args,
bool KernelOrKext,
1593 ArgStringList &CmdArgs)
const {
1604 case llvm::Triple::arm:
1605 case llvm::Triple::armeb:
1606 case llvm::Triple::thumb:
1607 case llvm::Triple::thumbeb:
1609 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1610 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1613 case llvm::Triple::aarch64:
1614 case llvm::Triple::aarch64_32:
1615 case llvm::Triple::aarch64_be:
1616 AddAArch64TargetArgs(Args, CmdArgs);
1617 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1620 case llvm::Triple::mips:
1621 case llvm::Triple::mipsel:
1622 case llvm::Triple::mips64:
1623 case llvm::Triple::mips64el:
1624 AddMIPSTargetArgs(Args, CmdArgs);
1627 case llvm::Triple::ppc:
1628 case llvm::Triple::ppc64:
1629 case llvm::Triple::ppc64le:
1630 AddPPCTargetArgs(Args, CmdArgs);
1633 case llvm::Triple::riscv32:
1634 case llvm::Triple::riscv64:
1635 AddRISCVTargetArgs(Args, CmdArgs);
1638 case llvm::Triple::sparc:
1639 case llvm::Triple::sparcel:
1640 case llvm::Triple::sparcv9:
1641 AddSparcTargetArgs(Args, CmdArgs);
1644 case llvm::Triple::systemz:
1645 AddSystemZTargetArgs(Args, CmdArgs);
1648 case llvm::Triple::x86:
1649 case llvm::Triple::x86_64:
1650 AddX86TargetArgs(Args, CmdArgs);
1653 case llvm::Triple::lanai:
1654 AddLanaiTargetArgs(Args, CmdArgs);
1657 case llvm::Triple::hexagon:
1658 AddHexagonTargetArgs(Args, CmdArgs);
1661 case llvm::Triple::wasm32:
1662 case llvm::Triple::wasm64:
1663 AddWebAssemblyTargetArgs(Args, CmdArgs);
1669 void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1670 ArgStringList &CmdArgs) {
1671 const char *ABIName =
nullptr;
1672 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1673 ABIName = A->getValue();
1674 else if (Triple.isOSDarwin())
1675 ABIName =
"darwinpcs";
1679 CmdArgs.push_back(
"-target-abi");
1680 CmdArgs.push_back(ABIName);
1684 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1685 ArgStringList &CmdArgs)
const {
1686 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1688 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1689 Args.hasArg(options::OPT_mkernel) ||
1690 Args.hasArg(options::OPT_fapple_kext))
1691 CmdArgs.push_back(
"-disable-red-zone");
1693 if (!Args.hasFlag(options::OPT_mimplicit_float,
1694 options::OPT_mno_implicit_float,
true))
1695 CmdArgs.push_back(
"-no-implicit-float");
1697 RenderAArch64ABI(Triple, Args, CmdArgs);
1699 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1700 options::OPT_mno_fix_cortex_a53_835769)) {
1701 CmdArgs.push_back(
"-mllvm");
1702 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1703 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1705 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1706 }
else if (Triple.isAndroid()) {
1708 CmdArgs.push_back(
"-mllvm");
1709 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1713 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1714 options::OPT_mno_global_merge)) {
1715 CmdArgs.push_back(
"-mllvm");
1716 if (A->getOption().matches(options::OPT_mno_global_merge))
1717 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1719 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1723 if (Arg *A = Args.getLastArg(options::OPT_msign_return_address_EQ,
1724 options::OPT_mbranch_protection_EQ)) {
1726 const Driver &D = getToolChain().getDriver();
1728 StringRef
Scope, Key;
1729 bool IndirectBranches;
1731 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1732 Scope = A->getValue();
1733 if (!Scope.equals(
"none") && !Scope.equals(
"non-leaf") &&
1734 !Scope.equals(
"all"))
1735 D.
Diag(diag::err_invalid_branch_protection)
1736 << Scope << A->getAsString(Args);
1738 IndirectBranches =
false;
1741 llvm::AArch64::ParsedBranchProtection PBP;
1742 if (!llvm::AArch64::parseBranchProtection(A->getValue(), PBP, Err))
1743 D.
Diag(diag::err_invalid_branch_protection)
1744 << Err << A->getAsString(Args);
1747 IndirectBranches = PBP.BranchTargetEnforcement;
1751 Args.MakeArgString(Twine(
"-msign-return-address=") + Scope));
1753 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1754 if (IndirectBranches)
1755 CmdArgs.push_back(
"-mbranch-target-enforce");
1759 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1760 ArgStringList &CmdArgs)
const {
1761 const Driver &D = getToolChain().getDriver();
1764 const llvm::Triple &Triple = getToolChain().getTriple();
1767 CmdArgs.push_back(
"-target-abi");
1768 CmdArgs.push_back(ABIName.data());
1773 CmdArgs.push_back(
"-msoft-float");
1774 CmdArgs.push_back(
"-mfloat-abi");
1775 CmdArgs.push_back(
"soft");
1779 CmdArgs.push_back(
"-mfloat-abi");
1780 CmdArgs.push_back(
"hard");
1783 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1784 options::OPT_mno_ldc1_sdc1)) {
1785 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1786 CmdArgs.push_back(
"-mllvm");
1787 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1791 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1792 options::OPT_mno_check_zero_division)) {
1793 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1794 CmdArgs.push_back(
"-mllvm");
1795 CmdArgs.push_back(
"-mno-check-zero-division");
1799 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1800 StringRef
v = A->getValue();
1801 CmdArgs.push_back(
"-mllvm");
1802 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1806 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1808 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1821 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1823 llvm::Reloc::Model RelocationModel;
1826 std::tie(RelocationModel, PICLevel, IsPIE) =
1829 NoABICalls = NoABICalls ||
1830 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1832 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1834 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1835 CmdArgs.push_back(
"-mllvm");
1836 CmdArgs.push_back(
"-mgpopt");
1838 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1839 options::OPT_mno_local_sdata);
1840 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1841 options::OPT_mno_extern_sdata);
1842 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1843 options::OPT_mno_embedded_data);
1845 CmdArgs.push_back(
"-mllvm");
1846 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1847 CmdArgs.push_back(
"-mlocal-sdata=1");
1849 CmdArgs.push_back(
"-mlocal-sdata=0");
1851 LocalSData->claim();
1855 CmdArgs.push_back(
"-mllvm");
1856 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1857 CmdArgs.push_back(
"-mextern-sdata=1");
1859 CmdArgs.push_back(
"-mextern-sdata=0");
1861 ExternSData->claim();
1865 CmdArgs.push_back(
"-mllvm");
1866 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1867 CmdArgs.push_back(
"-membedded-data=1");
1869 CmdArgs.push_back(
"-membedded-data=0");
1871 EmbeddedData->claim();
1874 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1875 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1880 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1881 StringRef Val = StringRef(A->getValue());
1883 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1884 CmdArgs.push_back(
"-mllvm");
1885 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1887 D.
Diag(diag::err_drv_unsupported_option_argument)
1888 << A->getOption().getName() << Val;
1890 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1893 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1894 options::OPT_mno_relax_pic_calls)) {
1895 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1896 CmdArgs.push_back(
"-mllvm");
1897 CmdArgs.push_back(
"-mips-jalr-reloc=0");
1902 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1903 ArgStringList &CmdArgs)
const {
1905 const char *ABIName =
nullptr;
1906 const llvm::Triple &T = getToolChain().getTriple();
1907 if (T.isOSBinFormatELF()) {
1908 switch (getToolChain().getArch()) {
1909 case llvm::Triple::ppc64: {
1913 bool HasQPX =
false;
1914 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1915 HasQPX = A->getValue() == StringRef(
"a2q");
1916 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1918 ABIName =
"elfv1-qpx";
1922 if (T.isMusl() || (T.isOSFreeBSD() && T.getOSMajorVersion() >= 13))
1928 case llvm::Triple::ppc64le:
1936 bool IEEELongDouble =
false;
1937 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
1938 StringRef
V = A->getValue();
1939 if (V ==
"ieeelongdouble")
1940 IEEELongDouble =
true;
1941 else if (V ==
"ibmlongdouble")
1942 IEEELongDouble =
false;
1943 else if (V !=
"altivec")
1947 ABIName = A->getValue();
1950 CmdArgs.push_back(
"-mabi=ieeelongdouble");
1957 CmdArgs.push_back(
"-msoft-float");
1958 CmdArgs.push_back(
"-mfloat-abi");
1959 CmdArgs.push_back(
"soft");
1963 CmdArgs.push_back(
"-mfloat-abi");
1964 CmdArgs.push_back(
"hard");
1968 CmdArgs.push_back(
"-target-abi");
1969 CmdArgs.push_back(ABIName);
1973 void Clang::AddRISCVTargetArgs(
const ArgList &Args,
1974 ArgStringList &CmdArgs)
const {
1975 const llvm::Triple &Triple = getToolChain().getTriple();
1978 CmdArgs.push_back(
"-target-abi");
1979 CmdArgs.push_back(ABIName.data());
1982 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1983 ArgStringList &CmdArgs)
const {
1989 CmdArgs.push_back(
"-msoft-float");
1990 CmdArgs.push_back(
"-mfloat-abi");
1991 CmdArgs.push_back(
"soft");
1995 CmdArgs.push_back(
"-mfloat-abi");
1996 CmdArgs.push_back(
"hard");
2000 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2001 ArgStringList &CmdArgs)
const {
2002 bool HasBackchain = Args.hasFlag(options::OPT_mbackchain,
2003 options::OPT_mno_backchain,
false);
2004 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2005 options::OPT_mno_packed_stack,
false);
2006 if (HasBackchain && HasPackedStack) {
2007 const Driver &D = getToolChain().getDriver();
2008 D.
Diag(diag::err_drv_unsupported_opt)
2009 << Args.getLastArg(options::OPT_mpacked_stack)->getAsString(Args) +
2010 " " + Args.getLastArg(options::OPT_mbackchain)->getAsString(Args);
2013 CmdArgs.push_back(
"-mbackchain");
2015 CmdArgs.push_back(
"-mpacked-stack");
2019 ArgStringList &CmdArgs) {
2020 if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) {
2021 CmdArgs.push_back(
"-mllvm");
2022 CmdArgs.push_back(
"-x86-branches-within-32B-boundaries");
2024 if (
const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {
2025 StringRef
Value = A->getValue();
2027 if (Value.getAsInteger(10, Boundary) || Boundary < 16 ||
2028 !llvm::isPowerOf2_64(Boundary)) {
2029 D.
Diag(diag::err_drv_invalid_argument_to_option)
2030 << Value << A->getOption().getName();
2032 CmdArgs.push_back(
"-mllvm");
2034 Args.MakeArgString(
"-x86-align-branch-boundary=" + Twine(Boundary)));
2037 if (
const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {
2038 std::string AlignBranch;
2039 for (StringRef T : A->getValues()) {
2040 if (T !=
"fused" && T !=
"jcc" && T !=
"jmp" && T !=
"call" &&
2041 T !=
"ret" && T !=
"indirect")
2042 D.
Diag(diag::err_drv_invalid_malign_branch_EQ)
2043 << T <<
"fused, jcc, jmp, call, ret, indirect";
2044 if (!AlignBranch.empty())
2048 CmdArgs.push_back(
"-mllvm");
2049 CmdArgs.push_back(Args.MakeArgString(
"-x86-align-branch=" + AlignBranch));
2052 Args.getLastArg(options::OPT_malign_branch_prefix_size_EQ)) {
2053 StringRef
Value = A->getValue();
2054 unsigned PrefixSize;
2055 if (Value.getAsInteger(10, PrefixSize) || PrefixSize > 5) {
2056 D.
Diag(diag::err_drv_invalid_argument_to_option)
2057 << Value << A->getOption().getName();
2059 CmdArgs.push_back(
"-mllvm");
2060 CmdArgs.push_back(Args.MakeArgString(
"-x86-align-branch-prefix-size=" +
2061 Twine(PrefixSize)));
2066 void Clang::AddX86TargetArgs(
const ArgList &Args,
2067 ArgStringList &CmdArgs)
const {
2068 const Driver &D = getToolChain().getDriver();
2071 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2072 Args.hasArg(options::OPT_mkernel) ||
2073 Args.hasArg(options::OPT_fapple_kext))
2074 CmdArgs.push_back(
"-disable-red-zone");
2076 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2077 options::OPT_mno_tls_direct_seg_refs,
true))
2078 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2082 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2083 Args.hasArg(options::OPT_fapple_kext));
2084 if (Arg *A = Args.getLastArg(
2085 options::OPT_msoft_float, options::OPT_mno_soft_float,
2086 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2087 const Option &O = A->getOption();
2088 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2089 O.matches(options::OPT_msoft_float));
2091 if (NoImplicitFloat)
2092 CmdArgs.push_back(
"-no-implicit-float");
2094 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2095 StringRef
Value = A->getValue();
2096 if (Value ==
"intel" || Value ==
"att") {
2097 CmdArgs.push_back(
"-mllvm");
2098 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
2100 D.
Diag(diag::err_drv_unsupported_option_argument)
2101 << A->getOption().getName() <<
Value;
2104 CmdArgs.push_back(
"-mllvm");
2105 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2109 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2110 CmdArgs.push_back(
"-mfloat-abi");
2111 CmdArgs.push_back(
"soft");
2112 CmdArgs.push_back(
"-mstack-alignment=4");
2116 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2117 ArgStringList &CmdArgs)
const {
2118 CmdArgs.push_back(
"-mqdsp6-compat");
2119 CmdArgs.push_back(
"-Wreturn-type");
2122 CmdArgs.push_back(
"-mllvm");
2123 CmdArgs.push_back(Args.MakeArgString(
"-hexagon-small-data-threshold=" +
2124 Twine(G.getValue())));
2127 if (!Args.hasArg(options::OPT_fno_short_enums))
2128 CmdArgs.push_back(
"-fshort-enums");
2129 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2130 CmdArgs.push_back(
"-mllvm");
2131 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2133 CmdArgs.push_back(
"-mllvm");
2134 CmdArgs.push_back(
"-machine-sink-split=0");
2137 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2138 ArgStringList &CmdArgs)
const {
2139 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2140 StringRef CPUName = A->getValue();
2142 CmdArgs.push_back(
"-target-cpu");
2143 CmdArgs.push_back(Args.MakeArgString(CPUName));
2145 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2146 StringRef
Value = A->getValue();
2150 if (Value.getAsInteger(10, Mregparm)) {
2151 if (Mregparm != 4) {
2152 getToolChain().getDriver().Diag(
2153 diag::err_drv_unsupported_option_argument)
2154 << A->getOption().getName() <<
Value;
2160 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2161 ArgStringList &CmdArgs)
const {
2163 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2164 options::OPT_fvisibility_ms_compat)) {
2165 CmdArgs.push_back(
"-fvisibility");
2166 CmdArgs.push_back(
"hidden");
2172 const InputInfo &Input,
const ArgList &Args)
const {
2174 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2177 using llvm::yaml::escape;
2178 const Driver &D = getToolChain().getDriver();
2180 if (!CompilationDatabase) {
2182 auto File = std::make_unique<llvm::raw_fd_ostream>(
Filename, EC,
2183 llvm::sys::fs::OF_Text);
2185 D.
Diag(clang::diag::err_drv_compilationdatabase) << Filename
2189 CompilationDatabase = std::move(File);
2191 auto &CDB = *CompilationDatabase;
2192 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2195 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2196 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2197 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2202 CDB <<
", \"" << escape(Buf) <<
"\"";
2203 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2206 CDB <<
", \"" << escape(Buf) <<
"\"";
2208 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2209 for (
auto &A: Args) {
2210 auto &O = A->getOption();
2212 if (O.getID() == options::OPT_x)
2215 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2217 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2220 if (O.getKind() == Option::InputClass)
2224 A->render(Args, ASL);
2226 CDB <<
", \"" << escape(it) <<
"\"";
2230 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2233 void Clang::DumpCompilationDatabaseFragmentToDir(
2235 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2237 if (C.
getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2240 if (CompilationDatabase)
2241 DumpCompilationDatabase(C,
"", Target, Output, Input, Args);
2246 auto Err = llvm::sys::fs::create_directory(Path,
true);
2248 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2252 llvm::sys::path::append(
2254 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2257 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath);
2259 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2262 CompilationDatabase =
2263 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2264 DumpCompilationDatabase(C,
"", Target, Output, Input, Args);
2268 const ArgList &Args,
2269 ArgStringList &CmdArgs,
2272 CmdArgs.push_back(
"-mrelax-all");
2276 bool DefaultIncrementalLinkerCompatible =
2278 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2279 options::OPT_mno_incremental_linker_compatible,
2280 DefaultIncrementalLinkerCompatible))
2281 CmdArgs.push_back(
"-mincremental-linker-compatible");
2284 case llvm::Triple::arm:
2285 case llvm::Triple::armeb:
2286 case llvm::Triple::thumb:
2287 case llvm::Triple::thumbeb:
2288 if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) {
2289 StringRef
Value = A->getValue();
2290 if (Value ==
"always" || Value ==
"never" || Value ==
"arm" ||
2292 CmdArgs.push_back(
"-mllvm");
2293 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" + Value));
2295 D.
Diag(diag::err_drv_unsupported_option_argument)
2296 << A->getOption().getName() <<
Value;
2312 bool TakeNextArg =
false;
2316 const char *MipsTargetFeature =
nullptr;
2318 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2321 for (StringRef
Value : A->getValues()) {
2323 CmdArgs.push_back(
Value.data());
2324 TakeNextArg =
false;
2329 Value ==
"-mbig-obj")
2335 case llvm::Triple::thumb:
2336 case llvm::Triple::thumbeb:
2337 case llvm::Triple::arm:
2338 case llvm::Triple::armeb:
2339 if (
Value ==
"-mthumb")
2344 case llvm::Triple::mips:
2345 case llvm::Triple::mipsel:
2346 case llvm::Triple::mips64:
2347 case llvm::Triple::mips64el:
2348 if (
Value ==
"--trap") {
2349 CmdArgs.push_back(
"-target-feature");
2350 CmdArgs.push_back(
"+use-tcc-in-div");
2353 if (
Value ==
"--break") {
2354 CmdArgs.push_back(
"-target-feature");
2355 CmdArgs.push_back(
"-use-tcc-in-div");
2358 if (
Value.startswith(
"-msoft-float")) {
2359 CmdArgs.push_back(
"-target-feature");
2360 CmdArgs.push_back(
"+soft-float");
2363 if (
Value.startswith(
"-mhard-float")) {
2364 CmdArgs.push_back(
"-target-feature");
2365 CmdArgs.push_back(
"-soft-float");
2369 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2370 .Case(
"-mips1",
"+mips1")
2371 .Case(
"-mips2",
"+mips2")
2372 .Case(
"-mips3",
"+mips3")
2373 .Case(
"-mips4",
"+mips4")
2374 .Case(
"-mips5",
"+mips5")
2375 .Case(
"-mips32",
"+mips32")
2376 .Case(
"-mips32r2",
"+mips32r2")
2377 .Case(
"-mips32r3",
"+mips32r3")
2378 .Case(
"-mips32r5",
"+mips32r5")
2379 .Case(
"-mips32r6",
"+mips32r6")
2380 .Case(
"-mips64",
"+mips64")
2381 .Case(
"-mips64r2",
"+mips64r2")
2382 .Case(
"-mips64r3",
"+mips64r3")
2383 .Case(
"-mips64r5",
"+mips64r5")
2384 .Case(
"-mips64r6",
"+mips64r6")
2386 if (MipsTargetFeature)
2390 if (
Value ==
"-force_cpusubtype_ALL") {
2392 }
else if (
Value ==
"-L") {
2393 CmdArgs.push_back(
"-msave-temp-labels");
2394 }
else if (
Value ==
"--fatal-warnings") {
2395 CmdArgs.push_back(
"-massembler-fatal-warnings");
2396 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2397 CmdArgs.push_back(
"-massembler-no-warn");
2398 }
else if (
Value ==
"--noexecstack") {
2399 UseNoExecStack =
true;
2400 }
else if (
Value.startswith(
"-compress-debug-sections") ||
2401 Value.startswith(
"--compress-debug-sections") ||
2402 Value ==
"-nocompress-debug-sections" ||
2403 Value ==
"--nocompress-debug-sections") {
2404 CmdArgs.push_back(
Value.data());
2405 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2406 Value ==
"--mrelax-relocations=yes") {
2407 UseRelaxRelocations =
true;
2408 }
else if (
Value ==
"-mrelax-relocations=no" ||
2409 Value ==
"--mrelax-relocations=no") {
2410 UseRelaxRelocations =
false;
2411 }
else if (
Value.startswith(
"-I")) {
2412 CmdArgs.push_back(
Value.data());
2417 }
else if (
Value.startswith(
"-gdwarf-")) {
2420 if (DwarfVersion == 0) {
2421 CmdArgs.push_back(
Value.data());
2425 DwarfVersion, llvm::DebuggerKind::Default);
2427 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2428 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2430 }
else if (
Value ==
"-defsym") {
2431 if (A->getNumValues() != 2) {
2432 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2435 const char *S = A->getValue(1);
2436 auto Pair = StringRef(S).split(
'=');
2437 auto Sym = Pair.first;
2438 auto SVal = Pair.second;
2440 if (Sym.empty() || SVal.empty()) {
2441 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2445 if (SVal.getAsInteger(0, IVal)) {
2446 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2449 CmdArgs.push_back(
Value.data());
2451 }
else if (
Value ==
"-fdebug-compilation-dir") {
2452 CmdArgs.push_back(
"-fdebug-compilation-dir");
2454 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2458 CmdArgs.push_back(
"-fdebug-compilation-dir");
2459 CmdArgs.push_back(
Value.data());
2461 D.
Diag(diag::err_drv_unsupported_option_argument)
2462 << A->getOption().getName() <<
Value;
2466 if (UseRelaxRelocations)
2467 CmdArgs.push_back(
"--mrelax-relocations");
2469 CmdArgs.push_back(
"-mnoexecstack");
2470 if (MipsTargetFeature !=
nullptr) {
2471 CmdArgs.push_back(
"-target-feature");
2472 CmdArgs.push_back(MipsTargetFeature);
2478 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2482 bool OFastEnabled,
const ArgList &Args,
2483 ArgStringList &CmdArgs) {
2489 bool HonorINFs =
true;
2490 bool HonorNaNs =
true;
2493 bool AssociativeMath =
false;
2494 bool ReciprocalMath =
false;
2495 bool SignedZeros =
true;
2496 bool TrappingMath =
false;
2497 bool TrappingMathPresent =
false;
2499 bool RoundingFPMath =
false;
2500 bool RoundingMathPresent =
false;
2502 StringRef FPModel =
"";
2504 StringRef FPExceptionBehavior =
"";
2505 StringRef DenormalFPMath =
"";
2506 StringRef FPContract =
"";
2507 bool StrictFPModel =
false;
2509 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2510 CmdArgs.push_back(
"-mlimit-float-precision");
2511 CmdArgs.push_back(A->getValue());
2514 for (
const Arg *A : Args) {
2515 auto optID = A->getOption().getID();
2516 bool PreciseFPModel =
false;
2520 case options::OPT_ffp_model_EQ: {
2526 AssociativeMath =
false;
2527 ReciprocalMath =
false;
2530 DenormalFPMath =
"";
2532 StringRef Val = A->getValue();
2533 if (OFastEnabled && !Val.equals(
"fast")) {
2535 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2536 << Args.MakeArgString(
"-ffp-model=" + Val)
2540 StrictFPModel =
false;
2541 PreciseFPModel =
true;
2545 if (!FPModel.empty() && !FPModel.equals(Val)) {
2546 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2547 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2548 << Args.MakeArgString(
"-ffp-model=" + Val);
2551 if (Val.equals(
"fast")) {
2552 optID = options::OPT_ffast_math;
2554 FPContract =
"fast";
2555 }
else if (Val.equals(
"precise")) {
2556 optID = options::OPT_ffp_contract;
2558 FPContract =
"fast";
2559 PreciseFPModel =
true;
2560 }
else if (Val.equals(
"strict")) {
2561 StrictFPModel =
true;
2562 optID = options::OPT_frounding_math;
2563 FPExceptionBehavior =
"strict";
2565 TrappingMath =
true;
2567 D.
Diag(diag::err_drv_unsupported_option_argument)
2568 << A->getOption().getName() << Val;
2578 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2579 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2580 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2581 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2582 case options::OPT_fmath_errno: MathErrno =
true;
break;
2583 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2584 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2585 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2586 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2587 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2588 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2589 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2590 case options::OPT_ftrapping_math:
2591 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2592 !FPExceptionBehavior.equals(
"strict"))
2594 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2595 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2596 <<
"-ftrapping-math";
2597 TrappingMath =
true;
2598 TrappingMathPresent =
true;
2599 FPExceptionBehavior =
"strict";
2601 case options::OPT_fno_trapping_math:
2602 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2603 !FPExceptionBehavior.equals(
"ignore"))
2605 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2606 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2607 <<
"-fno-trapping-math";
2608 TrappingMath =
false;
2609 TrappingMathPresent =
true;
2610 FPExceptionBehavior =
"ignore";
2613 case options::OPT_frounding_math:
2614 RoundingFPMath =
true;
2615 RoundingMathPresent =
true;
2618 case options::OPT_fno_rounding_math:
2619 RoundingFPMath =
false;
2620 RoundingMathPresent =
false;
2623 case options::OPT_fdenormal_fp_math_EQ:
2624 DenormalFPMath = A->getValue();
2628 case options::OPT_ffp_contract: {
2629 StringRef Val = A->getValue();
2630 if (PreciseFPModel) {
2635 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off"))
2638 D.
Diag(diag::err_drv_unsupported_option_argument)
2639 << A->getOption().getName() << Val;
2644 case options::OPT_ffp_model_EQ:
2651 case options::OPT_ffp_exception_behavior_EQ: {
2652 StringRef Val = A->getValue();
2653 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2654 !FPExceptionBehavior.equals(Val))
2656 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2657 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2658 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
2659 TrappingMath = TrappingMathPresent =
false;
2660 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
2661 FPExceptionBehavior = Val;
2662 else if (Val.equals(
"strict")) {
2663 FPExceptionBehavior = Val;
2664 TrappingMath = TrappingMathPresent =
true;
2666 D.
Diag(diag::err_drv_unsupported_option_argument)
2667 << A->getOption().getName() << Val;
2671 case options::OPT_ffinite_math_only:
2675 case options::OPT_fno_finite_math_only:
2680 case options::OPT_funsafe_math_optimizations:
2681 AssociativeMath =
true;
2682 ReciprocalMath =
true;
2683 SignedZeros =
false;
2684 TrappingMath =
false;
2685 FPExceptionBehavior =
"";
2687 case options::OPT_fno_unsafe_math_optimizations:
2688 AssociativeMath =
false;
2689 ReciprocalMath =
false;
2691 TrappingMath =
true;
2692 FPExceptionBehavior =
"strict";
2694 DenormalFPMath =
"";
2697 case options::OPT_Ofast:
2702 case options::OPT_ffast_math:
2706 AssociativeMath =
true;
2707 ReciprocalMath =
true;
2708 SignedZeros =
false;
2709 TrappingMath =
false;
2710 RoundingFPMath =
false;
2712 FPContract =
"fast";
2714 case options::OPT_fno_fast_math:
2721 AssociativeMath =
false;
2722 ReciprocalMath =
false;
2724 TrappingMath =
false;
2725 RoundingFPMath =
false;
2727 DenormalFPMath =
"";
2731 if (StrictFPModel) {
2734 if (HonorINFs && HonorNaNs &&
2735 !AssociativeMath && !ReciprocalMath &&
2736 SignedZeros && TrappingMath && RoundingFPMath &&
2737 DenormalFPMath.empty() && FPContract.empty())
2741 StrictFPModel =
false;
2743 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2744 <<
"-ffp-model=strict" <<
2745 ((A->getNumValues() == 0) ? A->getSpelling()
2746 : Args.MakeArgString(A->getSpelling() + A->getValue()));
2755 CmdArgs.push_back(
"-menable-no-infs");
2758 CmdArgs.push_back(
"-menable-no-nans");
2761 CmdArgs.push_back(
"-fmath-errno");
2763 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2765 CmdArgs.push_back(
"-menable-unsafe-fp-math");
2768 CmdArgs.push_back(
"-fno-signed-zeros");
2770 if (AssociativeMath && !SignedZeros && !TrappingMath)
2771 CmdArgs.push_back(
"-mreassociate");
2774 CmdArgs.push_back(
"-freciprocal-math");
2778 assert(FPExceptionBehavior.equals(
"strict"));
2779 CmdArgs.push_back(
"-ftrapping-math");
2780 }
else if (TrappingMathPresent)
2781 CmdArgs.push_back(
"-fno-trapping-math");
2783 if (!DenormalFPMath.empty())
2785 Args.MakeArgString(
"-fdenormal-fp-math=" + DenormalFPMath));
2787 if (!FPContract.empty())
2788 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
2790 if (!RoundingFPMath)
2791 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
2793 if (RoundingFPMath && RoundingMathPresent)
2794 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
2796 if (!FPExceptionBehavior.empty())
2797 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
2798 FPExceptionBehavior));
2805 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
2806 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
2807 CmdArgs.push_back(
"-ffast-math");
2808 if (FPModel.equals(
"fast")) {
2809 if (FPContract.equals(
"fast"))
2812 else if (FPContract.empty())
2814 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
2816 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2817 <<
"-ffp-model=fast" 2818 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
2823 if (!HonorINFs && !HonorNaNs)
2824 CmdArgs.push_back(
"-ffinite-math-only");
2826 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2827 CmdArgs.push_back(
"-mfpmath");
2828 CmdArgs.push_back(A->getValue());
2832 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
2833 options::OPT_fstrict_float_cast_overflow,
false))
2834 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
2838 const llvm::Triple &Triple,
2841 CmdArgs.push_back(
"-analyzer-store=region");
2844 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
2847 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2848 CmdArgs.push_back(
"-analyzer-checker=core");
2849 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
2851 if (!Triple.isWindowsMSVCEnvironment()) {
2852 CmdArgs.push_back(
"-analyzer-checker=unix");
2855 CmdArgs.push_back(
"-analyzer-checker=unix.API");
2856 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
2857 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
2858 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
2859 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
2860 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
2864 if (Triple.isPS4CPU()) {
2865 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
2866 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
2869 if (Triple.isOSDarwin()) {
2870 CmdArgs.push_back(
"-analyzer-checker=osx");
2872 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
2874 else if (Triple.isOSFuchsia())
2875 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
2877 CmdArgs.push_back(
"-analyzer-checker=deadcode");
2880 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
2882 if (!Triple.isPS4CPU()) {
2883 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
2884 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
2885 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
2886 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
2887 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
2888 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
2892 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
2893 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
2897 CmdArgs.push_back(
"-analyzer-output");
2898 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2899 CmdArgs.push_back(A->getValue());
2901 CmdArgs.push_back(
"plist");
2906 CmdArgs.push_back(
"-w");
2909 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2913 ArgStringList &CmdArgs,
bool KernelOrKext) {
2918 if (EffectiveTriple.isNVPTX())
2922 unsigned StackProtectorLevel = 0;
2923 unsigned DefaultStackProtectorLevel =
2926 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2927 options::OPT_fstack_protector_all,
2928 options::OPT_fstack_protector_strong,
2929 options::OPT_fstack_protector)) {
2930 if (A->getOption().matches(options::OPT_fstack_protector))
2931 StackProtectorLevel =
2933 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
2935 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2938 StackProtectorLevel = DefaultStackProtectorLevel;
2941 if (StackProtectorLevel) {
2942 CmdArgs.push_back(
"-stack-protector");
2943 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2947 for (
const Arg *A : Args.filtered(options::OPT__param)) {
2948 StringRef Str(A->getValue());
2949 if (Str.startswith(
"ssp-buffer-size=")) {
2950 if (StackProtectorLevel) {
2951 CmdArgs.push_back(
"-stack-protector-buffer-size");
2953 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
2962 const ArgList &Args,
2963 ArgStringList &CmdArgs) {
2965 StringRef TrivialAutoVarInit =
"";
2967 for (
const Arg *A : Args) {
2968 switch (A->getOption().getID()) {
2971 case options::OPT_ftrivial_auto_var_init: {
2973 StringRef Val = A->getValue();
2974 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
2975 TrivialAutoVarInit = Val;
2977 D.
Diag(diag::err_drv_unsupported_option_argument)
2978 << A->getOption().getName() << Val;
2984 if (TrivialAutoVarInit.empty())
2985 switch (DefaultTrivialAutoVarInit) {
2989 TrivialAutoVarInit =
"pattern";
2992 TrivialAutoVarInit =
"zero";
2996 if (!TrivialAutoVarInit.empty()) {
2997 if (TrivialAutoVarInit ==
"zero" && !Args.hasArg(options::OPT_enable_trivial_var_init_zero))
2998 D.
Diag(diag::err_drv_trivial_auto_var_init_zero_disabled);
3000 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3005 const unsigned ForwardedArguments[] = {
3006 options::OPT_cl_opt_disable,
3007 options::OPT_cl_strict_aliasing,
3008 options::OPT_cl_single_precision_constant,
3009 options::OPT_cl_finite_math_only,
3010 options::OPT_cl_kernel_arg_info,
3011 options::OPT_cl_unsafe_math_optimizations,
3012 options::OPT_cl_fast_relaxed_math,
3013 options::OPT_cl_mad_enable,
3014 options::OPT_cl_no_signed_zeros,
3015 options::OPT_cl_denorms_are_zero,
3016 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3017 options::OPT_cl_uniform_work_group_size
3020 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3021 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3022 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3025 for (
const auto &Arg : ForwardedArguments)
3026 if (
const auto *A = Args.getLastArg(Arg))
3027 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3031 ArgStringList &CmdArgs) {
3032 bool ARCMTEnabled =
false;
3033 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3034 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3035 options::OPT_ccc_arcmt_modify,
3036 options::OPT_ccc_arcmt_migrate)) {
3037 ARCMTEnabled =
true;
3038 switch (A->getOption().getID()) {
3039 default: llvm_unreachable(
"missed a case");
3040 case options::OPT_ccc_arcmt_check:
3041 CmdArgs.push_back(
"-arcmt-check");
3043 case options::OPT_ccc_arcmt_modify:
3044 CmdArgs.push_back(
"-arcmt-modify");
3046 case options::OPT_ccc_arcmt_migrate:
3047 CmdArgs.push_back(
"-arcmt-migrate");
3048 CmdArgs.push_back(
"-mt-migrate-directory");
3049 CmdArgs.push_back(A->getValue());
3051 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3052 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3057 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3058 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3059 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3062 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3064 D.
Diag(diag::err_drv_argument_not_allowed_with)
3065 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3067 CmdArgs.push_back(
"-mt-migrate-directory");
3068 CmdArgs.push_back(A->getValue());
3070 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3071 options::OPT_objcmt_migrate_subscripting,
3072 options::OPT_objcmt_migrate_property)) {
3074 CmdArgs.push_back(
"-objcmt-migrate-literals");
3075 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3076 CmdArgs.push_back(
"-objcmt-migrate-property");
3078 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3079 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3080 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3083 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3084 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3085 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3086 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3087 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3088 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3089 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3090 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3091 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3092 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3093 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3094 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3095 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3096 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3097 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3098 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
3103 const ArgList &Args, ArgStringList &CmdArgs) {
3106 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3107 !Args.hasArg(options::OPT_mkernel));
3109 CmdArgs.push_back(
"-fno-builtin");
3112 if (Args.hasArg(options::OPT_ffreestanding))
3113 UseBuiltins =
false;
3116 for (
const auto &Arg : Args) {
3117 const Option &O = Arg->getOption();
3118 if (!O.matches(options::OPT_fno_builtin_))
3128 StringRef FuncName = Arg->getValue();
3129 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
3135 if (TC.
getArch() == llvm::Triple::le32)
3136 CmdArgs.push_back(
"-fno-math-builtin");
3140 llvm::sys::path::system_temp_directory(
false, Result);
3141 llvm::sys::path::append(Result,
"org.llvm.clang.");
3143 llvm::sys::path::append(Result,
"ModuleCache");
3147 const ArgList &Args,
const InputInfo &Input,
3149 ArgStringList &CmdArgs,
bool &HaveModules) {
3153 bool HaveClangModules =
false;
3154 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3155 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3156 options::OPT_fno_cxx_modules,
true);
3158 CmdArgs.push_back(
"-fmodules");
3159 HaveClangModules =
true;
3163 HaveModules |= HaveClangModules;
3164 if (Args.hasArg(options::OPT_fmodules_ts)) {
3165 CmdArgs.push_back(
"-fmodules-ts");
3171 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3172 options::OPT_fno_implicit_module_maps, HaveClangModules))
3173 CmdArgs.push_back(
"-fimplicit-module-maps");
3176 if (Args.hasFlag(options::OPT_fmodules_decluse,
3177 options::OPT_fno_modules_decluse,
false))
3178 CmdArgs.push_back(
"-fmodules-decluse");
3182 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3183 options::OPT_fno_modules_strict_decluse,
false))
3184 CmdArgs.push_back(
"-fmodules-strict-decluse");
3187 bool ImplicitModules =
false;
3188 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3189 options::OPT_fno_implicit_modules, HaveClangModules)) {
3191 CmdArgs.push_back(
"-fno-implicit-modules");
3192 }
else if (HaveModules) {
3193 ImplicitModules =
true;
3197 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3198 Path = A->getValue();
3204 llvm::sys::path::replace_extension(Path,
".cache");
3205 llvm::sys::path::append(Path,
"modules");
3206 }
else if (Path.empty()) {
3211 const char Arg[] =
"-fmodules-cache-path=";
3212 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3213 CmdArgs.push_back(Args.MakeArgString(Path));
3218 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3219 CmdArgs.push_back(Args.MakeArgString(
3220 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3223 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3224 options::OPT_fno_modules_validate_input_files_content,
3226 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3231 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3235 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3239 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3241 llvm::sys::path::append(BuiltinModuleMap,
"include");
3242 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3243 if (llvm::sys::fs::exists(BuiltinModuleMap))
3245 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3253 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3255 Args.ClaimAllArgs(options::OPT_fmodule_file);
3261 llvm::sys::path::replace_extension(VFSDir,
".cache");
3265 llvm::sys::path::append(VFSDir,
"vfs");
3266 CmdArgs.push_back(
"-module-dependency-dir");
3267 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3270 if (HaveClangModules)
3271 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3274 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3275 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3276 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3278 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3280 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3281 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3282 D.
Diag(diag::err_drv_argument_not_allowed_with)
3283 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3285 llvm::sys::fs::file_status Status;
3286 if (llvm::sys::fs::status(A->getValue(), Status))
3287 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3289 Args.MakeArgString(
"-fbuild-session-timestamp=" +
3290 Twine((uint64_t)Status.getLastModificationTime()
3295 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3296 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3297 options::OPT_fbuild_session_file))
3298 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3300 Args.AddLastArg(CmdArgs,
3301 options::OPT_fmodules_validate_once_per_build_session);
3304 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
3305 options::OPT_fno_modules_validate_system_headers,
3307 CmdArgs.push_back(
"-fmodules-validate-system-headers");
3309 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
3313 ArgStringList &CmdArgs) {
3315 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
3316 options::OPT_fno_signed_char,
3317 options::OPT_funsigned_char,
3318 options::OPT_fno_unsigned_char)) {
3319 if (A->getOption().matches(options::OPT_funsigned_char) ||
3320 A->getOption().matches(options::OPT_fno_signed_char)) {
3321 CmdArgs.push_back(
"-fno-signed-char");
3324 CmdArgs.push_back(
"-fno-signed-char");
3328 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
3330 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3331 options::OPT_fno_short_wchar)) {
3332 if (A->getOption().matches(options::OPT_fshort_wchar)) {
3333 CmdArgs.push_back(
"-fwchar-type=short");
3334 CmdArgs.push_back(
"-fno-signed-wchar");
3336 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
3337 CmdArgs.push_back(
"-fwchar-type=int");
3338 if (IsARM && !(T.isOSWindows() || T.isOSNetBSD() ||
3340 CmdArgs.push_back(
"-fno-signed-wchar");
3342 CmdArgs.push_back(
"-fsigned-wchar");
3348 const llvm::Triple &T,
const ArgList &Args,
3350 const InputInfo &Input, ArgStringList &CmdArgs) {
3351 const llvm::Triple::ArchType Arch = TC.
getArch();
3357 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3358 options::OPT_fno_objc_legacy_dispatch,
3361 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
3363 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
3369 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
3371 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
3378 CmdArgs.push_back(
"-fobjc-arc");
3385 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
3387 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
3392 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3393 options::OPT_fno_objc_arc_exceptions,
3395 CmdArgs.push_back(
"-fobjc-arc-exceptions");
3400 if (Args.hasArg(options::OPT_fno_objc_arc)) {
3401 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
3402 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
3408 auto *Arg = Args.getLastArg(
3409 options::OPT_fobjc_convert_messages_to_runtime_calls,
3410 options::OPT_fno_objc_convert_messages_to_runtime_calls);
3412 Arg->getOption().matches(
3413 options::OPT_fno_objc_convert_messages_to_runtime_calls))
3414 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
3419 if (InferCovariantReturns)
3420 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
3425 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
3429 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
3430 D.
Diag(diag::err_objc_weak_unsupported);
3432 WeakArg->render(Args, CmdArgs);
3438 ArgStringList &CmdArgs) {
3439 bool CaretDefault =
true;
3440 bool ColumnDefault =
true;
3442 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
3443 options::OPT__SLASH_diagnostics_column,
3444 options::OPT__SLASH_diagnostics_caret)) {
3445 switch (A->getOption().getID()) {
3446 case options::OPT__SLASH_diagnostics_caret:
3447 CaretDefault =
true;
3448 ColumnDefault =
true;
3450 case options::OPT__SLASH_diagnostics_column:
3451 CaretDefault =
false;
3452 ColumnDefault =
true;
3454 case options::OPT__SLASH_diagnostics_classic:
3455 CaretDefault =
false;
3456 ColumnDefault =
false;
3462 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3463 options::OPT_fno_caret_diagnostics, CaretDefault))
3464 CmdArgs.push_back(
"-fno-caret-diagnostics");
3467 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3468 options::OPT_fno_diagnostics_fixit_info))
3469 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
3472 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3473 options::OPT_fno_diagnostics_show_option))
3474 CmdArgs.push_back(
"-fdiagnostics-show-option");
3477 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3478 CmdArgs.push_back(
"-fdiagnostics-show-category");
3479 CmdArgs.push_back(A->getValue());
3482 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
3483 options::OPT_fno_diagnostics_show_hotness,
false))
3484 CmdArgs.push_back(
"-fdiagnostics-show-hotness");
3487 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
3489 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
3490 CmdArgs.push_back(Args.MakeArgString(Opt));
3493 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3494 CmdArgs.push_back(
"-fdiagnostics-format");
3495 CmdArgs.push_back(A->getValue());
3498 if (
const Arg *A = Args.getLastArg(
3499 options::OPT_fdiagnostics_show_note_include_stack,
3500 options::OPT_fno_diagnostics_show_note_include_stack)) {
3501 const Option &O = A->getOption();
3502 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
3503 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
3505 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
3512 for (
const Arg *A : Args) {
3513 const Option &O = A->getOption();
3514 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3515 !O.matches(options::OPT_fdiagnostics_color) &&
3516 !O.matches(options::OPT_fno_color_diagnostics) &&
3517 !O.matches(options::OPT_fno_diagnostics_color) &&
3518 !O.matches(options::OPT_fdiagnostics_color_EQ))
3521 if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
3522 StringRef
Value(A->getValue());
3524 D.
Diag(diag::err_drv_clang_unsupported)
3525 << (
"-fdiagnostics-color=" +
Value).str();
3531 CmdArgs.push_back(
"-fcolor-diagnostics");
3533 if (Args.hasArg(options::OPT_fansi_escape_codes))
3534 CmdArgs.push_back(
"-fansi-escape-codes");
3536 if (!Args.hasFlag(options::OPT_fshow_source_location,
3537 options::OPT_fno_show_source_location))
3538 CmdArgs.push_back(
"-fno-show-source-location");
3540 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
3541 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
3543 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
3545 CmdArgs.push_back(
"-fno-show-column");
3547 if (!Args.hasFlag(options::OPT_fspell_checking,
3548 options::OPT_fno_spell_checking))
3549 CmdArgs.push_back(
"-fno-spell-checking");
3555 const ArgList &Args, Arg *&Arg) {
3557 Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ);
3561 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
3564 StringRef
Value = Arg->getValue();
3565 if (Value ==
"split")
3567 if (Value ==
"single")
3570 D.
Diag(diag::err_drv_unsupported_option_argument)
3571 << Arg->getOption().getName() << Arg->getValue();
3576 const llvm::Triple &T,
const ArgList &Args,
3577 bool EmitCodeView,
bool IsWindowsMSVC,
3578 ArgStringList &CmdArgs,
3581 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
3582 options::OPT_fno_debug_info_for_profiling,
false) &&
3584 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
3585 CmdArgs.push_back(
"-fdebug-info-for-profiling");
3598 bool SplitDWARFInlining =
3599 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
3600 options::OPT_fno_split_dwarf_inlining,
false);
3602 Args.ClaimAllArgs(options::OPT_g_Group);
3610 SplitDWARFInlining =
false;
3614 Args.getLastArg(options::OPT_g_Group, options::OPT_gsplit_dwarf,
3615 options::OPT_gsplit_dwarf_EQ)) {
3620 A->getOption().matches(options::OPT_gN_Group)) {
3629 SplitDWARFInlining))
3636 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
3638 if (A->getOption().matches(options::OPT_glldb))
3639 DebuggerTuning = llvm::DebuggerKind::LLDB;
3640 else if (A->getOption().matches(options::OPT_gsce))
3641 DebuggerTuning = llvm::DebuggerKind::SCE;
3643 DebuggerTuning = llvm::DebuggerKind::GDB;
3648 const Arg *GDwarfN = Args.getLastArg(
3649 options::OPT_gdwarf_2, options::OPT_gdwarf_3, options::OPT_gdwarf_4,
3650 options::OPT_gdwarf_5, options::OPT_gdwarf);
3651 bool EmitDwarf =
false;
3659 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview)) {
3661 EmitCodeView =
true;
3666 if (!EmitCodeView && !EmitDwarf &&
3670 EmitCodeView =
true;
3678 unsigned DWARFVersion = 0;
3683 assert(DWARFVersion &&
"toolchain default DWARF version must be nonzero");
3687 if (DefaultDWARFVersion)
3688 DWARFVersion = DefaultDWARFVersion;
3693 DWARFVersion = ExplicitVersion;
3702 Args.ClaimAllArgs(options::OPT_g_flags_Group);
3709 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
3711 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3713 DebuggerTuning != llvm::DebuggerKind::SCE))
3714 CmdArgs.push_back(
"-dwarf-column-info");
3718 if (
const Arg *A = Args.getLastArg(options::OPT_gmodules))
3723 CmdArgs.push_back(
"-dwarf-ext-refs");
3724 CmdArgs.push_back(
"-fmodule-format=obj");
3728 if (T.isOSBinFormatELF() && !SplitDWARFInlining)
3729 CmdArgs.push_back(
"-fno-split-dwarf-inlining");
3736 bool NeedFullDebug = Args.hasFlag(
3737 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
3738 DebuggerTuning == llvm::DebuggerKind::LLDB ||
3740 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
3745 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
3751 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
3752 if (DWARFVersion < 5)
3753 D.Diag(diag::err_drv_argument_only_allowed_with)
3754 << A->getAsString(Args) <<
"-gdwarf-5";
3756 CmdArgs.push_back(
"-gembed-source");
3760 CmdArgs.push_back(
"-gcodeview");
3763 if (Args.hasFlag(options::OPT_gcodeview_ghash,
3764 options::OPT_gno_codeview_ghash,
false)) {
3765 CmdArgs.push_back(
"-gcodeview-ghash");
3770 if (Args.hasFlag(options::OPT_gno_inline_line_tables,
3771 options::OPT_ginline_line_tables,
false)) {
3772 CmdArgs.push_back(
"-gno-inline-line-tables");
3787 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
3791 CmdArgs.push_back(
"-debug-info-macro");
3794 const auto *PubnamesArg =
3795 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
3796 options::OPT_gpubnames, options::OPT_gno_pubnames);
3800 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
3801 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
3802 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
3803 options::OPT_gpubnames)
3805 :
"-ggnu-pubnames");
3807 if (Args.hasFlag(options::OPT_fdebug_ranges_base_address,
3808 options::OPT_fno_debug_ranges_base_address,
false)) {
3809 CmdArgs.push_back(
"-fdebug-ranges-base-address");
3815 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
3816 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
3819 CmdArgs.push_back(
"-mllvm");
3820 CmdArgs.push_back(
"-generate-arange-section");
3823 if (Args.hasFlag(options::OPT_fforce_dwarf_frame,
3824 options::OPT_fno_force_dwarf_frame,
false))
3825 CmdArgs.push_back(
"-fforce-dwarf-frame");
3827 if (Args.hasFlag(options::OPT_fdebug_types_section,
3828 options::OPT_fno_debug_types_section,
false)) {
3829 if (!T.isOSBinFormatELF()) {
3830 D.Diag(diag::err_drv_unsupported_opt_for_target)
3831 << Args.getLastArg(options::OPT_fdebug_types_section)
3835 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
3837 CmdArgs.push_back(
"-mllvm");
3838 CmdArgs.push_back(
"-generate-type-units");
3844 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3845 CmdArgs.push_back(
"-debug-forward-template-params");
3849 if (DebuggerTuning == llvm::DebuggerKind::SCE)
3850 CmdArgs.push_back(
"-dwarf-explicit-import");
3857 const ArgList &Args,
const char *LinkingOutput)
const {
3858 const auto &TC = getToolChain();
3859 const llvm::Triple &RawTriple = TC.getTriple();
3860 const llvm::Triple &Triple = TC.getEffectiveTriple();
3861 const std::string &TripleStr = Triple.getTriple();
3864 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3865 const Driver &D = TC.getDriver();
3866 ArgStringList CmdArgs;
3869 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
3878 bool IsHeaderModulePrecompile = isa<HeaderModulePrecompileJobAction>(JA);
3882 const char *ModuleName = [&]{
3883 auto *ModuleNameArg = Args.getLastArg(options::OPT_fmodule_name_EQ);
3884 return ModuleNameArg ? ModuleNameArg->getValue() :
"";
3886 InputInfo HeaderModuleInput(Inputs[0].getType(), ModuleName, ModuleName);
3889 IsHeaderModulePrecompile ? HeaderModuleInput : Inputs[0];
3892 const InputInfo *CudaDeviceInput =
nullptr;
3893 const InputInfo *OpenMPDeviceInput =
nullptr;
3897 }
else if (IsHeaderModulePrecompile &&
3901 D.
Diag(diag::err_drv_module_header_wrong_kind)
3905 ModuleHeaderInputs.push_back(I);
3906 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
3907 CudaDeviceInput = &I;
3908 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
3909 OpenMPDeviceInput = &I;
3911 llvm_unreachable(
"unexpectedly given multiple inputs");
3915 const llvm::Triple *AuxTriple = IsCuda ? TC.getAuxTriple() :
nullptr;
3916 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
3917 bool IsIAMCU = RawTriple.isOSIAMCU();
3922 if (IsCuda || IsHIP)
3923 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
3927 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
3932 CmdArgs.push_back(
"-cc1");
3935 CmdArgs.push_back(
"-triple");
3936 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3938 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
3939 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
3940 Args.ClaimAllArgs(options::OPT_MJ);
3941 }
else if (
const Arg *GenCDBFragment =
3942 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
3943 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(), C,
3944 TripleStr, Output, Input, Args);
3945 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
3948 if (IsCuda || IsHIP) {
3951 std::string NormalizedTriple;
3969 assert(CTC &&
"Expected valid CUDA Toolchain.");
3971 CmdArgs.push_back(Args.MakeArgString(
3972 Twine(
"-target-sdk-version=") +
3976 CmdArgs.push_back(
"-aux-triple");
3977 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3980 if (IsOpenMPDevice) {
3982 std::string NormalizedTriple =
3986 CmdArgs.push_back(
"-aux-triple");
3987 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3990 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3991 Triple.getArch() == llvm::Triple::thumb)) {
3992 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
3994 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
3996 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4003 TC.addClangWarningOptions(CmdArgs);
4006 RewriteKind rewriteKind = RK_None;
4015 if (!isa<AssembleJobAction>(JA)) {
4018 if (TC.useIntegratedAs()) {
4019 Args.ClaimAllArgs(options::OPT_mrelax_all);
4020 Args.ClaimAllArgs(options::OPT_mno_relax_all);
4021 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4022 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4024 case llvm::Triple::arm:
4025 case llvm::Triple::armeb:
4026 case llvm::Triple::thumb:
4027 case llvm::Triple::thumbeb:
4028 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4034 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4035 Args.ClaimAllArgs(options::OPT_Xassembler);
4038 if (isa<AnalyzeJobAction>(JA)) {
4039 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
4040 CmdArgs.push_back(
"-analyze");
4041 }
else if (isa<MigrateJobAction>(JA)) {
4042 CmdArgs.push_back(
"-migrate");
4043 }
else if (isa<PreprocessJobAction>(JA)) {
4044 if (Output.
getType() == types::TY_Dependencies)
4045 CmdArgs.push_back(
"-Eonly");
4047 CmdArgs.push_back(
"-E");
4048 if (Args.hasArg(options::OPT_rewrite_objc) &&
4049 !Args.hasArg(options::OPT_g_Group))
4050 CmdArgs.push_back(
"-P");
4052 }
else if (isa<AssembleJobAction>(JA)) {
4053 CmdArgs.push_back(
"-emit-obj");
4058 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4059 }
else if (isa<PrecompileJobAction>(JA)) {
4060 if (JA.
getType() == types::TY_Nothing)
4061 CmdArgs.push_back(
"-fsyntax-only");
4062 else if (JA.
getType() == types::TY_ModuleFile)
4063 CmdArgs.push_back(IsHeaderModulePrecompile
4064 ?
"-emit-header-module" 4065 :
"-emit-module-interface");
4067 CmdArgs.push_back(
"-emit-pch");
4068 }
else if (isa<VerifyPCHJobAction>(JA)) {
4069 CmdArgs.push_back(
"-verify-pch");
4071 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
4072 "Invalid action for clang tool.");
4073 if (JA.
getType() == types::TY_Nothing) {
4074 CmdArgs.push_back(
"-fsyntax-only");
4075 }
else if (JA.
getType() == types::TY_LLVM_IR ||
4076 JA.
getType() == types::TY_LTO_IR) {
4077 CmdArgs.push_back(
"-emit-llvm");
4078 }
else if (JA.
getType() == types::TY_LLVM_BC ||
4079 JA.
getType() == types::TY_LTO_BC) {
4080 CmdArgs.push_back(
"-emit-llvm-bc");
4081 }
else if (JA.
getType() == types::TY_IFS ||
4082 JA.
getType() == types::TY_IFS_CPP) {
4084 Args.hasArg(options::OPT_interface_stub_version_EQ)
4085 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
4086 :
"experimental-ifs-v1";
4087 CmdArgs.push_back(
"-emit-interface-stubs");
4089 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
4090 }
else if (JA.
getType() == types::TY_PP_Asm) {
4091 CmdArgs.push_back(
"-S");
4092 }
else if (JA.
getType() == types::TY_AST) {
4093 CmdArgs.push_back(
"-emit-pch");
4094 }
else if (JA.
getType() == types::TY_ModuleFile) {
4095 CmdArgs.push_back(
"-module-file-info");
4096 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
4097 CmdArgs.push_back(
"-rewrite-objc");
4098 rewriteKind = RK_NonFragile;
4099 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
4100 CmdArgs.push_back(
"-rewrite-objc");
4101 rewriteKind = RK_Fragile;
4103 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
4110 if (JA.
getType() == types::TY_LLVM_BC)
4111 CmdArgs.push_back(
"-emit-llvm-uselists");
4117 if (D.
isUsingLTO() && !isDeviceOffloadAction) {
4118 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
4119 CmdArgs.push_back(
"-flto-unit");
4123 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
4125 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
4126 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
4129 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
4130 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
4132 if (Args.getLastArg(options::OPT_save_temps_EQ))
4133 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
4138 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
4140 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
4142 CmdArgs.push_back(
"-disable-llvm-passes");
4149 static const constexpr
unsigned kBitcodeOptionBlacklist[] = {
4150 options::OPT_mkernel,
4151 options::OPT_fapple_kext,
4152 options::OPT_ffunction_sections,
4153 options::OPT_fno_function_sections,
4154 options::OPT_fdata_sections,
4155 options::OPT_fno_data_sections,
4156 options::OPT_funique_section_names,
4157 options::OPT_fno_unique_section_names,
4158 options::OPT_mrestrict_it,
4159 options::OPT_mno_restrict_it,
4160 options::OPT_mstackrealign,
4161 options::OPT_mno_stackrealign,
4162 options::OPT_mstack_alignment,
4163 options::OPT_mcmodel_EQ,
4164 options::OPT_mlong_calls,
4165 options::OPT_mno_long_calls,
4166 options::OPT_ggnu_pubnames,
4167 options::OPT_gdwarf_aranges,
4168 options::OPT_fdebug_types_section,
4169 options::OPT_fno_debug_types_section,
4170 options::OPT_fdwarf_directory_asm,
4171 options::OPT_fno_dwarf_directory_asm,
4172 options::OPT_mrelax_all,
4173 options::OPT_mno_relax_all,
4174 options::OPT_ftrap_function_EQ,
4175 options::OPT_ffixed_r9,
4176 options::OPT_mfix_cortex_a53_835769,
4177 options::OPT_mno_fix_cortex_a53_835769,
4178 options::OPT_ffixed_x18,
4179 options::OPT_mglobal_merge,
4180 options::OPT_mno_global_merge,
4181 options::OPT_mred_zone,
4182 options::OPT_mno_red_zone,
4183 options::OPT_Wa_COMMA,
4184 options::OPT_Xassembler,
4187 for (
const auto &A : Args)
4188 if (llvm::find(kBitcodeOptionBlacklist, A->getOption().getID()) !=
4189 std::end(kBitcodeOptionBlacklist))
4190 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
4193 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
4194 options::OPT_fno_optimize_sibling_calls))
4195 CmdArgs.push_back(
"-mdisable-tail-calls");
4201 switch (TC.getArch()) {
4203 case llvm::Triple::arm:
4204 case llvm::Triple::armeb:
4205 case llvm::Triple::thumbeb:
4206 RenderARMABI(Triple, Args, CmdArgs);
4208 case llvm::Triple::aarch64:
4209 case llvm::Triple::aarch64_32:
4210 case llvm::Triple::aarch64_be:
4211 RenderAArch64ABI(Triple, Args, CmdArgs);
4216 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4217 if (A->getOption().matches(options::OPT_O4)) {
4218 CmdArgs.push_back(
"-O3");
4219 D.
Diag(diag::warn_O4_is_O3);
4221 A->render(Args, CmdArgs);
4226 if (Output.
getType() == types::TY_Dependencies) {
4229 CmdArgs.push_back(
"-o");
4232 assert(Output.
isNothing() &&
"Input output.");
4235 for (
const auto &II : Inputs) {
4237 if (II.isFilename())
4238 CmdArgs.push_back(II.getFilename());
4240 II.getInputArg().renderAsInput(Args, CmdArgs);
4249 CmdArgs.push_back(
"-fembed-bitcode=marker");
4255 CmdArgs.push_back(
"-disable-free");
4258 const bool IsAssertBuild =
false;
4260 const bool IsAssertBuild =
true;
4265 CmdArgs.push_back(
"-disable-llvm-verifier");
4268 if (Args.hasFlag(options::OPT_fdiscard_value_names,
4269 options::OPT_fno_discard_value_names, !IsAssertBuild))
4270 CmdArgs.push_back(
"-discard-value-names");
4274 CmdArgs.push_back(
"-main-file-name");
4275 CmdArgs.push_back(getBaseInputName(Args, Input));
4279 if (Args.hasArg(options::OPT_static))
4280 CmdArgs.push_back(
"-static-define");
4282 if (Args.hasArg(options::OPT_municode))
4283 CmdArgs.push_back(
"-DUNICODE");
4285 if (isa<AnalyzeJobAction>(JA))
4288 if (isa<AnalyzeJobAction>(JA) ||
4289 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
4290 CmdArgs.push_back(
"-setup-static-analyzer");
4295 bool FoundAnalyzerConfig =
false;
4296 for (
auto Arg : Args.filtered(options::OPT_Xclang))
4297 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
4298 FoundAnalyzerConfig =
true;
4301 if (!FoundAnalyzerConfig)
4302 for (
auto Arg : Args.filtered(options::OPT_Xanalyzer))
4303 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
4304 FoundAnalyzerConfig =
true;
4307 if (FoundAnalyzerConfig)
4308 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
4313 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
4314 if (FunctionAlignment) {
4315 CmdArgs.push_back(
"-function-alignment");
4316 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
4319 llvm::Reloc::Model RelocationModel;
4322 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
4326 if ((RelocationModel == llvm::Reloc::ROPI ||
4327 RelocationModel == llvm::Reloc::ROPI_RWPI) &&
4329 !Args.hasArg(options::OPT_fallow_unsupported))
4330 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
4333 CmdArgs.push_back(
"-mrelocation-model");
4334 CmdArgs.push_back(RMName);
4337 CmdArgs.push_back(
"-pic-level");
4338 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
4340 CmdArgs.push_back(
"-pic-is-pie");
4343 if (RelocationModel == llvm::Reloc::ROPI ||
4344 RelocationModel == llvm::Reloc::ROPI_RWPI)
4345 CmdArgs.push_back(
"-fropi");
4346 if (RelocationModel == llvm::Reloc::RWPI ||
4347 RelocationModel == llvm::Reloc::ROPI_RWPI)
4348 CmdArgs.push_back(
"-frwpi");
4350 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
4351 CmdArgs.push_back(
"-meabi");
4352 CmdArgs.push_back(A->getValue());
4355 CmdArgs.push_back(
"-mthread-model");
4356 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
4357 if (!TC.isThreadModelSupported(A->getValue()))
4358 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
4359 << A->getValue() << A->getAsString(Args);
4360 CmdArgs.push_back(A->getValue());
4363 CmdArgs.push_back(Args.MakeArgString(TC.getThreadModel()));
4365 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
4367 if (Args.hasFlag(options::OPT_fmerge_all_constants,
4368 options::OPT_fno_merge_all_constants,
false))
4369 CmdArgs.push_back(
"-fmerge-all-constants");
4371 if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks,
4372 options::OPT_fdelete_null_pointer_checks,
false))
4373 CmdArgs.push_back(
"-fno-delete-null-pointer-checks");
4377 if (Args.hasArg(options::OPT_frewrite_map_file) ||
4378 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
4379 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
4380 options::OPT_frewrite_map_file_EQ)) {
4381 StringRef Map = A->getValue();
4382 if (!llvm::sys::fs::exists(Map)) {
4383 D.
Diag(diag::err_drv_no_such_file) << Map;
4385 CmdArgs.push_back(
"-frewrite-map-file");
4386 CmdArgs.push_back(A->getValue());
4392 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
4393 StringRef
v = A->getValue();
4394 CmdArgs.push_back(
"-mllvm");
4395 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
4399 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
4401 CmdArgs.push_back(
"-fno-jump-tables");
4403 if (Args.hasFlag(options::OPT_fprofile_sample_accurate,
4404 options::OPT_fno_profile_sample_accurate,
false))
4405 CmdArgs.push_back(
"-fprofile-sample-accurate");
4407 if (!Args.hasFlag(options::OPT_fpreserve_as_comments,
4408 options::OPT_fno_preserve_as_comments,
true))
4409 CmdArgs.push_back(
"-fno-preserve-as-comments");
4411 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
4412 CmdArgs.push_back(
"-mregparm");
4413 CmdArgs.push_back(A->getValue());
4416 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
4417 options::OPT_freg_struct_return)) {
4418 if (TC.getArch() != llvm::Triple::x86) {
4419 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4420 << A->getSpelling() << RawTriple.str();
4421 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
4422 CmdArgs.push_back(
"-fpcc-struct-return");
4424 assert(A->getOption().matches(options::OPT_freg_struct_return));
4425 CmdArgs.push_back(
"-freg-struct-return");
4429 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
4430 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
4434 const char *FPKeepKindStr =
nullptr;
4435 switch (FPKeepKind) {
4437 FPKeepKindStr =
"-mframe-pointer=none";
4440 FPKeepKindStr =
"-mframe-pointer=non-leaf";
4443 FPKeepKindStr =
"-mframe-pointer=all";
4446 assert(FPKeepKindStr &&
"unknown FramePointerKind");
4447 CmdArgs.push_back(FPKeepKindStr);
4449 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
4450 options::OPT_fno_zero_initialized_in_bss))
4451 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
4456 OptSpecifier StrictAliasingAliasOption =
4457 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
4460 bool TBAAOnByDefault = !D.
IsCLMode();
4461 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
4462 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
4463 CmdArgs.push_back(
"-relaxed-aliasing");
4464 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
4465 options::OPT_fno_struct_path_tbaa))
4466 CmdArgs.push_back(
"-no-struct-path-tbaa");
4467 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
4469 CmdArgs.push_back(
"-fstrict-enums");
4470 if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
4472 CmdArgs.push_back(
"-fno-strict-return");
4473 if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
4474 options::OPT_fno_allow_editor_placeholders,
false))
4475 CmdArgs.push_back(
"-fallow-editor-placeholders");
4476 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
4477 options::OPT_fno_strict_vtable_pointers,
4479 CmdArgs.push_back(
"-fstrict-vtable-pointers");
4480 if (Args.hasFlag(options::OPT_fforce_emit_vtables,
4481 options::OPT_fno_force_emit_vtables,
4483 CmdArgs.push_back(
"-fforce-emit-vtables");
4484 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
4485 options::OPT_fno_optimize_sibling_calls))
4486 CmdArgs.push_back(
"-mdisable-tail-calls");
4487 if (Args.hasFlag(options::OPT_fno_escaping_block_tail_calls,
4488 options::OPT_fescaping_block_tail_calls,
false))
4489 CmdArgs.push_back(
"-fno-escaping-block-tail-calls");
4491 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
4492 options::OPT_fno_fine_grained_bitfield_accesses);
4495 if (Args.hasArg(options::OPT_fsplit_stack))
4496 CmdArgs.push_back(
"-split-stacks");
4500 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
4501 if (TC.getTriple().isX86())
4502 A->render(Args, CmdArgs);
4503 else if ((TC.getArch() == llvm::Triple::ppc || TC.getTriple().isPPC64()) &&
4504 (A->getOption().getID() != options::OPT_mlong_double_80))
4505 A->render(Args, CmdArgs);
4507 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4508 << A->getAsString(Args) << TripleStr;
4513 bool IsIntegratedAssemblerDefault = TC.IsIntegratedAssemblerDefault();
4514 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
4515 IsIntegratedAssemblerDefault))
4516 CmdArgs.push_back(
"-masm-verbose");
4518 if (!TC.useIntegratedAs())
4519 CmdArgs.push_back(
"-no-integrated-as");
4521 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
4522 CmdArgs.push_back(
"-mdebug-pass");
4523 CmdArgs.push_back(
"Structure");
4525 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
4526 CmdArgs.push_back(
"-mdebug-pass");
4527 CmdArgs.push_back(
"Arguments");
4533 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
4534 CmdArgs.push_back(
"-mconstructor-aliases");
4538 if (KernelOrKext && RawTriple.isOSDarwin())
4539 CmdArgs.push_back(
"-fforbid-guard-variables");
4541 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
4543 CmdArgs.push_back(
"-mms-bitfields");
4546 if (Args.hasFlag(options::OPT_mpie_copy_relocations,
4547 options::OPT_mno_pie_copy_relocations,
4549 CmdArgs.push_back(
"-mpie-copy-relocations");
4552 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
4553 CmdArgs.push_back(
"-fno-plt");
4560 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
4563 CmdArgs.push_back(
"-ffreestanding");
4568 bool AsynchronousUnwindTables =
4569 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
4570 options::OPT_fno_asynchronous_unwind_tables,
4571 (TC.IsUnwindTablesDefault(Args) ||
4572 TC.getSanitizerArgs().needsUnwindTables()) &&
4574 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
4575 AsynchronousUnwindTables))
4576 CmdArgs.push_back(
"-munwind-tables");
4581 (void)Args.hasArg(options::OPT_mtune_EQ);
4583 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
4584 CmdArgs.push_back(
"-mcode-model");
4585 CmdArgs.push_back(A->getValue());
4588 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
4589 StringRef
Value = A->getValue();
4590 unsigned TLSSize = 0;
4591 Value.getAsInteger(10, TLSSize);
4592 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
4593 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4594 << A->getOption().getName() << TripleStr;
4595 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
4596 D.
Diag(diag::err_drv_invalid_int_value)
4597 << A->getOption().getName() <<
Value;
4598 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
4602 std::string CPU =
getCPUName(Args, Triple,
false);
4604 CmdArgs.push_back(
"-target-cpu");
4605 CmdArgs.push_back(Args.MakeArgString(CPU));
4608 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
4612 bool EmitCodeView =
false;
4617 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
4621 CmdArgs, DebugInfoKind, DwarfFission);
4626 TC.getTriple().isOSBinFormatELF() &&
4627 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4628 isa<BackendJobAction>(JA));
4631 CmdArgs.push_back(
"-split-dwarf-file");
4632 CmdArgs.push_back(SplitDWARFOut);
4634 CmdArgs.push_back(
"-split-dwarf-output");
4635 CmdArgs.push_back(SplitDWARFOut);
4640 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4641 CmdArgs.push_back(
"-target-linker-version");
4642 CmdArgs.push_back(A->getValue());
4647 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
4649 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
4650 TC.getArch() == llvm::Triple::x86) {
4651 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
4652 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
4653 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
4654 << Unsupported->getOption().getName();
4657 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
4658 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
4659 << Unsupported->getOption().getName()
4660 <<
"please use -maltivec and include altivec.h explicitly";
4661 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
4662 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
4663 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
4666 Args.AddAllArgs(CmdArgs, options::OPT_v);
4667 Args.AddLastArg(CmdArgs, options::OPT_H);
4669 CmdArgs.push_back(
"-header-include-file");
4673 Args.AddLastArg(CmdArgs, options::OPT_P);
4674 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
4677 CmdArgs.push_back(
"-diagnostic-log-file");
4685 CmdArgs.push_back(
"-disable-pragma-debug-crash");
4689 if (Args.hasFlag(options::OPT_ffunction_sections,
4690 options::OPT_fno_function_sections, UseSeparateSections)) {
4691 CmdArgs.push_back(
"-ffunction-sections");
4694 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
4695 UseSeparateSections)) {
4696 CmdArgs.push_back(
"-fdata-sections");
4699 if (!Args.hasFlag(options::OPT_funique_section_names,
4700 options::OPT_fno_unique_section_names,
true))
4701 CmdArgs.push_back(
"-fno-unique-section-names");
4703 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
4704 options::OPT_finstrument_functions_after_inlining,
4705 options::OPT_finstrument_function_entry_bare);
4710 if (!Triple.isNVPTX())
4713 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
4716 if (RawTriple.isPS4CPU() &&
4717 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
4723 if (Args.hasArg(options::OPT_nostdinc)) {
4724 CmdArgs.push_back(
"-nostdsysteminc");
4725 CmdArgs.push_back(
"-nobuiltininc");
4727 if (Args.hasArg(options::OPT_nostdlibinc))
4728 CmdArgs.push_back(
"-nostdsysteminc");
4729 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
4730 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
4734 CmdArgs.push_back(
"-resource-dir");
4737 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
4746 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
4752 Args.ClaimAllArgs(options::OPT_D);
4755 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4756 if (A->getOption().matches(options::OPT_O4)) {
4757 CmdArgs.push_back(
"-O3");
4758 D.
Diag(diag::warn_O4_is_O3);
4760 A->render(Args, CmdArgs);
4766 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4767 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
4772 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
4773 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
4779 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
4781 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
4782 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
4783 CmdArgs.push_back(
"-pedantic");
4784 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
4785 Args.AddLastArg(CmdArgs, options::OPT_w);
4788 if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
4790 Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
4797 bool ImplyVCPPCXXVer =
false;
4798 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
4800 if (Std->getOption().matches(options::OPT_ansi))
4802 CmdArgs.push_back(
"-std=c++98");
4804 CmdArgs.push_back(
"-std=c89");
4806 Std->render(Args, CmdArgs);
4809 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
4810 options::OPT_ftrigraphs,
4811 options::OPT_fno_trigraphs))
4813 A->render(Args, CmdArgs);
4822 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
4824 else if (IsWindowsMSVC)
4825 ImplyVCPPCXXVer =
true;
4827 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4828 options::OPT_fno_trigraphs);
4844 Args.getLastArg(options::OPT_Wwrite_strings,
4845 options::OPT_Wno_write_strings, options::OPT_w);
4847 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
4848 CmdArgs.push_back(
"-fconst-strings");
4855 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4857 CmdArgs.push_back(
"-fdeprecated-macro");
4861 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4862 if (
Asm->getOption().matches(options::OPT_fasm))
4863 CmdArgs.push_back(
"-fgnu-keywords");
4865 CmdArgs.push_back(
"-fno-gnu-keywords");
4869 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4872 CmdArgs.push_back(
"-fno-autolink");
4879 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4880 options::OPT_ftemplate_depth_EQ)) {
4881 CmdArgs.push_back(
"-ftemplate-depth");
4882 CmdArgs.push_back(A->getValue());
4885 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4886 CmdArgs.push_back(
"-foperator-arrow-depth");
4887 CmdArgs.push_back(A->getValue());
4890 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4891 CmdArgs.push_back(
"-fconstexpr-depth");
4892 CmdArgs.push_back(A->getValue());
4895 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4896 CmdArgs.push_back(
"-fconstexpr-steps");
4897 CmdArgs.push_back(A->getValue());
4900 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
4901 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
4903 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4904 CmdArgs.push_back(
"-fbracket-depth");
4905 CmdArgs.push_back(A->getValue());
4908 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4909 options::OPT_Wlarge_by_value_copy_def)) {
4910 if (A->getNumValues()) {
4911 StringRef
bytes = A->getValue();
4912 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
4914 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
4917 if (Args.hasArg(options::OPT_relocatable_pch))
4918 CmdArgs.push_back(
"-relocatable-pch");
4920 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
4921 static const char *kCFABIs[] = {
4922 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
4925 if (find(kCFABIs, StringRef(A->getValue())) == std::end(kCFABIs))
4926 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
4928 A->render(Args, CmdArgs);
4931 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4932 CmdArgs.push_back(
"-fconstant-string-class");
4933 CmdArgs.push_back(A->getValue());
4936 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4937 CmdArgs.push_back(
"-ftabstop");
4938 CmdArgs.push_back(A->getValue());
4941 if (Args.hasFlag(options::OPT_fstack_size_section,
4942 options::OPT_fno_stack_size_section, RawTriple.isPS4()))
4943 CmdArgs.push_back(
"-fstack-size-section");
4945 CmdArgs.push_back(
"-ferror-limit");
4946 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
4947 CmdArgs.push_back(A->getValue());
4949 CmdArgs.push_back(
"19");
4951 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4952 CmdArgs.push_back(
"-fmacro-backtrace-limit");
4953 CmdArgs.push_back(A->getValue());
4956 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4957 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
4958 CmdArgs.push_back(A->getValue());
4961 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4962 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
4963 CmdArgs.push_back(A->getValue());
4966 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4967 CmdArgs.push_back(
"-fspell-checking-limit");
4968 CmdArgs.push_back(A->getValue());
4972 CmdArgs.push_back(
"-fmessage-length");
4973 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
4974 CmdArgs.push_back(A->getValue());
4978 unsigned N = llvm::sys::Process::StandardErrColumns();
4979 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
4983 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4984 options::OPT_fvisibility_ms_compat)) {
4985 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4986 CmdArgs.push_back(
"-fvisibility");
4987 CmdArgs.push_back(A->getValue());
4989 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4990 CmdArgs.push_back(
"-fvisibility");
4991 CmdArgs.push_back(
"hidden");
4992 CmdArgs.push_back(
"-ftype-visibility");
4993 CmdArgs.push_back(
"default");
4997 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
4998 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
5000 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
5003 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
5004 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
5005 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
5006 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
5007 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls,
5008 options::OPT_fno_emulated_tls);
5009 Args.AddLastArg(CmdArgs, options::OPT_fkeep_static_consts);
5012 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
5013 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
5015 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
5016 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
5020 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
5021 options::OPT_fno_openmp,
false) &&
5028 CmdArgs.push_back(
"-fopenmp");
5033 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
5034 options::OPT_fnoopenmp_use_tls,
true))
5035 CmdArgs.push_back(
"-fnoopenmp-use-tls");
5036 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
5037 options::OPT_fno_openmp_simd);
5038 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
5039 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
5040 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
5041 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
5042 Args.AddAllArgs(CmdArgs,
5043 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
5044 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
5045 options::OPT_fno_openmp_optimistic_collapse,
5047 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
5051 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
5052 options::OPT_fno_openmp_cuda_mode,
false))
5053 CmdArgs.push_back(
"-fopenmp-cuda-mode");
5057 if (Args.hasFlag(options::OPT_fopenmp_cuda_force_full_runtime,
5058 options::OPT_fno_openmp_cuda_force_full_runtime,
5060 CmdArgs.push_back(
"-fopenmp-cuda-force-full-runtime");
5072 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
5073 options::OPT_fno_openmp_simd);
5074 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
5078 Sanitize.
addArgs(TC, Args, CmdArgs, InputType);
5080 const XRayArgs &XRay = TC.getXRayArgs();
5081 XRay.
addArgs(TC, Args, CmdArgs, InputType);
5083 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
5084 StringRef S0 = A->getValue(), S = S0;
5085 unsigned Size,
Offset = 0;
5086 if (!Triple.isAArch64() && Triple.getArch() != llvm::Triple::x86 &&
5087 Triple.getArch() != llvm::Triple::x86_64)
5088 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5089 << A->getAsString(Args) << TripleStr;
5090 else if (S.consumeInteger(10, Size) ||
5091 (!S.empty() && (!S.consume_front(
",") ||
5092 S.consumeInteger(10, Offset) || !S.empty())))
5093 D.
Diag(diag::err_drv_invalid_argument_to_option)
5094 << S0 << A->getOption().getName();
5095 else if (Size < Offset)
5096 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
5098 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
5099 CmdArgs.push_back(Args.MakeArgString(
5100 "-fpatchable-function-entry-offset=" + Twine(Offset)));
5104 if (TC.SupportsProfiling()) {
5105 Args.AddLastArg(CmdArgs, options::OPT_pg);
5107 llvm::Triple::ArchType Arch = TC.getArch();
5108 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
5109 if (Arch == llvm::Triple::systemz || TC.getTriple().isX86())
5110 A->render(Args, CmdArgs);
5112 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5113 << A->getAsString(Args) << TripleStr;
5115 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
5116 if (Arch == llvm::Triple::systemz)
5117 A->render(Args, CmdArgs);
5119 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5120 << A->getAsString(Args) << TripleStr;
5122 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
5123 if (Arch == llvm::Triple::systemz)
5124 A->render(Args, CmdArgs);
5126 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5127 << A->getAsString(Args) << TripleStr;
5131 if (Args.getLastArg(options::OPT_fapple_kext) ||
5132 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
5133 CmdArgs.push_back(
"-fapple-kext");
5135 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
5136 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
5137 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
5138 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
5139 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
5140 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace);
5141 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
5142 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
5143 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
5144 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
5146 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
5147 CmdArgs.push_back(
"-ftrapv-handler");
5148 CmdArgs.push_back(A->getValue());
5151 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
5155 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
5156 if (A->getOption().matches(options::OPT_fwrapv))
5157 CmdArgs.push_back(
"-fwrapv");
5158 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
5159 options::OPT_fno_strict_overflow)) {
5160 if (A->getOption().matches(options::OPT_fno_strict_overflow))
5161 CmdArgs.push_back(
"-fwrapv");
5164 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
5165 options::OPT_fno_reroll_loops))
5166 if (A->getOption().matches(options::OPT_freroll_loops))
5167 CmdArgs.push_back(
"-freroll-loops");
5169 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
5170 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
5171 options::OPT_fno_unroll_loops);
5173 Args.AddLastArg(CmdArgs, options::OPT_pthread);
5175 if (Args.hasFlag(options::OPT_mspeculative_load_hardening, options::OPT_mno_speculative_load_hardening,
5177 CmdArgs.push_back(Args.MakeArgString(
"-mspeculative-load-hardening"));
5183 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
5185 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
5187 if (Args.hasArg(options::OPT_mstack_alignment)) {
5188 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
5189 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
5192 if (Args.hasArg(options::OPT_mstack_probe_size)) {
5193 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
5196 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
5198 CmdArgs.push_back(
"-mstack-probe-size=0");
5201 if (!Args.hasFlag(options::OPT_mstack_arg_probe,
5202 options::OPT_mno_stack_arg_probe,
true))
5203 CmdArgs.push_back(Args.MakeArgString(
"-mno-stack-arg-probe"));
5205 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
5206 options::OPT_mno_restrict_it)) {
5207 if (A->getOption().matches(options::OPT_mrestrict_it)) {
5208 CmdArgs.push_back(
"-mllvm");
5209 CmdArgs.push_back(
"-arm-restrict-it");
5211 CmdArgs.push_back(
"-mllvm");
5212 CmdArgs.push_back(
"-arm-no-restrict-it");
5214 }
else if (Triple.isOSWindows() &&
5215 (Triple.getArch() == llvm::Triple::arm ||
5216 Triple.getArch() == llvm::Triple::thumb)) {
5218 CmdArgs.push_back(
"-mllvm");
5219 CmdArgs.push_back(
"-arm-restrict-it");
5225 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
5226 options::OPT_fno_hip_new_launch_api,
false))
5227 CmdArgs.push_back(
"-fhip-new-launch-api");
5229 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
5231 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
5237 auto *PGOArg = Args.getLastArg(
5238 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
5239 options::OPT_fcs_profile_generate, options::OPT_fcs_profile_generate_EQ,
5240 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ);
5242 D.
Diag(diag::err_drv_argument_not_allowed_with)
5243 <<
"SampleUse with PGO options";
5245 StringRef fname = A->getValue();
5246 if (!llvm::sys::fs::exists(fname))
5247 D.
Diag(diag::err_drv_no_such_file) << fname;
5249 A->render(Args, CmdArgs);
5251 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
5255 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5256 options::OPT_fno_assume_sane_operator_new))
5257 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
5260 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
5261 TC.IsBlocksDefault()) ||
5262 (Args.hasArg(options::OPT_fgnu_runtime) &&
5263 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
5264 !Args.hasArg(options::OPT_fno_blocks))) {
5265 CmdArgs.push_back(
"-fblocks");
5267 if (!Args.hasArg(options::OPT_fgnu_runtime) && !TC.hasBlocksRuntime())
5268 CmdArgs.push_back(
"-fblocks-runtime-optional");
5272 if (TC.IsEncodeExtendedBlockSignatureDefault())
5273 CmdArgs.push_back(
"-fencode-extended-block-signature");
5275 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
5278 CmdArgs.push_back(
"-fcoroutines-ts");
5281 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
5282 options::OPT_fno_double_square_bracket_attributes);
5285 if (Args.hasFlag(options::OPT_fno_access_control,
5286 options::OPT_faccess_control,
false))
5287 CmdArgs.push_back(
"-fno-access-control");
5290 if (Args.hasFlag(options::OPT_fno_elide_constructors,
5291 options::OPT_felide_constructors,
false))
5292 CmdArgs.push_back(
"-fno-elide-constructors");
5298 CmdArgs.push_back(
"-fno-rtti");
5301 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
5302 TC.getArch() == llvm::Triple::hexagon))
5303 CmdArgs.push_back(
"-fshort-enums");
5309 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
5310 !RawTriple.isOSWindows() &&
5311 TC.getArch() != llvm::Triple::xcore &&
5312 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
5313 RawTriple.hasEnvironment())) ||
5315 CmdArgs.push_back(
"-fno-use-cxa-atexit");
5317 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
5318 options::OPT_fno_register_global_dtors_with_atexit,
5319 RawTriple.isOSDarwin() && !KernelOrKext))
5320 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
5323 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
5325 CmdArgs.push_back(
"-fms-extensions");
5328 if (Args.hasFlag(options::OPT_fuse_line_directives,
5329 options::OPT_fno_use_line_directives,
false))
5330 CmdArgs.push_back(
"-fuse-line-directives");
5333 bool IsMSVCCompat = Args.hasFlag(
5334 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
5335 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
5336 options::OPT_fno_ms_extensions,
true)));
5338 CmdArgs.push_back(
"-fms-compatibility");
5341 VersionTuple GNUCVer;
5342 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
5345 StringRef Val = A->getValue();
5346 Val = Val.empty() ?
"0" : Val;
5347 bool Invalid = GNUCVer.tryParse(Val);
5348 unsigned Minor = GNUCVer.getMinor().getValueOr(0);
5349 unsigned Patch = GNUCVer.getSubminor().getValueOr(0);
5350 if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
5351 D.
Diag(diag::err_drv_invalid_value)
5352 << A->getAsString(Args) << A->getValue();
5354 }
else if (!IsMSVCCompat) {
5356 GNUCVer = VersionTuple(4, 2, 1);
5358 if (!GNUCVer.empty()) {
5360 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
5363 VersionTuple MSVT = TC.computeMSVCVersion(&D, Args);
5366 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
5368 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
5369 if (ImplyVCPPCXXVer) {
5370 StringRef LanguageStandard;
5371 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
5373 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
5374 .Case(
"c++14",
"-std=c++14")
5375 .Case(
"c++17",
"-std=c++17")
5376 .Case(
"c++latest",
"-std=c++2a")
5378 if (LanguageStandard.empty())
5379 D.
Diag(clang::diag::warn_drv_unused_argument)
5380 << StdArg->getAsString(Args);
5383 if (LanguageStandard.empty()) {
5384 if (IsMSVC2015Compatible)
5385 LanguageStandard =
"-std=c++14";
5387 LanguageStandard =
"-std=c++11";
5390 CmdArgs.push_back(LanguageStandard.data());
5394 if (Args.hasFlag(options::OPT_fborland_extensions,
5395 options::OPT_fno_borland_extensions,
false))
5396 CmdArgs.push_back(
"-fborland-extensions");
5399 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
5401 CmdArgs.push_back(
"-fdeclspec");
5402 else if (Args.hasArg(options::OPT_fno_declspec))
5403 CmdArgs.push_back(
"-fno-declspec");
5407 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
5408 options::OPT_fno_threadsafe_statics,
5409 !IsWindowsMSVC || IsMSVC2015Compatible))
5410 CmdArgs.push_back(
"-fno-threadsafe-statics");
5416 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
5417 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
5418 CmdArgs.push_back(
"-fdelayed-template-parsing");
5422 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
5423 options::OPT_fno_gnu_keywords);
5425 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
5427 CmdArgs.push_back(
"-fgnu89-inline");
5429 if (Args.hasArg(options::OPT_fno_inline))
5430 CmdArgs.push_back(
"-fno-inline");
5432 Args.AddLastArg(CmdArgs, options::OPT_finline_functions,
5433 options::OPT_finline_hint_functions,
5434 options::OPT_fno_inline_functions);
5439 Std && (Std->containsValue(
"c++2a") || Std->containsValue(
"c++latest"));
5442 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
5443 options::OPT_fno_pch_validate_input_files_content,
false))
5444 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
5446 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager,
5447 options::OPT_fno_experimental_new_pass_manager);
5449 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
5453 if (Args.hasFlag(options::OPT_fapplication_extension,
5454 options::OPT_fno_application_extension,
false))
5455 CmdArgs.push_back(
"-fapplication-extension");
5462 Arg *A = Args.getLastArg(
5463 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
5464 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
5466 const Option &Opt = A->getOption();
5467 if (Opt.matches(options::OPT_fsjlj_exceptions))
5468 CmdArgs.push_back(
"-fsjlj-exceptions");
5469 if (Opt.matches(options::OPT_fseh_exceptions))
5470 CmdArgs.push_back(
"-fseh-exceptions");
5471 if (Opt.matches(options::OPT_fdwarf_exceptions))
5472 CmdArgs.push_back(
"-fdwarf-exceptions");
5473 if (Opt.matches(options::OPT_fwasm_exceptions))
5474 CmdArgs.push_back(
"-fwasm-exceptions");
5476 switch (TC.GetExceptionModel(Args)) {
5479 case llvm::ExceptionHandling::DwarfCFI:
5480 CmdArgs.push_back(
"-fdwarf-exceptions");
5482 case llvm::ExceptionHandling::SjLj:
5483 CmdArgs.push_back(
"-fsjlj-exceptions");
5485 case llvm::ExceptionHandling::WinEH:
5486 CmdArgs.push_back(
"-fseh-exceptions");
5492 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5493 options::OPT_fno_assume_sane_operator_new))
5494 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
5499 if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
5500 options::OPT_fno_relaxed_template_template_args,
false))
5501 CmdArgs.push_back(
"-frelaxed-template-template-args");
5505 if (Args.hasFlag(options::OPT_fsized_deallocation,
5506 options::OPT_fno_sized_deallocation,
false))
5507 CmdArgs.push_back(
"-fsized-deallocation");
5511 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
5512 options::OPT_fno_aligned_allocation,
5513 options::OPT_faligned_new_EQ)) {
5514 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
5515 CmdArgs.push_back(
"-fno-aligned-allocation");
5517 CmdArgs.push_back(
"-faligned-allocation");
5522 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
5523 options::OPT_faligned_new_EQ))
5525 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
5529 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
5530 options::OPT_fno_constant_cfstrings) ||
5531 !Args.hasFlag(options::OPT_mconstant_cfstrings,
5532 options::OPT_mno_constant_cfstrings))
5533 CmdArgs.push_back(
"-fno-constant-cfstrings");
5536 if (Args.hasFlag(options::OPT_fpascal_strings,
5537 options::OPT_fno_pascal_strings,
false))
5538 CmdArgs.push_back(
"-fpascal-strings");
5542 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
5543 std::string PackStructStr =
"-fpack-struct=";
5544 PackStructStr += A->getValue();
5545 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
5546 }
else if (Args.hasFlag(options::OPT_fpack_struct,
5547 options::OPT_fno_pack_struct,
false)) {
5548 CmdArgs.push_back(
"-fpack-struct=1");
5552 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
5553 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
5554 if (!SkipMaxTypeAlign) {
5555 std::string MaxTypeAlignStr =
"-fmax-type-align=";
5556 MaxTypeAlignStr += A->getValue();
5557 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5559 }
else if (RawTriple.isOSDarwin()) {
5560 if (!SkipMaxTypeAlign) {
5561 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
5562 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5566 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
5567 CmdArgs.push_back(
"-Qn");
5571 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
5573 CmdArgs.push_back(
"-fno-common");
5577 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
5578 options::OPT_funsigned_bitfields))
5579 D.
Diag(diag::warn_drv_clang_unsupported)
5580 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
5583 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
5584 D.
Diag(diag::err_drv_clang_unsupported)
5585 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
5588 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
5589 StringRef value = inputCharset->getValue();
5590 if (!value.equals_lower(
"utf-8"))
5591 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
5596 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
5597 StringRef value = execCharset->getValue();
5598 if (!value.equals_lower(
"utf-8"))
5599 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
5606 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
5608 CmdArgs.push_back(
"-fasm-blocks");
5611 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
5612 options::OPT_fno_gnu_inline_asm,
true))
5613 CmdArgs.push_back(
"-fno-gnu-inline-asm");
5619 OptSpecifier VectorizeAliasOption =
5620 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
5621 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
5622 options::OPT_fno_vectorize, EnableVec))
5623 CmdArgs.push_back(
"-vectorize-loops");
5627 OptSpecifier SLPVectAliasOption =
5628 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
5629 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
5630 options::OPT_fno_slp_vectorize, EnableSLPVec))
5631 CmdArgs.push_back(
"-vectorize-slp");
5635 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
5636 Args.AddLastArg(CmdArgs,
5637 options::OPT_fsanitize_undefined_strip_path_components_EQ);
5641 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
5642 options::OPT_fno_dollars_in_identifiers)) {
5643 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
5644 CmdArgs.push_back(
"-fdollars-in-identifiers");
5646 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
5651 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
5652 options::OPT_fno_unit_at_a_time)) {
5653 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
5654 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
5657 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
5658 options::OPT_fno_apple_pragma_pack,
false))
5659 CmdArgs.push_back(
"-fapple-pragma-pack");
5665 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
5666 options::OPT_fno_rewrite_imports,
false);
5668 CmdArgs.push_back(
"-frewrite-imports");
5674 if (Args.hasFlag(options::OPT_frewrite_includes,
5675 options::OPT_fno_rewrite_includes,
false) ||
5677 CmdArgs.push_back(
"-frewrite-includes");
5680 if (Arg *A = Args.getLastArg(options::OPT_traditional,
5681 options::OPT_traditional_cpp)) {
5682 if (isa<PreprocessJobAction>(JA))
5683 CmdArgs.push_back(
"-traditional-cpp");
5685 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
5688 Args.AddLastArg(CmdArgs, options::OPT_dM);
5689 Args.AddLastArg(CmdArgs, options::OPT_dD);
5692 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5693 CmdArgs.push_back(
"-serialize-diagnostic-file");
5694 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
5697 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5698 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
5701 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
5703 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
5706 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5707 CmdArgs.push_back(
"-load");
5708 CmdArgs.push_back(A->getValue());
5713 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
5715 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
5721 if (!StatsFile.empty())
5722 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
5729 !isa<PreprocessJobAction>(JA)) {
5730 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
5732 if (StringRef(Arg->getValue()) !=
"-finclude-default-header")
5733 CmdArgs.push_back(Arg->getValue());
5737 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
5739 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
5745 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
5746 CmdArgs.push_back(
"-disable-llvm-optzns");
5748 A->render(Args, CmdArgs);
5762 isa<CompileJobAction>(JA))
5763 CmdArgs.push_back(
"-disable-llvm-passes");
5765 Args.AddAllArgs(CmdArgs, options::OPT_undef);
5774 auto GRecordSwitches =
5775 Args.hasFlag(options::OPT_grecord_command_line,
5776 options::OPT_gno_record_command_line,
false);
5777 auto FRecordSwitches =
5778 Args.hasFlag(options::OPT_frecord_command_line,
5779 options::OPT_fno_record_command_line,
false);
5780 if (FRecordSwitches && !Triple.isOSBinFormatELF())
5781 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5782 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
5784 if (TC.UseDwarfDebugFlags() || GRecordSwitches || FRecordSwitches) {
5785 ArgStringList OriginalArgs;
5786 for (
const auto &Arg : Args)
5787 Arg->render(Args, OriginalArgs);
5791 for (
const char *OriginalArg : OriginalArgs) {
5795 Flags += EscapedArg;
5797 auto FlagsArgString = Args.MakeArgString(Flags);
5798 if (TC.UseDwarfDebugFlags() || GRecordSwitches) {
5799 CmdArgs.push_back(
"-dwarf-debug-flags");
5800 CmdArgs.push_back(FlagsArgString);
5802 if (FRecordSwitches) {
5803 CmdArgs.push_back(
"-record-command-line");
5804 CmdArgs.push_back(FlagsArgString);
5810 if ((IsCuda || IsHIP) && CudaDeviceInput) {
5811 CmdArgs.push_back(
"-fcuda-include-gpubinary");
5812 CmdArgs.push_back(CudaDeviceInput->
getFilename());
5813 if (Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false))
5814 CmdArgs.push_back(
"-fgpu-rdc");
5818 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
5819 options::OPT_fno_cuda_short_ptr,
false))
5820 CmdArgs.push_back(
"-fcuda-short-ptr");
5824 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
5831 if (IsOpenMPDevice) {
5832 CmdArgs.push_back(
"-fopenmp-is-device");
5833 if (OpenMPDeviceInput) {
5834 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
5835 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
5844 Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ);
5845 assert(Tgts && Tgts->getNumValues() &&
5846 "OpenMP offloading has to have targets specified.");
5847 for (
unsigned i = 0; i < Tgts->getNumValues(); ++i) {
5852 llvm::Triple T(Tgts->getValue(i));
5853 TargetInfo += T.getTriple();
5855 CmdArgs.push_back(Args.MakeArgString(TargetInfo.str()));
5858 bool VirtualFunctionElimination =
5859 Args.hasFlag(options::OPT_fvirtual_function_elimination,
5860 options::OPT_fno_virtual_function_elimination,
false);
5861 if (VirtualFunctionElimination) {
5865 D.
Diag(diag::err_drv_argument_only_allowed_with)
5866 <<
"-fvirtual-function-elimination" 5869 CmdArgs.push_back(
"-fvirtual-function-elimination");
5873 bool WholeProgramVTables = Args.hasFlag(
5874 options::OPT_fwhole_program_vtables,
5875 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
5876 if (VirtualFunctionElimination && !WholeProgramVTables) {
5877 D.
Diag(diag::err_drv_argument_not_allowed_with)
5878 <<
"-fno-whole-program-vtables" 5879 <<
"-fvirtual-function-elimination";
5882 if (WholeProgramVTables) {
5884 D.
Diag(diag::err_drv_argument_only_allowed_with)
5885 <<
"-fwhole-program-vtables" 5887 CmdArgs.push_back(
"-fwhole-program-vtables");
5890 bool DefaultsSplitLTOUnit =
5891 (WholeProgramVTables || Sanitize.
needsLTO()) &&
5894 Args.hasFlag(options::OPT_fsplit_lto_unit,
5895 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
5896 if (Sanitize.
needsLTO() && !SplitLTOUnit)
5897 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit" 5898 <<
"-fsanitize=cfi";
5900 CmdArgs.push_back(
"-fsplit-lto-unit");
5902 if (Arg *A = Args.getLastArg(options::OPT_fexperimental_isel,
5903 options::OPT_fno_experimental_isel)) {
5904 CmdArgs.push_back(
"-mllvm");
5905 if (A->getOption().matches(options::OPT_fexperimental_isel)) {
5906 CmdArgs.push_back(
"-global-isel=1");
5911 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
5912 bool IsOptLevelSupported =
false;
5914 Arg *A = Args.getLastArg(options::OPT_O_Group);
5915 if (Triple.getArch() == llvm::Triple::aarch64) {
5916 if (!A || A->getOption().matches(options::OPT_O0))
5917 IsOptLevelSupported =
true;
5919 if (!IsArchSupported || !IsOptLevelSupported) {
5920 CmdArgs.push_back(
"-mllvm");
5921 CmdArgs.push_back(
"-global-isel-abort=2");
5923 if (!IsArchSupported)
5924 D.
Diag(diag::warn_drv_experimental_isel_incomplete) << Triple.getArchName();
5926 D.
Diag(diag::warn_drv_experimental_isel_incomplete_opt);
5929 CmdArgs.push_back(
"-global-isel=0");
5933 if (Args.hasArg(options::OPT_forder_file_instrumentation)) {
5934 CmdArgs.push_back(
"-forder-file-instrumentation");
5939 CmdArgs.push_back(
"-mllvm");
5940 CmdArgs.push_back(
"-enable-order-file-instrumentation");
5944 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
5945 options::OPT_fno_force_enable_int128)) {
5946 if (A->getOption().matches(options::OPT_fforce_enable_int128))
5947 CmdArgs.push_back(
"-fforce-enable-int128");
5950 if (Args.hasFlag(options::OPT_fcomplete_member_pointers,
5951 options::OPT_fno_complete_member_pointers,
false))
5952 CmdArgs.push_back(
"-fcomplete-member-pointers");
5954 if (!Args.hasFlag(options::OPT_fcxx_static_destructors,
5955 options::OPT_fno_cxx_static_destructors,
true))
5956 CmdArgs.push_back(
"-fno-c++-static-destructors");
5958 if (Arg *A = Args.getLastArg(options::OPT_moutline,
5959 options::OPT_mno_outline)) {
5960 if (A->getOption().matches(options::OPT_moutline)) {
5964 if (Triple.getArch() != llvm::Triple::aarch64 &&
5965 Triple.getArch() != llvm::Triple::aarch64_32) {
5966 D.
Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
5968 CmdArgs.push_back(
"-mllvm");
5969 CmdArgs.push_back(
"-enable-machine-outliner");
5973 CmdArgs.push_back(
"-mllvm");
5974 CmdArgs.push_back(
"-enable-machine-outliner=never");
5978 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
5979 (TC.getTriple().isOSBinFormatELF() ||
5980 TC.getTriple().isOSBinFormatCOFF()) &&
5981 !TC.getTriple().isPS4() &&
5982 !TC.getTriple().isOSNetBSD() &&
5984 !TC.getTriple().isAndroid() &&
5985 TC.useIntegratedAs()))
5986 CmdArgs.push_back(
"-faddrsig");
5988 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
5989 std::string Str = A->getAsString(Args);
5990 if (!TC.getTriple().isOSBinFormatELF())
5991 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5992 << Str << TC.getTripleString();
5993 CmdArgs.push_back(Args.MakeArgString(Str));
5998 if (Output.
getType() == types::TY_Dependencies) {
6001 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
6002 Output.
getType() == clang::driver::types::TY_IFS) {
6004 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
6005 CmdArgs.push_back(
"-o");
6006 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6008 CmdArgs.push_back(
"-o");
6012 assert(Output.
isNothing() &&
"Invalid output.");
6018 if (IsHeaderModulePrecompile)
6019 FrontendInputs = ModuleHeaderInputs;
6021 FrontendInputs = {};
6023 for (
const InputInfo &Input : FrontendInputs) {
6031 if (Args.hasArg(options::OPT__SLASH_fallback) &&
6032 Output.
getType() == types::TY_Object &&
6033 (InputType == types::TY_C || InputType == types::TY_CXX)) {
6035 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
6036 C.
addCommand(std::make_unique<FallbackCommand>(
6037 JA, *
this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
6038 }
else if (Args.hasArg(options::OPT__SLASH_fallback) &&
6039 isa<PrecompileJobAction>(JA)) {
6042 C.
addCommand(std::make_unique<ForceSuccessCommand>(JA, *
this, Exec,
6047 std::make_unique<CC1Command>(JA, *
this, Exec, CmdArgs, Inputs));
6049 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6053 if (Output.
getType() == types::TY_Object &&
6054 Args.hasFlag(options::OPT__SLASH_showFilenames,
6055 options::OPT__SLASH_showFilenames_,
false)) {
6059 if (Arg *A = Args.getLastArg(options::OPT_pg))
6061 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer" 6062 << A->getAsString(Args);
6068 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
6072 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
6073 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
6076 Args.ClaimAllArgs(options::OPT_emit_llvm);
6083 :
Tool(
"clang",
"clang frontend", TC, RF_Full) {}
6090 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
6091 ArgStringList &cmdArgs,
6092 RewriteKind rewriteKind)
const {
6095 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
6096 options::OPT_fobjc_runtime_EQ);
6101 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
6103 StringRef value = runtimeArg->getValue();
6109 (runtime.
getVersion() >= VersionTuple(2, 0)))
6113 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
6117 runtimeArg->render(args, cmdArgs);
6126 unsigned objcABIVersion = 1;
6128 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
6129 StringRef value = abiArg->getValue();
6132 else if (value ==
"2")
6134 else if (value ==
"3")
6140 bool nonFragileABIIsDefault =
6141 (rewriteKind == RK_NonFragile ||
6142 (rewriteKind == RK_None &&
6144 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
6145 options::OPT_fno_objc_nonfragile_abi,
6146 nonFragileABIIsDefault)) {
6148 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 6149 unsigned nonFragileABIVersion = 1;
6151 unsigned nonFragileABIVersion = 2;
6155 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
6156 StringRef value = abiArg->getValue();
6158 nonFragileABIVersion = 1;
6159 else if (value ==
"2")
6160 nonFragileABIVersion = 2;
6166 objcABIVersion = 1 + nonFragileABIVersion;
6174 bool isNonFragile = objcABIVersion != 1;
6180 switch (rewriteKind) {
6193 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
6205 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
6215 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
6220 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
6228 bool Asynch =
false;
6229 bool NoUnwindC =
false;
6243 std::vector<std::string> EHArgs =
6244 Args.getAllArgValues(options::OPT__SLASH_EH);
6245 for (
auto EHVal : EHArgs) {
6246 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
6264 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
6270 if (EHArgs.empty() &&
6271 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
6274 EH.NoUnwindC =
true;
6280 void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
6281 ArgStringList &CmdArgs,
6283 bool *EmitCodeView)
const {
6284 unsigned RTOptionID = options::OPT__SLASH_MT;
6286 if (Args.hasArg(options::OPT__SLASH_LDd))
6289 RTOptionID = options::OPT__SLASH_MTd;
6291 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
6292 RTOptionID = A->getOption().getID();
6294 StringRef FlagForCRT;
6295 switch (RTOptionID) {
6296 case options::OPT__SLASH_MD:
6297 if (Args.hasArg(options::OPT__SLASH_LDd))
6298 CmdArgs.push_back(
"-D_DEBUG");
6299 CmdArgs.push_back(
"-D_MT");
6300 CmdArgs.push_back(
"-D_DLL");
6301 FlagForCRT =
"--dependent-lib=msvcrt";
6303 case options::OPT__SLASH_MDd:
6304 CmdArgs.push_back(
"-D_DEBUG");
6305 CmdArgs.push_back(
"-D_MT");
6306 CmdArgs.push_back(
"-D_DLL");
6307 FlagForCRT =
"--dependent-lib=msvcrtd";
6309 case options::OPT__SLASH_MT:
6310 if (Args.hasArg(options::OPT__SLASH_LDd))
6311 CmdArgs.push_back(
"-D_DEBUG");
6312 CmdArgs.push_back(
"-D_MT");
6313 CmdArgs.push_back(
"-flto-visibility-public-std");
6314 FlagForCRT =
"--dependent-lib=libcmt";
6316 case options::OPT__SLASH_MTd:
6317 CmdArgs.push_back(
"-D_DEBUG");
6318 CmdArgs.push_back(
"-D_MT");
6319 CmdArgs.push_back(
"-flto-visibility-public-std");
6320 FlagForCRT =
"--dependent-lib=libcmtd";
6323 llvm_unreachable(
"Unexpected option ID.");
6326 if (Args.hasArg(options::OPT__SLASH_Zl)) {
6327 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
6329 CmdArgs.push_back(FlagForCRT.data());
6334 CmdArgs.push_back(
"--dependent-lib=oldnames");
6337 Args.AddLastArg(CmdArgs, options::OPT_show_includes);
6340 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
6342 CmdArgs.push_back(
"-fno-rtti-data");
6346 if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
6348 CmdArgs.push_back(
"-stack-protector");
6353 if (Arg *DebugInfoArg =
6354 Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
6355 options::OPT_gline_tables_only)) {
6356 *EmitCodeView =
true;
6357 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
6362 *EmitCodeView =
false;
6367 if (EH.Synch || EH.Asynch) {
6369 CmdArgs.push_back(
"-fcxx-exceptions");
6370 CmdArgs.push_back(
"-fexceptions");
6372 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
6373 CmdArgs.push_back(
"-fexternc-nounwind");
6376 if (Args.hasArg(options::OPT__SLASH_EP)) {
6377 CmdArgs.push_back(
"-E");
6378 CmdArgs.push_back(
"-P");
6381 unsigned VolatileOptionID;
6383 VolatileOptionID = options::OPT__SLASH_volatile_ms;
6385 VolatileOptionID = options::OPT__SLASH_volatile_iso;
6387 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
6388 VolatileOptionID = A->getOption().getID();
6390 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
6391 CmdArgs.push_back(
"-fms-volatile");
6393 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
6394 options::OPT__SLASH_Zc_dllexportInlines,
6396 if (Args.hasArg(options::OPT__SLASH_fallback)) {
6397 D.
Diag(clang::diag::err_drv_dllexport_inlines_and_fallback);
6399 CmdArgs.push_back(
"-fno-dllexport-inlines");
6403 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
6404 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
6405 if (MostGeneralArg && BestCaseArg)
6406 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
6407 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
6409 if (MostGeneralArg) {
6410 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
6411 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
6412 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
6414 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
6415 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
6416 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
6417 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
6418 << FirstConflict->getAsString(Args)
6419 << SecondConflict->getAsString(Args);
6422 CmdArgs.push_back(
"-fms-memptr-rep=single");
6423 else if (MultipleArg)
6424 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
6426 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
6431 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
6432 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
6433 options::OPT__SLASH_Gregcall)) {
6434 unsigned DCCOptId = CCArg->getOption().getID();
6435 const char *DCCFlag =
nullptr;
6436 bool ArchSupported =
true;
6439 case options::OPT__SLASH_Gd:
6440 DCCFlag =
"-fdefault-calling-conv=cdecl";
6442 case options::OPT__SLASH_Gr:
6443 ArchSupported = Arch == llvm::Triple::x86;
6444 DCCFlag =
"-fdefault-calling-conv=fastcall";
6446 case options::OPT__SLASH_Gz:
6447 ArchSupported = Arch == llvm::Triple::x86;
6448 DCCFlag =
"-fdefault-calling-conv=stdcall";
6450 case options::OPT__SLASH_Gv:
6451 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
6452 DCCFlag =
"-fdefault-calling-conv=vectorcall";
6454 case options::OPT__SLASH_Gregcall:
6455 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
6456 DCCFlag =
"-fdefault-calling-conv=regcall";
6461 if (ArchSupported && DCCFlag)
6462 CmdArgs.push_back(DCCFlag);
6465 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
6467 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
6468 CmdArgs.push_back(
"-fdiagnostics-format");
6469 if (Args.hasArg(options::OPT__SLASH_fallback))
6470 CmdArgs.push_back(
"msvc-fallback");
6472 CmdArgs.push_back(
"msvc");
6475 if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
6476 StringRef GuardArgs = A->getValue();
6478 if (GuardArgs.equals_lower(
"cf")) {
6480 CmdArgs.push_back(
"-cfguard");
6481 }
else if (GuardArgs.equals_lower(
"cf,nochecks")) {
6483 CmdArgs.push_back(
"-cfguard-no-checks");
6484 }
else if (GuardArgs.equals_lower(
"cf-")) {
6487 D.
Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
6495 return CLFallback.get();
6501 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
6508 if (
const char *
End = strrchr(Str,
'.'))
6509 return Args.MakeArgString(std::string(Str,
End));
6518 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6520 llvm::sys::path::replace_extension(OutputFilename, llvm::Twine(
'd'));
6521 return Args.MakeArgString(OutputFilename);
6530 ArgStringList &CmdArgs)
const {
6536 CmdArgs.push_back(
"-target-abi");
6537 CmdArgs.push_back(ABIName.data());
6541 ArgStringList &CmdArgs)
const {
6544 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
6545 StringRef
Value = A->getValue();
6546 if (Value ==
"intel" || Value ==
"att") {
6547 CmdArgs.push_back(
"-mllvm");
6548 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
6551 << A->getOption().getName() <<
Value;
6557 ArgStringList &CmdArgs)
const {
6561 CmdArgs.push_back(
"-target-abi");
6562 CmdArgs.push_back(ABIName.data());
6567 const ArgList &Args,
6568 const char *LinkingOutput)
const {
6569 ArgStringList CmdArgs;
6571 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
6575 const std::string &TripleStr = Triple.getTriple();
6579 Args.ClaimAllArgs(options::OPT_w);
6581 Args.ClaimAllArgs(options::OPT_emit_llvm);
6588 CmdArgs.push_back(
"-cc1as");
6591 CmdArgs.push_back(
"-triple");
6592 CmdArgs.push_back(Args.MakeArgString(TripleStr));
6596 CmdArgs.push_back(
"-filetype");
6597 CmdArgs.push_back(
"obj");
6601 CmdArgs.push_back(
"-main-file-name");
6605 std::string CPU =
getCPUName(Args, Triple,
true);
6607 CmdArgs.push_back(
"-target-cpu");
6608 CmdArgs.push_back(Args.MakeArgString(CPU));
6615 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
6618 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
6621 const Action *SourceAction = &JA;
6623 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
6624 SourceAction = SourceAction->
getInputs()[0];
6629 bool WantDebug =
false;
6630 unsigned DwarfVersion = 0;
6631 Args.ClaimAllArgs(options::OPT_g_Group);
6632 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
6633 WantDebug = !A->getOption().matches(options::OPT_g0) &&
6634 !A->getOption().matches(options::OPT_ggdb0);
6640 if (DwarfVersion == 0)
6641 DwarfVersion = DefaultDwarfVersion;
6643 if (DwarfVersion == 0)
6648 if (SourceAction->
getType() == types::TY_Asm ||
6649 SourceAction->
getType() == types::TY_PP_Asm) {
6663 CmdArgs.push_back(
"-dwarf-debug-producer");
6667 Args.AddAllArgs(CmdArgs, options::OPT_I);
6670 llvm::DebuggerKind::Default);
6676 llvm::Reloc::Model RelocationModel;
6679 std::tie(RelocationModel, PICLevel, IsPIE) =
6684 CmdArgs.push_back(
"-mrelocation-model");
6685 CmdArgs.push_back(RMName);
6691 ArgStringList OriginalArgs;
6692 for (
const auto &Arg : Args)
6693 Arg->render(Args, OriginalArgs);
6698 for (
const char *OriginalArg : OriginalArgs) {
6702 Flags += EscapedArg;
6704 CmdArgs.push_back(
"-dwarf-debug-flags");
6705 CmdArgs.push_back(Args.MakeArgString(Flags));
6715 case llvm::Triple::mips:
6716 case llvm::Triple::mipsel:
6717 case llvm::Triple::mips64:
6718 case llvm::Triple::mips64el:
6719 AddMIPSTargetArgs(Args, CmdArgs);
6722 case llvm::Triple::x86:
6723 case llvm::Triple::x86_64:
6724 AddX86TargetArgs(Args, CmdArgs);
6727 case llvm::Triple::arm:
6728 case llvm::Triple::armeb:
6729 case llvm::Triple::thumb:
6730 case llvm::Triple::thumbeb:
6733 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
6734 options::OPT_mno_default_build_attributes,
true)) {
6735 CmdArgs.push_back(
"-mllvm");
6736 CmdArgs.push_back(
"-arm-add-build-attributes");
6740 case llvm::Triple::riscv32:
6741 case llvm::Triple::riscv64:
6742 AddRISCVTargetArgs(Args, CmdArgs);
6751 Args.ClaimAllArgs(options::OPT_W_Group);
6756 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
6758 assert(Output.
isFilename() &&
"Unexpected lipo output.");
6759 CmdArgs.push_back(
"-o");
6765 T.isOSBinFormatELF()) {
6766 CmdArgs.push_back(
"-split-dwarf-output");
6770 assert(Input.isFilename() &&
"Invalid input.");
6771 CmdArgs.push_back(Input.getFilename());
6774 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6782 const llvm::opt::ArgList &TCArgs,
6783 const char *LinkingOutput)
const {
6785 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
6793 ArgStringList CmdArgs;
6796 CmdArgs.push_back(TCArgs.MakeArgString(
6799 assert(JA.
getInputs().size() == Inputs.size() &&
6800 "Not have inputs for all dependence actions??");
6804 Triples +=
"-targets=";
6805 for (
unsigned I = 0; I < Inputs.size(); ++I) {
6814 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
6816 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
6817 assert(CurTC ==
nullptr &&
"Expected one dependence!");
6824 Triples += CurTC->
getTriple().normalize();
6830 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
6834 TCArgs.MakeArgString(Twine(
"-outputs=") + Output.
getFilename()));
6839 for (
unsigned I = 0; I < Inputs.size(); ++I) {
6845 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
6847 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
6848 assert(CurTC ==
nullptr &&
"Expected one dependence!");
6854 CmdArgs.push_back(TCArgs.MakeArgString(UB));
6865 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
6866 const char *LinkingOutput)
const {
6868 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
6877 ArgStringList CmdArgs;
6879 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
6883 CmdArgs.push_back(TCArgs.MakeArgString(
6888 Triples +=
"-targets=";
6889 auto DepInfo = UA.getDependentActionsInfo();
6890 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
6894 auto &Dep = DepInfo[I];
6897 Triples += Dep.DependentToolChain->getTriple().normalize();
6899 !Dep.DependentBoundArch.empty()) {
6901 Triples += Dep.DependentBoundArch;
6905 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
6909 TCArgs.MakeArgString(Twine(
"-inputs=") + Input.getFilename()));
6914 for (
unsigned I = 0; I < Outputs.size(); ++I) {
6917 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
6919 CmdArgs.push_back(TCArgs.MakeArgString(UB));
6920 CmdArgs.push_back(
"-unbundle");
6932 const ArgList &Args,
6933 const char *LinkingOutput)
const {
6934 ArgStringList CmdArgs;
6939 CmdArgs.push_back(
"-target");
6940 CmdArgs.push_back(Args.MakeArgString(Triple.getTriple()));
6943 assert(Output.
isFilename() &&
"Invalid output.");
6944 CmdArgs.push_back(
"-o");
6949 assert(I.isFilename() &&
"Invalid input.");
6950 CmdArgs.push_back(I.getFilename());
StringRef getSysRoot() const
Returns the sysroot path.
static bool checkRemarksOptions(const Driver &D, const ArgList &Args, const llvm::Triple &Triple)
static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, ArgStringList &CmdArgs)
static bool hasMultipleInvocations(const llvm::Triple &Triple, const ArgList &Args)
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)
static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC, const JobAction &JA)
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
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...
llvm::Expected< T > Expected
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type, or null if unspecified.
static void addExceptionArgs(const ArgList &Args, types::ID InputType, const ToolChain &TC, bool KernelOrKext, const ObjCRuntime &objcRuntime, ArgStringList &CmdArgs)
Adds exception related arguments to the driver command arguments.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Defines types useful for describing an Objective-C runtime.
bool embedBitcodeEnabled() const
static void addDebugPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the debug file path prefix map.
static void forAllAssociatedToolChains(Compilation &C, const JobAction &JA, const ToolChain &RegularToolChain, llvm::function_ref< void(const ToolChain &)> Work)
Apply Work on the current tool chain RegularToolChain and any other offloading tool chain that is ass...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticBuilder Diag(unsigned DiagID) const
static void QuoteTarget(StringRef Target, SmallVectorImpl< char > &Res)
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args)
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
static bool UseRelaxAll(Compilation &C, const ArgList &Args)
Check if -relax-all should be passed to the internal assembler.
static StringRef bytes(const std::vector< T, Allocator > &v)
Don't generate debug info.
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Distro - Helper class for detecting and classifying Linux distributions.
bool embedBitcodeMarkerOnly() const
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C, const Driver &D, const InputInfo &Output, const ArgList &Args, ArgStringList &CmdArgs)
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, bool OFastEnabled, const ArgList &Args, ArgStringList &CmdArgs)
bool isOffloading(OffloadKind OKind) const
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
Action - Represent an abstract compilation step to perform.
static const char * RelocationModelName(llvm::Reloc::Model Model)
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Emit only debug directives with the line numbers data.
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
types::ID getType() const
bool isDeviceOffloading(OffloadKind OKind) const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
Scope - A scope is a transient data structure that is used while parsing the program.
OffloadKind getOffloadingDeviceKind() const
static void RenderSSPOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC)
llvm::vfs::FileSystem & getVFS() const
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.
const char * CudaVersionToString(CudaVersion V)
static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
const ToolChain & getDefaultToolChain() const
static void getDefaultModuleCachePath(SmallVectorImpl< char > &Result)
Compute the default -fmodule-cache-path.
Exposes information about the current target.
static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs)
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
const DiagnosticsEngine & getDiags() const
bool isForDiagnostics() const
Return true if we're compiling for diagnostics.
static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind DebugInfoKind, unsigned DwarfVersion, llvm::DebuggerKind DebuggerTuning)
Defines the clang::LangOptions interface.
ActionClass getKind() const
Limit generated debug info to reduce size (-fno-standalone-debug).
static void getWebAssemblyTargetFeatures(const ArgList &Args, std::vector< StringRef > &Features)
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
std::string getAsString() const
static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
The -mprefer-vector-width option accepts either a positive integer or the string "none".
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
static unsigned DwarfVersionNum(StringRef ArgValue)
Defines version macros and version-related utility functions for Clang.
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
static void addX86AlignBranchArgs(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
void addCommand(std::unique_ptr< Command > C)
'gnustep' is the modern non-fragile GNUstep runtime.
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args)
const_offload_toolchains_range getOffloadToolChains() const
static bool isSignedCharDefault(const llvm::Triple &Triple)
static CodeGenOptions::FramePointerKind getFramePointerKind(const ArgList &Args, const llvm::Triple &Triple)
static void RenderModulesOptions(Compilation &C, const Driver &D, const ArgList &Args, const InputInfo &Input, const InputInfo &Output, ArgStringList &CmdArgs, bool &HaveModules)
bool embedBitcodeInObject() const
static bool isNoCommonDefault(const llvm::Triple &Triple)
static void EscapeSpacesAndBackslashes(const char *Arg, SmallVectorImpl< char > &Res)
const llvm::opt::DerivedArgList & getArgs() const
static bool getRefinementStep(StringRef In, const Driver &D, const Arg &A, size_t &Position)
This is a helper function for validating the optional refinement step parameter in reciprocal argumen...
Generate complete debug info.
static bool checkDebugInfoOption(const Arg *A, const ArgList &Args, const Driver &D, const ToolChain &TC)
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
static DwarfFissionKind getDebugFissionKind(const Driver &D, const ArgList &Args, Arg *&Arg)
bool isSaveTempsEnabled() const
Limit generated debug info for classes to reduce size.
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
const VersionTuple & getVersion() const
static void appendUserToPath(SmallVectorImpl< char > &Result)
Dataflow Directional Tag Classes.
const char * CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
static void RenderObjCOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, ObjCRuntime &Runtime, bool InferCovariantReturns, const InputInfo &Input, ArgStringList &CmdArgs)
The basic abstraction for the target Objective-C runtime.
Emit only debug info necessary for generating line number tables (-gline-tables-only).
std::string SysRoot
sysroot, if present
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
ActionList & getActions()
static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args)
/EH controls whether to run destructor cleanups when exceptions are thrown.
static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs, const llvm::vfs::FileSystem &VFS)
Add a CC1 option to specify the debug compilation directory.
std::string ClangExecutable
The original path to the clang executable.
Assembly: we accept this only so that we can preprocess it.
ID getPrecompiledType(ID Id)
getPrecompiledType - Get the ID of the type for this input when it has been precompiled, or INVALID if this input is not precompiled.
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Compilation - A set of tasks to perform for a single driver invocation.
const Driver & getDriver() const
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
const char * CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
const char * addFailureResultFile(const char *Name, const JobAction *JA)
addFailureResultFile - Add a file to remove if we crash, and returns its argument.
bool willEmitRemarks(const llvm::opt::ArgList &Args)
static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the macro file path prefix map.
static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple)
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
static void ParseMRecip(const Driver &D, const ArgList &Args, ArgStringList &OutStrings)
The -mrecip flag requires processing of many optional parameters.
static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec)
Vectorize at all optimization levels greater than 1 except for -Oz.
static bool maybeConsumeDash(const std::string &EH, size_t &I)
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
static void RenderTrivialAutoVarInitOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
const char * getClangProgramPath() const
Get the path to the main clang executable.
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input)
static bool ContainsCompileAction(const Action *A)
Check whether the given input tree contains any compilation actions.
static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A)
static bool ShouldDisableDwarfDirectory(const ArgList &Args, const ToolChain &TC)
bool isLLVMIR(ID Id)
Is this LLVM IR.
static void RenderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, bool EmitCodeView, bool IsWindowsMSVC, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind &DebugInfoKind, DwarfFissionKind &DwarfFission)
const char * getOffloadingArch() const
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
const list_type & getJobs() const
static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs)
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
bool allowsWeak() const
Does this runtime allow the use of __weak?
std::string ResourceDir
The path to the compiler resource directory.