32 #include "clang/Config/config.h"
41 #include "llvm/ADT/StringExtras.h"
42 #include "llvm/Config/llvm-config.h"
43 #include "llvm/Option/ArgList.h"
44 #include "llvm/Support/CodeGen.h"
45 #include "llvm/Support/Compiler.h"
46 #include "llvm/Support/Compression.h"
47 #include "llvm/Support/FileSystem.h"
48 #include "llvm/Support/Host.h"
49 #include "llvm/Support/Path.h"
50 #include "llvm/Support/Process.h"
51 #include "llvm/Support/TargetParser.h"
52 #include "llvm/Support/YAMLParser.h"
56 using namespace clang;
60 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
61 options::OPT_fminimize_whitespace,
62 options::OPT_fno_minimize_whitespace)) {
63 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
64 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
65 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
66 << A->getBaseArg().getAsString(Args)
67 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
74 if (Args.hasArg(options::OPT_static))
76 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
77 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
102 for (
unsigned i = 0, e =
Target.size(); i != e; ++i) {
107 for (
int j = i - 1; j >= 0 &&
Target[j] ==
'\\'; --j)
132 llvm::function_ref<
void(
const ToolChain &)> Work) {
134 Work(RegularToolChain);
149 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
164 const Arg &A,
size_t &Position) {
165 const char RefinementStepToken =
':';
166 Position = In.find(RefinementStepToken);
167 if (Position != StringRef::npos) {
168 StringRef Option = A.getOption().getName();
169 StringRef RefStep = In.substr(Position + 1);
177 if (RefStep.size() != 1) {
178 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
181 char RefStepChar = RefStep[0];
182 if (RefStepChar < '0' || RefStepChar >
'9') {
183 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
192 ArgStringList &OutStrings) {
193 StringRef DisabledPrefixIn =
"!";
194 StringRef DisabledPrefixOut =
"!";
195 StringRef EnabledPrefixOut =
"";
196 StringRef Out =
"-mrecip=";
198 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
202 unsigned NumOptions = A->getNumValues();
203 if (NumOptions == 0) {
205 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
210 if (NumOptions == 1) {
211 StringRef Val = A->getValue(0);
215 StringRef ValBase = Val.slice(0, RefStepLoc);
216 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
217 OutStrings.push_back(Args.MakeArgString(Out + Val));
226 llvm::StringMap<bool> OptionStrings;
227 OptionStrings.insert(std::make_pair(
"divd",
false));
228 OptionStrings.insert(std::make_pair(
"divf",
false));
229 OptionStrings.insert(std::make_pair(
"divh",
false));
230 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
231 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
232 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
233 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
234 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
235 OptionStrings.insert(std::make_pair(
"sqrth",
false));
236 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
237 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
238 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
240 for (
unsigned i = 0; i != NumOptions; ++i) {
241 StringRef Val = A->getValue(i);
243 bool IsDisabled = Val.startswith(DisabledPrefixIn);
252 StringRef ValBase = Val.slice(0, RefStep);
253 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
254 if (OptionIter == OptionStrings.end()) {
256 OptionIter = OptionStrings.find(ValBase.str() +
'f');
257 if (OptionIter == OptionStrings.end()) {
259 D.
Diag(diag::err_drv_unknown_argument) << Val;
265 if (OptionStrings[ValBase.str() +
'd'] ||
266 OptionStrings[ValBase.str() +
'h']) {
267 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
272 if (OptionIter->second ==
true) {
274 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
279 OptionIter->second =
true;
283 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
284 OptionStrings[ValBase.str() +
'd'] =
true;
285 OptionStrings[ValBase.str() +
'h'] =
true;
289 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
290 Out = Args.MakeArgString(Out + Prefix + Val);
291 if (i != NumOptions - 1)
292 Out = Args.MakeArgString(Out +
",");
295 OutStrings.push_back(Args.MakeArgString(Out));
301 ArgStringList &CmdArgs) {
302 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
306 StringRef
Value = A->getValue();
307 if (
Value ==
"none") {
308 CmdArgs.push_back(
"-mprefer-vector-width=none");
311 if (
Value.getAsInteger(10, Width)) {
312 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
315 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
320 std::vector<StringRef> &Features) {
325 const ArgList &Args, ArgStringList &CmdArgs,
326 bool ForAS,
bool IsAux =
false) {
327 std::vector<StringRef> Features;
328 switch (Triple.getArch()) {
331 case llvm::Triple::mips:
332 case llvm::Triple::mipsel:
333 case llvm::Triple::mips64:
334 case llvm::Triple::mips64el:
338 case llvm::Triple::arm:
339 case llvm::Triple::armeb:
340 case llvm::Triple::thumb:
341 case llvm::Triple::thumbeb:
345 case llvm::Triple::ppc:
346 case llvm::Triple::ppcle:
347 case llvm::Triple::ppc64:
348 case llvm::Triple::ppc64le:
351 case llvm::Triple::riscv32:
352 case llvm::Triple::riscv64:
355 case llvm::Triple::systemz:
358 case llvm::Triple::aarch64:
359 case llvm::Triple::aarch64_32:
360 case llvm::Triple::aarch64_be:
363 case llvm::Triple::x86:
364 case llvm::Triple::x86_64:
367 case llvm::Triple::hexagon:
370 case llvm::Triple::wasm32:
371 case llvm::Triple::wasm64:
374 case llvm::Triple::sparc:
375 case llvm::Triple::sparcel:
376 case llvm::Triple::sparcv9:
379 case llvm::Triple::r600:
380 case llvm::Triple::amdgcn:
383 case llvm::Triple::nvptx:
384 case llvm::Triple::nvptx64:
387 case llvm::Triple::m68k:
390 case llvm::Triple::msp430:
393 case llvm::Triple::ve:
396 case llvm::Triple::csky:
402 CmdArgs.push_back(IsAux ?
"-aux-target-feature" :
"-target-feature");
403 CmdArgs.push_back(Feature.data());
409 const llvm::Triple &Triple) {
416 if (!Triple.isMacOSX())
419 return (!Triple.isMacOSXVersionLT(10, 5) &&
420 (Triple.getArch() == llvm::Triple::x86_64 ||
421 Triple.getArch() == llvm::Triple::arm));
431 ArgStringList &CmdArgs) {
432 const llvm::Triple &Triple = TC.
getTriple();
437 Args.ClaimAllArgs(options::OPT_fexceptions);
438 Args.ClaimAllArgs(options::OPT_fno_exceptions);
439 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
440 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
441 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
442 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
443 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
444 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
449 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
452 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
453 options::OPT_fno_async_exceptions,
false);
455 CmdArgs.push_back(
"-fasync-exceptions");
462 Args.hasFlag(options::OPT_fobjc_exceptions,
463 options::OPT_fno_objc_exceptions,
true)) {
464 CmdArgs.push_back(
"-fobjc-exceptions");
471 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
472 !Triple.isPS() && !Triple.isDriverKit();
473 Arg *ExceptionArg = Args.getLastArg(
474 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
475 options::OPT_fexceptions, options::OPT_fno_exceptions);
477 CXXExceptionsEnabled =
478 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
479 ExceptionArg->getOption().matches(options::OPT_fexceptions);
481 if (CXXExceptionsEnabled) {
482 CmdArgs.push_back(
"-fcxx-exceptions");
491 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
494 CmdArgs.push_back(
"-fexceptions");
510 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
517 assert(A.getOption().matches(options::OPT_gN_Group) &&
518 "Not a -g option that specifies a debug-info level");
519 if (A.getOption().matches(options::OPT_g0) ||
520 A.getOption().matches(options::OPT_ggdb0))
522 if (A.getOption().matches(options::OPT_gline_tables_only) ||
523 A.getOption().matches(options::OPT_ggdb1))
525 if (A.getOption().matches(options::OPT_gline_directives_only))
531 switch (Triple.getArch()){
534 case llvm::Triple::arm:
535 case llvm::Triple::thumb:
538 return Triple.isOSDarwin();
543 const llvm::Triple &Triple) {
544 if (Args.hasArg(options::OPT_pg) && !Args.hasArg(options::OPT_mfentry))
547 switch (Triple.getArch()) {
548 case llvm::Triple::xcore:
549 case llvm::Triple::wasm32:
550 case llvm::Triple::wasm64:
551 case llvm::Triple::msp430:
555 case llvm::Triple::ppc:
556 case llvm::Triple::ppcle:
557 case llvm::Triple::ppc64:
558 case llvm::Triple::ppc64le:
559 case llvm::Triple::riscv32:
560 case llvm::Triple::riscv64:
561 case llvm::Triple::amdgcn:
562 case llvm::Triple::r600:
563 case llvm::Triple::csky:
569 if (Triple.isOSNetBSD()) {
573 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI ||
575 switch (Triple.getArch()) {
577 case llvm::Triple::arm:
578 case llvm::Triple::armeb:
579 case llvm::Triple::thumb:
580 case llvm::Triple::thumbeb:
581 if (Triple.isAndroid())
584 case llvm::Triple::mips64:
585 case llvm::Triple::mips64el:
586 case llvm::Triple::mips:
587 case llvm::Triple::mipsel:
588 case llvm::Triple::systemz:
589 case llvm::Triple::x86:
590 case llvm::Triple::x86_64:
597 if (Triple.isOSWindows()) {
598 switch (Triple.getArch()) {
599 case llvm::Triple::x86:
601 case llvm::Triple::x86_64:
602 return Triple.isOSBinFormatMachO();
603 case llvm::Triple::arm:
604 case llvm::Triple::thumb:
629 Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
630 options::OPT_fno_omit_frame_pointer);
631 bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer);
633 A && A->getOption().matches(options::OPT_fno_omit_frame_pointer);
635 Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
636 options::OPT_mno_omit_leaf_frame_pointer,
637 Triple.isAArch64() || Triple.isPS() || Triple.isVE());
649 ArgStringList &CmdArgs,
650 const llvm::vfs::FileSystem &VFS) {
651 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
652 options::OPT_fdebug_compilation_dir_EQ)) {
653 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
654 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
657 A->render(Args, CmdArgs);
658 }
else if (llvm::ErrorOr<std::string> CWD =
659 VFS.getCurrentWorkingDirectory()) {
660 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
662 StringRef Path(CmdArgs.back());
663 return Path.substr(Path.find(
'=') + 1).data();
667 const char *DebugCompilationDir,
668 const char *OutputFileName) {
670 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
671 if (StringRef(Arg->getValue()).startswith(
"-object-file-name"))
674 if (Args.hasArg(options::OPT_object_file_name_EQ))
678 if (ObjFileNameForDebug !=
"-" &&
679 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
680 (!DebugCompilationDir ||
681 llvm::sys::path::is_absolute(DebugCompilationDir))) {
683 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
686 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
691 const ArgList &Args, ArgStringList &CmdArgs) {
692 auto AddOneArg = [&](StringRef Map, StringRef Name) {
693 if (!Map.contains(
'='))
694 D.
Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
696 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
699 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
700 options::OPT_fdebug_prefix_map_EQ)) {
701 AddOneArg(A->getValue(), A->getOption().getName());
705 if (GlobalRemapEntry.empty())
707 AddOneArg(GlobalRemapEntry,
"environment");
712 ArgStringList &CmdArgs) {
713 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
714 options::OPT_fmacro_prefix_map_EQ)) {
715 StringRef Map = A->getValue();
716 if (!Map.contains(
'='))
717 D.
Diag(diag::err_drv_invalid_argument_to_option)
718 << Map << A->getOption().getName();
720 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
727 ArgStringList &CmdArgs) {
728 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
729 options::OPT_fcoverage_prefix_map_EQ)) {
730 StringRef Map = A->getValue();
731 if (!Map.contains(
'='))
732 D.
Diag(diag::err_drv_invalid_argument_to_option)
733 << Map << A->getOption().getName();
735 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
744 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
745 if (A->getOption().matches(options::OPT_O4) ||
746 A->getOption().matches(options::OPT_Ofast))
749 if (A->getOption().matches(options::OPT_O0))
752 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
755 StringRef S(A->getValue());
763 unsigned OptLevel = 0;
764 if (S.getAsInteger(10, OptLevel))
775 ArgStringList &CmdArgs) {
778 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
781 CmdArgs.push_back(
"-x");
782 if (Args.hasArg(options::OPT_rewrite_objc))
788 const char *ClangType;
790 case types::TY_CXXModule:
793 case types::TY_PP_CXXModule:
794 ClangType =
"c++-cpp-output";
800 CmdArgs.push_back(ClangType);
807 ArgStringList &CmdArgs) {
809 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
810 options::OPT_fprofile_generate_EQ,
811 options::OPT_fno_profile_generate);
812 if (PGOGenerateArg &&
813 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
814 PGOGenerateArg =
nullptr;
816 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
817 options::OPT_fcs_profile_generate_EQ,
818 options::OPT_fno_profile_generate);
819 if (CSPGOGenerateArg &&
820 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
821 CSPGOGenerateArg =
nullptr;
823 auto *ProfileGenerateArg = Args.getLastArg(
824 options::OPT_fprofile_instr_generate,
825 options::OPT_fprofile_instr_generate_EQ,
826 options::OPT_fno_profile_instr_generate);
827 if (ProfileGenerateArg &&
828 ProfileGenerateArg->getOption().matches(
829 options::OPT_fno_profile_instr_generate))
830 ProfileGenerateArg =
nullptr;
832 if (PGOGenerateArg && ProfileGenerateArg)
833 D.
Diag(diag::err_drv_argument_not_allowed_with)
834 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
838 if (PGOGenerateArg && ProfileUseArg)
839 D.
Diag(diag::err_drv_argument_not_allowed_with)
840 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
842 if (ProfileGenerateArg && ProfileUseArg)
843 D.
Diag(diag::err_drv_argument_not_allowed_with)
844 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
846 if (CSPGOGenerateArg && PGOGenerateArg) {
847 D.
Diag(diag::err_drv_argument_not_allowed_with)
848 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
849 PGOGenerateArg =
nullptr;
853 if (ProfileGenerateArg)
854 D.
Diag(diag::err_drv_unsupported_opt_for_target)
855 << ProfileGenerateArg->getSpelling() << TC.
getTriple().str();
857 D.
Diag(diag::err_drv_unsupported_opt_for_target)
858 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
861 if (ProfileGenerateArg) {
862 if (ProfileGenerateArg->getOption().matches(
863 options::OPT_fprofile_instr_generate_EQ))
864 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
865 ProfileGenerateArg->getValue()));
867 CmdArgs.push_back(
"-fprofile-instrument=clang");
868 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
870 CmdArgs.push_back(Args.MakeArgString(
875 Arg *PGOGenArg =
nullptr;
876 if (PGOGenerateArg) {
877 assert(!CSPGOGenerateArg);
878 PGOGenArg = PGOGenerateArg;
879 CmdArgs.push_back(
"-fprofile-instrument=llvm");
881 if (CSPGOGenerateArg) {
882 assert(!PGOGenerateArg);
883 PGOGenArg = CSPGOGenerateArg;
884 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
887 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
889 CmdArgs.push_back(Args.MakeArgString(
892 if (PGOGenArg->getOption().matches(
893 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
894 : options::OPT_fcs_profile_generate_EQ)) {
896 llvm::sys::path::append(Path,
"default_%m.profraw");
898 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
903 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
904 CmdArgs.push_back(Args.MakeArgString(
905 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
906 else if ((ProfileUseArg->getOption().matches(
907 options::OPT_fprofile_use_EQ) ||
908 ProfileUseArg->getOption().matches(
909 options::OPT_fprofile_instr_use))) {
911 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
912 if (Path.empty() || llvm::sys::fs::is_directory(Path))
913 llvm::sys::path::append(Path,
"default.profdata");
915 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
919 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
920 options::OPT_fno_test_coverage,
false) ||
921 Args.hasArg(options::OPT_coverage);
924 CmdArgs.push_back(
"-ftest-coverage");
926 CmdArgs.push_back(
"-fprofile-arcs");
928 if (Args.hasFlag(options::OPT_fcoverage_mapping,
929 options::OPT_fno_coverage_mapping,
false)) {
930 if (!ProfileGenerateArg)
931 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
932 <<
"-fcoverage-mapping"
933 <<
"-fprofile-instr-generate";
935 CmdArgs.push_back(
"-fcoverage-mapping");
938 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
939 options::OPT_fcoverage_compilation_dir_EQ)) {
940 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
941 CmdArgs.push_back(Args.MakeArgString(
942 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
944 A->render(Args, CmdArgs);
945 }
else if (llvm::ErrorOr<std::string> CWD =
946 D.
getVFS().getCurrentWorkingDirectory()) {
947 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
950 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
951 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
952 if (!Args.hasArg(options::OPT_coverage))
953 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
954 <<
"-fprofile-exclude-files="
957 StringRef
v = Arg->getValue();
959 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
962 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
963 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
964 if (!Args.hasArg(options::OPT_coverage))
965 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
966 <<
"-fprofile-filter-files="
969 StringRef
v = Arg->getValue();
970 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
973 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
974 StringRef Val = A->getValue();
975 if (Val ==
"atomic" || Val ==
"prefer-atomic")
976 CmdArgs.push_back(
"-fprofile-update=atomic");
977 else if (Val !=
"single")
978 D.
Diag(diag::err_drv_unsupported_option_argument)
979 << A->getOption().getName() << Val;
981 CmdArgs.push_back(
"-fprofile-update=atomic");
988 Arg *FProfileDir =
nullptr;
989 if (Args.hasArg(options::OPT_fprofile_arcs) ||
990 Args.hasArg(options::OPT_coverage))
991 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
998 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
999 (EmitCovNotes || EmitCovData) && Output.
isFilename()) {
1001 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT__SLASH_Fo))
1002 OutputFilename = FinalOutput->getValue();
1003 else if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1004 OutputFilename = FinalOutput->getValue();
1006 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
1008 if (llvm::sys::path::is_relative(CoverageFilename))
1009 (void)D.
getVFS().makeAbsolute(CoverageFilename);
1010 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
1012 CmdArgs.push_back(
"-coverage-notes-file");
1013 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
1017 CoverageFilename = FProfileDir->getValue();
1018 llvm::sys::path::append(CoverageFilename, OutputFilename);
1020 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
1021 CmdArgs.push_back(
"-coverage-data-file");
1022 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
1029 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
1038 bool RelaxDefault =
true;
1040 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1041 RelaxDefault = A->getOption().matches(options::OPT_O0);
1044 RelaxDefault =
false;
1045 for (
const auto &Act : C.getActions()) {
1047 RelaxDefault =
true;
1053 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1061 return llvm::StringSwitch<unsigned>(ArgValue)
1062 .Case(
"-gdwarf-2", 2)
1063 .Case(
"-gdwarf-3", 3)
1064 .Case(
"-gdwarf-4", 4)
1065 .Case(
"-gdwarf-5", 5)
1072 return Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
1073 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
1074 options::OPT_gdwarf);
1079 unsigned DwarfVersion,
1080 llvm::DebuggerKind DebuggerTuning) {
1083 CmdArgs.push_back(
"-debug-info-kind=line-directives-only");
1086 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
1089 CmdArgs.push_back(
"-debug-info-kind=constructor");
1092 CmdArgs.push_back(
"-debug-info-kind=limited");
1095 CmdArgs.push_back(
"-debug-info-kind=standalone");
1098 CmdArgs.push_back(
"-debug-info-kind=unused-types");
1103 if (DwarfVersion > 0)
1105 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
1106 switch (DebuggerTuning) {
1107 case llvm::DebuggerKind::GDB:
1108 CmdArgs.push_back(
"-debugger-tuning=gdb");
1110 case llvm::DebuggerKind::LLDB:
1111 CmdArgs.push_back(
"-debugger-tuning=lldb");
1113 case llvm::DebuggerKind::SCE:
1114 CmdArgs.push_back(
"-debugger-tuning=sce");
1116 case llvm::DebuggerKind::DBX:
1117 CmdArgs.push_back(
"-debugger-tuning=dbx");
1126 assert(A &&
"Expected non-nullptr argument.");
1129 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
1135 ArgStringList &CmdArgs,
1138 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
1142 StringRef
Value = A->getValue();
1143 if (
Value ==
"none") {
1144 CmdArgs.push_back(
"--compress-debug-sections=none");
1145 }
else if (
Value ==
"zlib") {
1146 if (llvm::zlib::isAvailable()) {
1148 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1150 D.
Diag(diag::warn_debug_compression_unavailable);
1153 D.
Diag(diag::err_drv_unsupported_option_argument)
1154 << A->getOption().getName() <<
Value;
1161 case llvm::Reloc::Static:
1163 case llvm::Reloc::PIC_:
1165 case llvm::Reloc::DynamicNoPIC:
1166 return "dynamic-no-pic";
1167 case llvm::Reloc::ROPI:
1169 case llvm::Reloc::RWPI:
1171 case llvm::Reloc::ROPI_RWPI:
1174 llvm_unreachable(
"Unknown Reloc::Model kind");
1177 const ArgList &Args,
1178 ArgStringList &CmdArgs,
1179 bool IsCC1As =
false) {
1187 CmdArgs.insert(CmdArgs.begin() + 1,
1188 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
1189 Twine(CodeObjVer)));
1190 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
1193 CmdArgs.insert(CmdArgs.begin() + 1,
1194 Args.MakeArgString(Twine(
"-mcode-object-version=") +
1195 Twine(CodeObjVer)));
1200 const Driver &D,
const ArgList &Args,
1201 ArgStringList &CmdArgs,
1204 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
1208 Args.AddLastArg(CmdArgs, options::OPT_C);
1209 Args.AddLastArg(CmdArgs, options::OPT_CC);
1212 Arg *ArgM = Args.getLastArg(options::OPT_MM);
1214 ArgM = Args.getLastArg(options::OPT_M);
1215 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1217 ArgMD = Args.getLastArg(options::OPT_MD);
1221 CmdArgs.push_back(
"-w");
1227 const char *DepFile;
1228 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1229 DepFile = MF->getValue();
1230 C.addFailureResultFile(DepFile, &JA);
1231 }
else if (Output.
getType() == types::TY_Dependencies) {
1233 }
else if (!ArgMD) {
1236 DepFile = getDependencyFileName(Args, Inputs);
1237 C.addFailureResultFile(DepFile, &JA);
1239 CmdArgs.push_back(
"-dependency-file");
1240 CmdArgs.push_back(DepFile);
1242 bool HasTarget =
false;
1243 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1246 if (A->getOption().matches(options::OPT_MT)) {
1247 A->render(Args, CmdArgs);
1249 CmdArgs.push_back(
"-MT");
1252 CmdArgs.push_back(Args.MakeArgString(Quoted));
1258 const char *DepTarget;
1262 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1263 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1264 DepTarget = OutputOpt->getValue();
1270 llvm::sys::path::replace_extension(
P,
"o");
1271 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1274 CmdArgs.push_back(
"-MT");
1277 CmdArgs.push_back(Args.MakeArgString(Quoted));
1280 if (ArgM->getOption().matches(options::OPT_M) ||
1281 ArgM->getOption().matches(options::OPT_MD))
1282 CmdArgs.push_back(
"-sys-header-deps");
1283 if ((isa<PrecompileJobAction>(JA) &&
1284 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1285 Args.hasArg(options::OPT_fmodule_file_deps))
1286 CmdArgs.push_back(
"-module-file-deps");
1289 if (Args.hasArg(options::OPT_MG)) {
1290 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1291 ArgM->getOption().matches(options::OPT_MMD))
1292 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1293 CmdArgs.push_back(
"-MG");
1296 Args.AddLastArg(CmdArgs, options::OPT_MP);
1297 Args.AddLastArg(CmdArgs, options::OPT_MV);
1304 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1306 getToolChain().AddHIPIncludeArgs(Args, CmdArgs);
1311 !Args.hasArg(options::OPT_nostdinc) &&
1312 (getToolChain().getTriple().isNVPTX() ||
1313 getToolChain().getTriple().isAMDGCN())) {
1314 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1318 llvm::sys::path::append(
P,
"include");
1319 llvm::sys::path::append(
P,
"openmp_wrappers");
1320 CmdArgs.push_back(
"-internal-isystem");
1321 CmdArgs.push_back(Args.MakeArgString(
P));
1324 CmdArgs.push_back(
"-include");
1325 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1334 if (getToolChain().getDriver().IsCLMode()) {
1335 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1336 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1339 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1342 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1343 options::OPT_fno_pch_instantiate_templates,
true))
1344 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1346 if (YcArg || YuArg) {
1347 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1348 if (!isa<PrecompileJobAction>(JA)) {
1349 CmdArgs.push_back(
"-include-pch");
1351 C, !ThroughHeader.empty()
1353 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1356 if (ThroughHeader.empty()) {
1357 CmdArgs.push_back(Args.MakeArgString(
1358 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1361 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1366 bool RenderedImplicitInclude =
false;
1367 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1368 if (A->getOption().matches(options::OPT_include) &&
1371 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1372 RenderedImplicitInclude =
true;
1374 bool FoundPCH =
false;
1379 llvm::sys::path::replace_extension(
P,
"pch");
1384 llvm::sys::path::replace_extension(
P,
"gch");
1391 if (IsFirstImplicitInclude) {
1393 CmdArgs.push_back(
"-include-pch");
1394 CmdArgs.push_back(Args.MakeArgString(
P));
1398 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1399 << A->getAsString(Args);
1402 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1409 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1416 A->render(Args, CmdArgs);
1419 Args.AddAllArgs(CmdArgs,
1420 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1421 options::OPT_F, options::OPT_index_header_map});
1429 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1430 options::OPT_Xpreprocessor);
1433 if (Arg *A = Args.getLastArg(options::OPT_I_))
1434 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1438 StringRef sysroot =
C.getSysRoot();
1439 if (sysroot !=
"") {
1440 if (!Args.hasArg(options::OPT_isysroot)) {
1441 CmdArgs.push_back(
"-isysroot");
1442 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1459 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1467 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1469 C, JA, getToolChain(),
1470 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1479 [&Args, &CmdArgs](
const ToolChain &TC) {
1484 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1490 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1491 options::OPT_fno_file_reproducible);
1496 switch (Triple.getArch()) {
1500 case llvm::Triple::aarch64:
1501 case llvm::Triple::aarch64_32:
1502 case llvm::Triple::aarch64_be:
1503 case llvm::Triple::arm:
1504 case llvm::Triple::armeb:
1505 case llvm::Triple::thumb:
1506 case llvm::Triple::thumbeb:
1507 if (Triple.isOSDarwin() || Triple.isOSWindows())
1511 case llvm::Triple::ppc:
1512 case llvm::Triple::ppc64:
1513 if (Triple.isOSDarwin())
1517 case llvm::Triple::hexagon:
1518 case llvm::Triple::ppcle:
1519 case llvm::Triple::ppc64le:
1520 case llvm::Triple::riscv32:
1521 case llvm::Triple::riscv64:
1522 case llvm::Triple::systemz:
1523 case llvm::Triple::xcore:
1529 const ArgList &Args) {
1532 if (!Triple.isOSDarwin())
1536 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1540 const llvm::Triple &Triple) {
1545 bool hasExplicitOutputFile =
1546 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1548 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1549 <<
"-foptimization-record-file";
1556 const llvm::Triple &Triple,
1559 StringRef Format =
"yaml";
1560 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1561 Format = A->getValue();
1563 CmdArgs.push_back(
"-opt-record-file");
1565 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1567 CmdArgs.push_back(A->getValue());
1569 bool hasMultipleArchs =
1570 Triple.isOSDarwin() &&
1571 Args.getAllArgValues(options::OPT_arch).size() > 1;
1575 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1576 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1577 F = FinalOutput->getValue();
1579 if (Format !=
"yaml" &&
1580 Triple.isOSDarwin() &&
1594 llvm::sys::path::replace_extension(F,
"");
1596 Triple.normalize());
1606 if (hasMultipleArchs) {
1610 llvm::sys::path::replace_extension(F,
"");
1613 F += Triple.getArchName();
1615 llvm::sys::path::replace_extension(F, OldExtension);
1619 Extension +=
"opt.";
1620 Extension += Format;
1622 llvm::sys::path::replace_extension(F, Extension);
1623 CmdArgs.push_back(Args.MakeArgString(F));
1627 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1628 CmdArgs.push_back(
"-opt-record-passes");
1629 CmdArgs.push_back(A->getValue());
1632 if (!Format.empty()) {
1633 CmdArgs.push_back(
"-opt-record-format");
1634 CmdArgs.push_back(Format.data());
1639 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1640 options::OPT_fno_aapcs_bitfield_width,
true))
1641 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1643 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1644 CmdArgs.push_back(
"-faapcs-bitfield-load");
1648 void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1649 const ArgList &Args, ArgStringList &CmdArgs) {
1653 const char *ABIName =
nullptr;
1654 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1655 ABIName = A->getValue();
1658 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1661 CmdArgs.push_back(
"-target-abi");
1662 CmdArgs.push_back(ABIName);
1665 void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1666 auto StrictAlignIter =
1667 std::find_if(CmdArgs.rbegin(), CmdArgs.rend(), [](StringRef Arg) {
1668 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1670 if (StrictAlignIter != CmdArgs.rend() &&
1671 StringRef(*StrictAlignIter) ==
"+strict-align")
1672 CmdArgs.push_back(
"-Wunaligned-access");
1677 ArgStringList &CmdArgs,
bool isAArch64) {
1678 const Arg *A = isAArch64
1679 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1680 options::OPT_mbranch_protection_EQ)
1681 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1687 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1688 D.
Diag(diag::warn_incompatible_branch_protection_option)
1689 << Triple.getArchName();
1691 StringRef
Scope, Key;
1692 bool IndirectBranches;
1694 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1695 Scope = A->getValue();
1696 if (!
Scope.equals(
"none") && !
Scope.equals(
"non-leaf") &&
1697 !
Scope.equals(
"all"))
1698 D.
Diag(diag::err_invalid_branch_protection)
1699 <<
Scope << A->getAsString(Args);
1701 IndirectBranches =
false;
1704 llvm::ARM::ParsedBranchProtection PBP;
1705 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg))
1706 D.
Diag(diag::err_invalid_branch_protection)
1707 << DiagMsg << A->getAsString(Args);
1708 if (!isAArch64 && PBP.Key ==
"b_key")
1709 D.
Diag(diag::warn_unsupported_branch_protection)
1710 <<
"b-key" << A->getAsString(Args);
1713 IndirectBranches = PBP.BranchTargetEnforcement;
1717 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1718 if (!
Scope.equals(
"none"))
1720 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1721 if (IndirectBranches)
1722 CmdArgs.push_back(
"-mbranch-target-enforce");
1725 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1726 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1727 RenderARMABI(getToolChain().getDriver(), Triple, Args, CmdArgs);
1734 CmdArgs.push_back(
"-msoft-float");
1735 CmdArgs.push_back(
"-mfloat-abi");
1736 CmdArgs.push_back(
"soft");
1739 CmdArgs.push_back(
"-mfloat-abi");
1740 CmdArgs.push_back(
"soft");
1744 CmdArgs.push_back(
"-mfloat-abi");
1745 CmdArgs.push_back(
"hard");
1749 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1750 options::OPT_mno_global_merge)) {
1751 CmdArgs.push_back(
"-mllvm");
1752 if (A->getOption().matches(options::OPT_mno_global_merge))
1753 CmdArgs.push_back(
"-arm-global-merge=false");
1755 CmdArgs.push_back(
"-arm-global-merge=true");
1758 if (!Args.hasFlag(options::OPT_mimplicit_float,
1759 options::OPT_mno_implicit_float,
true))
1760 CmdArgs.push_back(
"-no-implicit-float");
1762 if (Args.getLastArg(options::OPT_mcmse))
1763 CmdArgs.push_back(
"-mcmse");
1770 AddUnalignedAccessWarning(CmdArgs);
1773 void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1774 const ArgList &Args,
bool KernelOrKext,
1775 ArgStringList &CmdArgs)
const {
1786 case llvm::Triple::arm:
1787 case llvm::Triple::armeb:
1788 case llvm::Triple::thumb:
1789 case llvm::Triple::thumbeb:
1791 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1792 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1795 case llvm::Triple::aarch64:
1796 case llvm::Triple::aarch64_32:
1797 case llvm::Triple::aarch64_be:
1798 AddAArch64TargetArgs(Args, CmdArgs);
1799 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
1802 case llvm::Triple::mips:
1803 case llvm::Triple::mipsel:
1804 case llvm::Triple::mips64:
1805 case llvm::Triple::mips64el:
1806 AddMIPSTargetArgs(Args, CmdArgs);
1809 case llvm::Triple::ppc:
1810 case llvm::Triple::ppcle:
1811 case llvm::Triple::ppc64:
1812 case llvm::Triple::ppc64le:
1813 AddPPCTargetArgs(Args, CmdArgs);
1816 case llvm::Triple::riscv32:
1817 case llvm::Triple::riscv64:
1818 AddRISCVTargetArgs(Args, CmdArgs);
1821 case llvm::Triple::sparc:
1822 case llvm::Triple::sparcel:
1823 case llvm::Triple::sparcv9:
1824 AddSparcTargetArgs(Args, CmdArgs);
1827 case llvm::Triple::systemz:
1828 AddSystemZTargetArgs(Args, CmdArgs);
1831 case llvm::Triple::x86:
1832 case llvm::Triple::x86_64:
1833 AddX86TargetArgs(Args, CmdArgs);
1836 case llvm::Triple::lanai:
1837 AddLanaiTargetArgs(Args, CmdArgs);
1840 case llvm::Triple::hexagon:
1841 AddHexagonTargetArgs(Args, CmdArgs);
1844 case llvm::Triple::wasm32:
1845 case llvm::Triple::wasm64:
1846 AddWebAssemblyTargetArgs(Args, CmdArgs);
1849 case llvm::Triple::ve:
1850 AddVETargetArgs(Args, CmdArgs);
1856 void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1857 ArgStringList &CmdArgs) {
1858 const char *ABIName =
nullptr;
1859 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1860 ABIName = A->getValue();
1861 else if (Triple.isOSDarwin())
1862 ABIName =
"darwinpcs";
1866 CmdArgs.push_back(
"-target-abi");
1867 CmdArgs.push_back(ABIName);
1871 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1872 ArgStringList &CmdArgs)
const {
1873 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1875 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1876 Args.hasArg(options::OPT_mkernel) ||
1877 Args.hasArg(options::OPT_fapple_kext))
1878 CmdArgs.push_back(
"-disable-red-zone");
1880 if (!Args.hasFlag(options::OPT_mimplicit_float,
1881 options::OPT_mno_implicit_float,
true))
1882 CmdArgs.push_back(
"-no-implicit-float");
1884 RenderAArch64ABI(Triple, Args, CmdArgs);
1887 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1888 options::OPT_mno_global_merge)) {
1889 CmdArgs.push_back(
"-mllvm");
1890 if (A->getOption().matches(options::OPT_mno_global_merge))
1891 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1893 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1900 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1901 StringRef Val = A->getValue();
1902 const Driver &D = getToolChain().getDriver();
1903 if (Val.equals(
"128") || Val.equals(
"256") || Val.equals(
"512") ||
1904 Val.equals(
"1024") || Val.equals(
"2048") || Val.equals(
"128+") ||
1905 Val.equals(
"256+") || Val.equals(
"512+") || Val.equals(
"1024+") ||
1906 Val.equals(
"2048+")) {
1908 if (Val.endswith(
"+"))
1909 Val = Val.substr(0, Val.size() - 1);
1911 bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid;
1912 assert(!Invalid &&
"Failed to parse value");
1914 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1917 bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid;
1918 assert(!Invalid &&
"Failed to parse value");
1920 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1922 }
else if (!Val.equals(
"scalable"))
1924 D.
Diag(diag::err_drv_unsupported_option_argument)
1925 << A->getOption().getName() << Val;
1930 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1931 StringRef Name = A->getValue();
1934 if (Name ==
"native")
1935 TuneCPU =
std::string(llvm::sys::getHostCPUName());
1939 if (!TuneCPU.empty()) {
1940 CmdArgs.push_back(
"-tune-cpu");
1941 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1945 AddUnalignedAccessWarning(CmdArgs);
1948 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1949 ArgStringList &CmdArgs)
const {
1950 const Driver &D = getToolChain().getDriver();
1953 const llvm::Triple &Triple = getToolChain().getTriple();
1956 CmdArgs.push_back(
"-target-abi");
1957 CmdArgs.push_back(ABIName.data());
1962 CmdArgs.push_back(
"-msoft-float");
1963 CmdArgs.push_back(
"-mfloat-abi");
1964 CmdArgs.push_back(
"soft");
1968 CmdArgs.push_back(
"-mfloat-abi");
1969 CmdArgs.push_back(
"hard");
1972 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1973 options::OPT_mno_ldc1_sdc1)) {
1974 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1975 CmdArgs.push_back(
"-mllvm");
1976 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1980 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1981 options::OPT_mno_check_zero_division)) {
1982 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1983 CmdArgs.push_back(
"-mllvm");
1984 CmdArgs.push_back(
"-mno-check-zero-division");
1988 if (Args.getLastArg(options::OPT_mfix4300)) {
1989 CmdArgs.push_back(
"-mllvm");
1990 CmdArgs.push_back(
"-mfix4300");
1993 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1994 StringRef
v = A->getValue();
1995 CmdArgs.push_back(
"-mllvm");
1996 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
2000 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
2002 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
2015 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
2017 llvm::Reloc::Model RelocationModel;
2020 std::tie(RelocationModel, PICLevel, IsPIE) =
2023 NoABICalls = NoABICalls ||
2024 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
2026 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
2028 if (NoABICalls && (!GPOpt || WantGPOpt)) {
2029 CmdArgs.push_back(
"-mllvm");
2030 CmdArgs.push_back(
"-mgpopt");
2032 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
2033 options::OPT_mno_local_sdata);
2034 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
2035 options::OPT_mno_extern_sdata);
2036 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
2037 options::OPT_mno_embedded_data);
2039 CmdArgs.push_back(
"-mllvm");
2040 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
2041 CmdArgs.push_back(
"-mlocal-sdata=1");
2043 CmdArgs.push_back(
"-mlocal-sdata=0");
2045 LocalSData->claim();
2049 CmdArgs.push_back(
"-mllvm");
2050 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
2051 CmdArgs.push_back(
"-mextern-sdata=1");
2053 CmdArgs.push_back(
"-mextern-sdata=0");
2055 ExternSData->claim();
2059 CmdArgs.push_back(
"-mllvm");
2060 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
2061 CmdArgs.push_back(
"-membedded-data=1");
2063 CmdArgs.push_back(
"-membedded-data=0");
2065 EmbeddedData->claim();
2068 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
2069 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
2074 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
2075 StringRef Val = StringRef(A->getValue());
2077 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
2078 CmdArgs.push_back(
"-mllvm");
2079 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
2081 D.
Diag(diag::err_drv_unsupported_option_argument)
2082 << A->getOption().getName() << Val;
2084 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
2087 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
2088 options::OPT_mno_relax_pic_calls)) {
2089 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
2090 CmdArgs.push_back(
"-mllvm");
2091 CmdArgs.push_back(
"-mips-jalr-reloc=0");
2096 void Clang::AddPPCTargetArgs(
const ArgList &Args,
2097 ArgStringList &CmdArgs)
const {
2099 const char *ABIName =
nullptr;
2100 const llvm::Triple &T = getToolChain().getTriple();
2101 if (T.isOSBinFormatELF()) {
2102 switch (getToolChain().getArch()) {
2103 case llvm::Triple::ppc64: {
2104 if ((T.isOSFreeBSD() && T.getOSMajorVersion() >= 13) ||
2105 T.isOSOpenBSD() || T.isMusl())
2111 case llvm::Triple::ppc64le:
2119 bool IEEELongDouble = getToolChain().defaultToIEEELongDouble();
2120 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2121 StringRef
V = A->getValue();
2122 if (
V ==
"ieeelongdouble")
2123 IEEELongDouble =
true;
2124 else if (
V ==
"ibmlongdouble")
2125 IEEELongDouble =
false;
2126 else if (
V !=
"altivec")
2130 ABIName = A->getValue();
2133 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2140 CmdArgs.push_back(
"-msoft-float");
2141 CmdArgs.push_back(
"-mfloat-abi");
2142 CmdArgs.push_back(
"soft");
2146 CmdArgs.push_back(
"-mfloat-abi");
2147 CmdArgs.push_back(
"hard");
2151 CmdArgs.push_back(
"-target-abi");
2152 CmdArgs.push_back(ABIName);
2157 ArgStringList &CmdArgs) {
2159 const llvm::Triple &Triple = TC.
getTriple();
2161 const char *SmallDataLimit =
"8";
2163 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2164 options::OPT_fPIC)) {
2166 SmallDataLimit =
"0";
2167 if (Args.hasArg(options::OPT_G)) {
2168 D.
Diag(diag::warn_drv_unsupported_sdata);
2170 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2171 .equals_insensitive(
"large") &&
2172 (Triple.getArch() == llvm::Triple::riscv64)) {
2174 SmallDataLimit =
"0";
2175 if (Args.hasArg(options::OPT_G)) {
2176 D.
Diag(diag::warn_drv_unsupported_sdata);
2178 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2179 SmallDataLimit = A->getValue();
2182 CmdArgs.push_back(
"-msmall-data-limit");
2183 CmdArgs.push_back(SmallDataLimit);
2186 void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2187 ArgStringList &CmdArgs)
const {
2188 const llvm::Triple &Triple = getToolChain().getTriple();
2191 CmdArgs.push_back(
"-target-abi");
2192 CmdArgs.push_back(ABIName.data());
2198 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2199 StringRef Name = A->getValue();
2201 Name = llvm::RISCV::resolveTuneCPUAlias(Name, Triple.isArch64Bit());
2205 if (!TuneCPU.empty()) {
2206 CmdArgs.push_back(
"-tune-cpu");
2207 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2211 void Clang::AddSparcTargetArgs(
const ArgList &Args,
2212 ArgStringList &CmdArgs)
const {
2218 CmdArgs.push_back(
"-msoft-float");
2219 CmdArgs.push_back(
"-mfloat-abi");
2220 CmdArgs.push_back(
"soft");
2224 CmdArgs.push_back(
"-mfloat-abi");
2225 CmdArgs.push_back(
"hard");
2229 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2230 ArgStringList &CmdArgs)
const {
2231 bool HasBackchain = Args.hasFlag(options::OPT_mbackchain,
2232 options::OPT_mno_backchain,
false);
2233 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2234 options::OPT_mno_packed_stack,
false);
2238 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2239 const Driver &D = getToolChain().getDriver();
2240 D.
Diag(diag::err_drv_unsupported_opt)
2241 <<
"-mpacked-stack -mbackchain -mhard-float";
2244 CmdArgs.push_back(
"-mbackchain");
2246 CmdArgs.push_back(
"-mpacked-stack");
2249 CmdArgs.push_back(
"-msoft-float");
2250 CmdArgs.push_back(
"-mfloat-abi");
2251 CmdArgs.push_back(
"soft");
2255 void Clang::AddX86TargetArgs(
const ArgList &Args,
2256 ArgStringList &CmdArgs)
const {
2257 const Driver &D = getToolChain().getDriver();
2260 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2261 Args.hasArg(options::OPT_mkernel) ||
2262 Args.hasArg(options::OPT_fapple_kext))
2263 CmdArgs.push_back(
"-disable-red-zone");
2265 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2266 options::OPT_mno_tls_direct_seg_refs,
true))
2267 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2271 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2272 Args.hasArg(options::OPT_fapple_kext));
2273 if (Arg *A = Args.getLastArg(
2274 options::OPT_msoft_float, options::OPT_mno_soft_float,
2275 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2276 const Option &O = A->getOption();
2277 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2278 O.matches(options::OPT_msoft_float));
2280 if (NoImplicitFloat)
2281 CmdArgs.push_back(
"-no-implicit-float");
2283 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2284 StringRef
Value = A->getValue();
2286 CmdArgs.push_back(
"-mllvm");
2287 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2288 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2290 D.
Diag(diag::err_drv_unsupported_option_argument)
2291 << A->getOption().getName() <<
Value;
2294 CmdArgs.push_back(
"-mllvm");
2295 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2298 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2299 options::OPT_mno_skip_rax_setup))
2300 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2301 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2304 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2305 CmdArgs.push_back(
"-mfloat-abi");
2306 CmdArgs.push_back(
"soft");
2307 CmdArgs.push_back(
"-mstack-alignment=4");
2314 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2315 !getToolChain().getTriple().isPS())
2316 TuneCPU =
"generic";
2319 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2320 StringRef Name = A->getValue();
2322 if (Name ==
"native") {
2323 Name = llvm::sys::getHostCPUName();
2330 if (!TuneCPU.empty()) {
2331 CmdArgs.push_back(
"-tune-cpu");
2332 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2336 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2337 ArgStringList &CmdArgs)
const {
2338 CmdArgs.push_back(
"-mqdsp6-compat");
2339 CmdArgs.push_back(
"-Wreturn-type");
2342 CmdArgs.push_back(
"-mllvm");
2343 CmdArgs.push_back(Args.MakeArgString(
"-hexagon-small-data-threshold=" +
2344 Twine(G.getValue())));
2347 if (!Args.hasArg(options::OPT_fno_short_enums))
2348 CmdArgs.push_back(
"-fshort-enums");
2349 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2350 CmdArgs.push_back(
"-mllvm");
2351 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2353 CmdArgs.push_back(
"-mllvm");
2354 CmdArgs.push_back(
"-machine-sink-split=0");
2357 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2358 ArgStringList &CmdArgs)
const {
2359 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2360 StringRef CPUName = A->getValue();
2362 CmdArgs.push_back(
"-target-cpu");
2363 CmdArgs.push_back(Args.MakeArgString(CPUName));
2365 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2366 StringRef
Value = A->getValue();
2370 if (
Value.getAsInteger(10, Mregparm)) {
2371 if (Mregparm != 4) {
2372 getToolChain().getDriver().Diag(
2373 diag::err_drv_unsupported_option_argument)
2374 << A->getOption().getName() <<
Value;
2380 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2381 ArgStringList &CmdArgs)
const {
2383 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2384 options::OPT_fvisibility_ms_compat)) {
2385 CmdArgs.push_back(
"-fvisibility");
2386 CmdArgs.push_back(
"hidden");
2390 void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2392 CmdArgs.push_back(
"-mfloat-abi");
2393 CmdArgs.push_back(
"hard");
2397 StringRef Target,
const InputInfo &Output,
2398 const InputInfo &Input,
const ArgList &Args)
const {
2400 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2403 using llvm::yaml::escape;
2404 const Driver &D = getToolChain().getDriver();
2406 if (!CompilationDatabase) {
2408 auto File = std::make_unique<llvm::raw_fd_ostream>(
2409 Filename, EC, llvm::sys::fs::OF_TextWithCRLF);
2411 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2415 CompilationDatabase = std::move(File);
2417 auto &CDB = *CompilationDatabase;
2418 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2421 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2422 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2423 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2428 CDB <<
", \"" << escape(Buf) <<
"\"";
2429 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2432 CDB <<
", \"" << escape(Buf) <<
"\"";
2434 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2435 for (
auto &A: Args) {
2436 auto &O = A->getOption();
2438 if (O.getID() == options::OPT_x)
2441 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2443 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2446 if (O.getKind() == Option::InputClass)
2450 A->render(Args, ASL);
2452 CDB <<
", \"" << escape(it) <<
"\"";
2456 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2459 void Clang::DumpCompilationDatabaseFragmentToDir(
2461 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2463 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2466 if (CompilationDatabase)
2467 DumpCompilationDatabase(C,
"", Target, Output, Input, Args);
2470 const auto &
Driver =
C.getDriver();
2472 auto Err = llvm::sys::fs::create_directory(Path,
true);
2474 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2478 llvm::sys::path::append(
2480 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2483 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2484 llvm::sys::fs::OF_Text);
2486 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2489 CompilationDatabase =
2490 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2491 DumpCompilationDatabase(C,
"", Target, Output, Input, Args);
2501 CmdArgs.push_back(
"-mllvm");
2502 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2506 const ArgList &Args,
2507 ArgStringList &CmdArgs,
2510 CmdArgs.push_back(
"-mrelax-all");
2514 bool DefaultIncrementalLinkerCompatible =
2515 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2516 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2517 options::OPT_mno_incremental_linker_compatible,
2518 DefaultIncrementalLinkerCompatible))
2519 CmdArgs.push_back(
"-mincremental-linker-compatible");
2529 bool TakeNextArg =
false;
2531 bool UseRelaxRelocations = C.getDefaultToolChain().useRelaxRelocations();
2532 bool UseNoExecStack =
false;
2533 const char *MipsTargetFeature =
nullptr;
2534 StringRef ImplicitIt;
2536 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2537 options::OPT_mimplicit_it_EQ)) {
2540 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2541 switch (C.getDefaultToolChain().getArch()) {
2542 case llvm::Triple::arm:
2543 case llvm::Triple::armeb:
2544 case llvm::Triple::thumb:
2545 case llvm::Triple::thumbeb:
2547 ImplicitIt = A->getValue();
2549 D.
Diag(diag::err_drv_unsupported_option_argument)
2550 << A->getOption().getName() << ImplicitIt;
2557 for (StringRef
Value : A->getValues()) {
2559 CmdArgs.push_back(
Value.data());
2560 TakeNextArg =
false;
2564 if (C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2565 Value ==
"-mbig-obj")
2568 switch (C.getDefaultToolChain().getArch()) {
2571 case llvm::Triple::thumb:
2572 case llvm::Triple::thumbeb:
2573 case llvm::Triple::arm:
2574 case llvm::Triple::armeb:
2575 if (
Value.startswith(
"-mimplicit-it=")) {
2577 ImplicitIt =
Value.split(
"=").second;
2581 if (
Value ==
"-mthumb")
2586 case llvm::Triple::mips:
2587 case llvm::Triple::mipsel:
2588 case llvm::Triple::mips64:
2589 case llvm::Triple::mips64el:
2590 if (
Value ==
"--trap") {
2591 CmdArgs.push_back(
"-target-feature");
2592 CmdArgs.push_back(
"+use-tcc-in-div");
2595 if (
Value ==
"--break") {
2596 CmdArgs.push_back(
"-target-feature");
2597 CmdArgs.push_back(
"-use-tcc-in-div");
2600 if (
Value.startswith(
"-msoft-float")) {
2601 CmdArgs.push_back(
"-target-feature");
2602 CmdArgs.push_back(
"+soft-float");
2605 if (
Value.startswith(
"-mhard-float")) {
2606 CmdArgs.push_back(
"-target-feature");
2607 CmdArgs.push_back(
"-soft-float");
2611 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2612 .Case(
"-mips1",
"+mips1")
2613 .Case(
"-mips2",
"+mips2")
2614 .Case(
"-mips3",
"+mips3")
2615 .Case(
"-mips4",
"+mips4")
2616 .Case(
"-mips5",
"+mips5")
2617 .Case(
"-mips32",
"+mips32")
2618 .Case(
"-mips32r2",
"+mips32r2")
2619 .Case(
"-mips32r3",
"+mips32r3")
2620 .Case(
"-mips32r5",
"+mips32r5")
2621 .Case(
"-mips32r6",
"+mips32r6")
2622 .Case(
"-mips64",
"+mips64")
2623 .Case(
"-mips64r2",
"+mips64r2")
2624 .Case(
"-mips64r3",
"+mips64r3")
2625 .Case(
"-mips64r5",
"+mips64r5")
2626 .Case(
"-mips64r6",
"+mips64r6")
2628 if (MipsTargetFeature)
2632 if (
Value ==
"-force_cpusubtype_ALL") {
2634 }
else if (
Value ==
"-L") {
2635 CmdArgs.push_back(
"-msave-temp-labels");
2636 }
else if (
Value ==
"--fatal-warnings") {
2637 CmdArgs.push_back(
"-massembler-fatal-warnings");
2638 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2639 CmdArgs.push_back(
"-massembler-no-warn");
2640 }
else if (
Value ==
"--noexecstack") {
2641 UseNoExecStack =
true;
2642 }
else if (
Value.startswith(
"-compress-debug-sections") ||
2643 Value.startswith(
"--compress-debug-sections") ||
2644 Value ==
"-nocompress-debug-sections" ||
2645 Value ==
"--nocompress-debug-sections") {
2646 CmdArgs.push_back(
Value.data());
2647 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2648 Value ==
"--mrelax-relocations=yes") {
2649 UseRelaxRelocations =
true;
2650 }
else if (
Value ==
"-mrelax-relocations=no" ||
2651 Value ==
"--mrelax-relocations=no") {
2652 UseRelaxRelocations =
false;
2653 }
else if (
Value.startswith(
"-I")) {
2654 CmdArgs.push_back(
Value.data());
2659 }
else if (
Value.startswith(
"-gdwarf-")) {
2662 if (DwarfVersion == 0) {
2663 CmdArgs.push_back(
Value.data());
2667 DwarfVersion, llvm::DebuggerKind::Default);
2669 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2670 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2672 }
else if (
Value ==
"-defsym") {
2673 if (A->getNumValues() != 2) {
2674 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2677 const char *S = A->getValue(1);
2678 auto Pair = StringRef(S).split(
'=');
2679 auto Sym = Pair.first;
2680 auto SVal = Pair.second;
2682 if (Sym.empty() || SVal.empty()) {
2683 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2687 if (SVal.getAsInteger(0, IVal)) {
2688 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2691 CmdArgs.push_back(
Value.data());
2693 }
else if (
Value ==
"-fdebug-compilation-dir") {
2694 CmdArgs.push_back(
"-fdebug-compilation-dir");
2696 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2700 CmdArgs.push_back(
"-fdebug-compilation-dir");
2701 CmdArgs.push_back(
Value.data());
2702 }
else if (
Value ==
"--version") {
2705 D.
Diag(diag::err_drv_unsupported_option_argument)
2706 << A->getOption().getName() <<
Value;
2710 if (ImplicitIt.size())
2712 if (UseRelaxRelocations)
2713 CmdArgs.push_back(
"--mrelax-relocations");
2715 CmdArgs.push_back(
"-mnoexecstack");
2716 if (MipsTargetFeature !=
nullptr) {
2717 CmdArgs.push_back(
"-target-feature");
2718 CmdArgs.push_back(MipsTargetFeature);
2722 if (C.getDriver().embedBitcodeEnabled() ||
2723 C.getDriver().embedBitcodeMarkerOnly())
2724 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2728 bool OFastEnabled,
const ArgList &Args,
2729 ArgStringList &CmdArgs,
2736 bool HonorINFs =
true;
2737 bool HonorNaNs =
true;
2738 bool ApproxFunc =
false;
2741 bool AssociativeMath =
false;
2742 bool ReciprocalMath =
false;
2743 bool SignedZeros =
true;
2744 bool TrappingMath =
false;
2745 bool TrappingMathPresent =
false;
2747 bool RoundingFPMath =
false;
2748 bool RoundingMathPresent =
false;
2750 StringRef FPModel =
"";
2752 StringRef FPExceptionBehavior =
"";
2754 StringRef FPEvalMethod =
"";
2755 const llvm::DenormalMode DefaultDenormalFPMath =
2757 const llvm::DenormalMode DefaultDenormalFP32Math =
2760 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
2761 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
2764 StringRef FPContract;
2768 bool StrictFPModel =
false;
2770 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2771 CmdArgs.push_back(
"-mlimit-float-precision");
2772 CmdArgs.push_back(A->getValue());
2775 for (
const Arg *A : Args) {
2776 auto optID = A->getOption().getID();
2777 bool PreciseFPModel =
false;
2781 case options::OPT_ffp_model_EQ: {
2787 AssociativeMath =
false;
2788 ReciprocalMath =
false;
2792 DenormalFPMath = llvm::DenormalMode::getIEEE();
2796 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2798 StringRef Val = A->getValue();
2799 if (OFastEnabled && !Val.equals(
"fast")) {
2801 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2802 << Args.MakeArgString(
"-ffp-model=" + Val)
2806 StrictFPModel =
false;
2807 PreciseFPModel =
true;
2811 if (!FPModel.empty() && !FPModel.equals(Val))
2812 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2813 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2814 << Args.MakeArgString(
"-ffp-model=" + Val);
2815 if (Val.equals(
"fast")) {
2816 optID = options::OPT_ffast_math;
2818 FPContract =
"fast";
2819 }
else if (Val.equals(
"precise")) {
2820 optID = options::OPT_ffp_contract;
2823 PreciseFPModel =
true;
2824 }
else if (Val.equals(
"strict")) {
2825 StrictFPModel =
true;
2826 optID = options::OPT_frounding_math;
2827 FPExceptionBehavior =
"strict";
2830 TrappingMath =
true;
2832 D.
Diag(diag::err_drv_unsupported_option_argument)
2833 << A->getOption().getName() << Val;
2843 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2844 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2845 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2846 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2847 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2848 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2849 case options::OPT_fmath_errno: MathErrno =
true;
break;
2850 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2851 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2852 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2853 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2854 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2855 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2856 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2857 case options::OPT_ftrapping_math:
2858 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2859 !FPExceptionBehavior.equals(
"strict"))
2861 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2862 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2863 <<
"-ftrapping-math";
2864 TrappingMath =
true;
2865 TrappingMathPresent =
true;
2866 FPExceptionBehavior =
"strict";
2868 case options::OPT_fno_trapping_math:
2869 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2870 !FPExceptionBehavior.equals(
"ignore"))
2872 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2873 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2874 <<
"-fno-trapping-math";
2875 TrappingMath =
false;
2876 TrappingMathPresent =
true;
2877 FPExceptionBehavior =
"ignore";
2880 case options::OPT_frounding_math:
2881 RoundingFPMath =
true;
2882 RoundingMathPresent =
true;
2885 case options::OPT_fno_rounding_math:
2886 RoundingFPMath =
false;
2887 RoundingMathPresent =
false;
2890 case options::OPT_fdenormal_fp_math_EQ:
2891 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
2892 DenormalFP32Math = DenormalFPMath;
2893 if (!DenormalFPMath.isValid()) {
2894 D.
Diag(diag::err_drv_invalid_value)
2895 << A->getAsString(Args) << A->getValue();
2899 case options::OPT_fdenormal_fp_math_f32_EQ:
2900 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
2901 if (!DenormalFP32Math.isValid()) {
2902 D.
Diag(diag::err_drv_invalid_value)
2903 << A->getAsString(Args) << A->getValue();
2908 case options::OPT_ffp_contract: {
2909 StringRef Val = A->getValue();
2910 if (PreciseFPModel) {
2915 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off"))
2918 D.
Diag(diag::err_drv_unsupported_option_argument)
2919 << A->getOption().getName() << Val;
2924 case options::OPT_ffp_model_EQ:
2931 case options::OPT_ffp_exception_behavior_EQ: {
2932 StringRef Val = A->getValue();
2933 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2934 !FPExceptionBehavior.equals(Val))
2936 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2937 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2938 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
2939 TrappingMath = TrappingMathPresent =
false;
2940 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
2941 FPExceptionBehavior = Val;
2942 else if (Val.equals(
"strict")) {
2943 FPExceptionBehavior = Val;
2944 TrappingMath = TrappingMathPresent =
true;
2946 D.
Diag(diag::err_drv_unsupported_option_argument)
2947 << A->getOption().getName() << Val;
2952 case options::OPT_ffp_eval_method_EQ: {
2953 StringRef Val = A->getValue();
2954 if (Val.equals(
"double") || Val.equals(
"extended") ||
2955 Val.equals(
"source"))
2958 D.
Diag(diag::err_drv_unsupported_option_argument)
2959 << A->getOption().getName() << Val;
2963 case options::OPT_ffinite_math_only:
2967 case options::OPT_fno_finite_math_only:
2972 case options::OPT_funsafe_math_optimizations:
2973 AssociativeMath =
true;
2974 ReciprocalMath =
true;
2975 SignedZeros =
false;
2977 TrappingMath =
false;
2978 FPExceptionBehavior =
"";
2980 case options::OPT_fno_unsafe_math_optimizations:
2981 AssociativeMath =
false;
2982 ReciprocalMath =
false;
2985 TrappingMath =
true;
2986 FPExceptionBehavior =
"strict";
2989 DenormalFPMath = llvm::DenormalMode::getIEEE();
2990 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2993 case options::OPT_Ofast:
2998 case options::OPT_ffast_math:
3002 AssociativeMath =
true;
3003 ReciprocalMath =
true;
3005 SignedZeros =
false;
3006 TrappingMath =
false;
3007 RoundingFPMath =
false;
3009 FPContract =
"fast";
3011 case options::OPT_fno_fast_math:
3018 AssociativeMath =
false;
3019 ReciprocalMath =
false;
3023 DenormalFPMath = DefaultDenormalFPMath;
3024 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3027 if (FPContract ==
"fast") {
3029 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3030 <<
"-ffp-contract=fast"
3031 <<
"-ffp-contract=on";
3035 if (StrictFPModel) {
3038 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3039 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3040 DenormalFPMath == llvm::DenormalMode::getIEEE() &&
3041 DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
3042 FPContract.equals(
"off"))
3046 StrictFPModel =
false;
3048 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3049 <<
"-ffp-model=strict" <<
3050 ((A->getNumValues() == 0) ? A->getSpelling()
3051 : Args.MakeArgString(A->getSpelling() + A->getValue()));
3060 CmdArgs.push_back(
"-menable-no-infs");
3063 CmdArgs.push_back(
"-menable-no-nans");
3066 CmdArgs.push_back(
"-fapprox-func");
3069 CmdArgs.push_back(
"-fmath-errno");
3071 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3072 ApproxFunc && !TrappingMath)
3073 CmdArgs.push_back(
"-menable-unsafe-fp-math");
3076 CmdArgs.push_back(
"-fno-signed-zeros");
3078 if (AssociativeMath && !SignedZeros && !TrappingMath)
3079 CmdArgs.push_back(
"-mreassociate");
3082 CmdArgs.push_back(
"-freciprocal-math");
3086 assert(FPExceptionBehavior.equals(
"strict"));
3090 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3092 llvm::raw_svector_ostream ArgStr(DenormFlag);
3093 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3094 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3098 if (DenormalFP32Math != DenormalFPMath) {
3100 llvm::raw_svector_ostream ArgStr(DenormFlag);
3101 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3102 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3105 if (!FPContract.empty())
3106 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3108 if (!RoundingFPMath)
3109 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3111 if (RoundingFPMath && RoundingMathPresent)
3112 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3114 if (!FPExceptionBehavior.empty())
3115 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3116 FPExceptionBehavior));
3118 if (!FPEvalMethod.empty())
3119 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3126 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3127 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3128 CmdArgs.push_back(
"-ffast-math");
3129 if (FPModel.equals(
"fast")) {
3130 if (FPContract.equals(
"fast"))
3133 else if (FPContract.empty())
3135 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3137 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3138 <<
"-ffp-model=fast"
3139 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3144 if (!HonorINFs && !HonorNaNs)
3145 CmdArgs.push_back(
"-ffinite-math-only");
3147 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3148 CmdArgs.push_back(
"-mfpmath");
3149 CmdArgs.push_back(A->getValue());
3153 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3154 options::OPT_fstrict_float_cast_overflow,
false))
3155 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3159 const llvm::Triple &Triple,
3162 CmdArgs.push_back(
"-analyzer-store=region");
3165 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
3168 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3169 CmdArgs.push_back(
"-analyzer-checker=core");
3170 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3172 if (!Triple.isWindowsMSVCEnvironment()) {
3173 CmdArgs.push_back(
"-analyzer-checker=unix");
3176 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3177 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3178 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3179 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3180 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3181 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3185 if (Triple.isPS()) {
3186 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3187 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3190 if (Triple.isOSDarwin()) {
3191 CmdArgs.push_back(
"-analyzer-checker=osx");
3193 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3195 else if (Triple.isOSFuchsia())
3196 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3198 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3201 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3203 if (!Triple.isPS()) {
3204 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3205 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3206 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3207 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3208 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3209 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3213 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3214 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3218 CmdArgs.push_back(
"-analyzer-output");
3219 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3220 CmdArgs.push_back(A->getValue());
3222 CmdArgs.push_back(
"plist");
3227 CmdArgs.push_back(
"-w");
3230 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3234 const ArgList &Args, ArgStringList &CmdArgs,
3235 bool KernelOrKext) {
3240 if (EffectiveTriple.isNVPTX())
3248 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3249 options::OPT_fstack_protector_all,
3250 options::OPT_fstack_protector_strong,
3251 options::OPT_fstack_protector)) {
3252 if (A->getOption().matches(options::OPT_fstack_protector))
3253 StackProtectorLevel =
3255 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3257 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3260 StackProtectorLevel = DefaultStackProtectorLevel;
3263 if (StackProtectorLevel) {
3264 CmdArgs.push_back(
"-stack-protector");
3265 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3269 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3270 StringRef Str(A->getValue());
3271 if (Str.startswith(
"ssp-buffer-size=")) {
3272 if (StackProtectorLevel) {
3273 CmdArgs.push_back(
"-stack-protector-buffer-size");
3275 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3281 const std::string &TripleStr = EffectiveTriple.getTriple();
3282 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3283 StringRef
Value = A->getValue();
3284 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3285 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3286 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3287 << A->getAsString(Args) << TripleStr;
3288 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3289 EffectiveTriple.isThumb()) &&
3291 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3292 << A->getOption().getName() <<
Value <<
"tls global";
3295 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3297 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3298 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3299 << A->getAsString(Args);
3304 D.
Diag(diag::err_target_unsupported_tp_hard)
3305 << EffectiveTriple.getArchName();
3309 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3310 StringRef
Value = A->getValue();
3311 if (
Value !=
"cp15") {
3312 D.
Diag(diag::err_drv_argument_not_allowed_with)
3313 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3317 CmdArgs.push_back(
"-target-feature");
3318 CmdArgs.push_back(
"+read-tp-hard");
3320 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3321 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3322 << A->getOption().getName() <<
Value <<
"sysreg global";
3325 A->render(Args, CmdArgs);
3328 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3329 StringRef
Value = A->getValue();
3330 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3331 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3332 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3333 << A->getAsString(Args) << TripleStr;
3336 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3339 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3340 (Offset < 0 || Offset > 0xfffff)) {
3341 D.
Diag(diag::err_drv_invalid_int_value)
3342 << A->getOption().getName() <<
Value;
3345 A->render(Args, CmdArgs);
3348 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3349 StringRef
Value = A->getValue();
3350 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3351 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3352 << A->getAsString(Args) << TripleStr;
3353 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3354 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3355 << A->getOption().getName() <<
Value <<
"fs gs";
3358 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3359 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3362 A->render(Args, CmdArgs);
3367 ArgStringList &CmdArgs) {
3370 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3373 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3374 !EffectiveTriple.isPPC64())
3377 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3378 options::OPT_fno_stack_clash_protection);
3383 const ArgList &Args,
3384 ArgStringList &CmdArgs) {
3386 StringRef TrivialAutoVarInit =
"";
3388 for (
const Arg *A : Args) {
3389 switch (A->getOption().getID()) {
3392 case options::OPT_ftrivial_auto_var_init: {
3394 StringRef Val = A->getValue();
3395 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3396 TrivialAutoVarInit = Val;
3398 D.
Diag(diag::err_drv_unsupported_option_argument)
3399 << A->getOption().getName() << Val;
3405 if (TrivialAutoVarInit.empty())
3406 switch (DefaultTrivialAutoVarInit) {
3410 TrivialAutoVarInit =
"pattern";
3413 TrivialAutoVarInit =
"zero";
3417 if (!TrivialAutoVarInit.empty()) {
3418 if (TrivialAutoVarInit ==
"zero" && !Args.hasArg(options::OPT_enable_trivial_var_init_zero))
3419 D.
Diag(diag::err_drv_trivial_auto_var_init_zero_disabled);
3421 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3425 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3426 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3428 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3430 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3432 StringRef Val = A->getValue();
3433 if (std::stoi(Val.str()) <= 0)
3434 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3436 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3444 const unsigned ForwardedArguments[] = {
3445 options::OPT_cl_opt_disable,
3446 options::OPT_cl_strict_aliasing,
3447 options::OPT_cl_single_precision_constant,
3448 options::OPT_cl_finite_math_only,
3449 options::OPT_cl_kernel_arg_info,
3450 options::OPT_cl_unsafe_math_optimizations,
3451 options::OPT_cl_fast_relaxed_math,
3452 options::OPT_cl_mad_enable,
3453 options::OPT_cl_no_signed_zeros,
3454 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3455 options::OPT_cl_uniform_work_group_size
3458 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3460 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3463 for (
const auto &Arg : ForwardedArguments)
3464 if (
const auto *A = Args.getLastArg(Arg))
3465 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3470 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3471 CmdArgs.push_back(
"-finclude-default-header");
3472 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3478 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3479 options::OPT_S, options::OPT_emit_llvm,
3480 options::OPT_disable_llvm_passes};
3482 for (
const auto &Arg : ForwardedArguments)
3483 if (
const auto *A = Args.getLastArg(Arg))
3484 A->renderAsInput(Args, CmdArgs);
3488 ArgStringList &CmdArgs) {
3489 bool ARCMTEnabled =
false;
3490 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3491 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3492 options::OPT_ccc_arcmt_modify,
3493 options::OPT_ccc_arcmt_migrate)) {
3494 ARCMTEnabled =
true;
3495 switch (A->getOption().getID()) {
3496 default: llvm_unreachable(
"missed a case");
3497 case options::OPT_ccc_arcmt_check:
3498 CmdArgs.push_back(
"-arcmt-action=check");
3500 case options::OPT_ccc_arcmt_modify:
3501 CmdArgs.push_back(
"-arcmt-action=modify");
3503 case options::OPT_ccc_arcmt_migrate:
3504 CmdArgs.push_back(
"-arcmt-action=migrate");
3505 CmdArgs.push_back(
"-mt-migrate-directory");
3506 CmdArgs.push_back(A->getValue());
3508 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3509 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3514 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3515 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3516 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3519 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3521 D.
Diag(diag::err_drv_argument_not_allowed_with)
3522 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3524 CmdArgs.push_back(
"-mt-migrate-directory");
3525 CmdArgs.push_back(A->getValue());
3527 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3528 options::OPT_objcmt_migrate_subscripting,
3529 options::OPT_objcmt_migrate_property)) {
3531 CmdArgs.push_back(
"-objcmt-migrate-literals");
3532 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3533 CmdArgs.push_back(
"-objcmt-migrate-property");
3535 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3536 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3537 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3540 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3541 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3542 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3543 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3544 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3545 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3546 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3547 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3548 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3549 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3550 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3551 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3552 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3553 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3554 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3555 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3560 const ArgList &Args, ArgStringList &CmdArgs) {
3563 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3564 !Args.hasArg(options::OPT_mkernel));
3566 CmdArgs.push_back(
"-fno-builtin");
3569 if (Args.hasArg(options::OPT_ffreestanding))
3570 UseBuiltins =
false;
3573 for (
const auto &Arg : Args) {
3574 const Option &O = Arg->getOption();
3575 if (!O.matches(options::OPT_fno_builtin_))
3585 StringRef FuncName = Arg->getValue();
3586 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
3592 if (TC.
getArch() == llvm::Triple::le32)
3593 CmdArgs.push_back(
"-fno-math-builtin");
3597 if (llvm::sys::path::cache_directory(Result)) {
3598 llvm::sys::path::append(Result,
"clang");
3599 llvm::sys::path::append(Result,
"ModuleCache");
3606 const ArgList &Args,
const InputInfo &Input,
3608 ArgStringList &CmdArgs,
bool &HaveModules) {
3612 bool HaveClangModules =
false;
3613 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3614 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3615 options::OPT_fno_cxx_modules,
true);
3617 CmdArgs.push_back(
"-fmodules");
3618 HaveClangModules =
true;
3622 HaveModules |= HaveClangModules;
3623 if (Args.hasArg(options::OPT_fmodules_ts)) {
3624 CmdArgs.push_back(
"-fmodules-ts");
3630 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3631 options::OPT_fno_implicit_module_maps, HaveClangModules))
3632 CmdArgs.push_back(
"-fimplicit-module-maps");
3635 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3636 options::OPT_fno_modules_decluse);
3640 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3641 options::OPT_fno_modules_strict_decluse,
false))
3642 CmdArgs.push_back(
"-fmodules-strict-decluse");
3645 bool ImplicitModules =
false;
3646 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3647 options::OPT_fno_implicit_modules, HaveClangModules)) {
3649 CmdArgs.push_back(
"-fno-implicit-modules");
3650 }
else if (HaveModules) {
3651 ImplicitModules =
true;
3655 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3656 Path = A->getValue();
3658 bool HasPath =
true;
3659 if (C.isForDiagnostics()) {
3663 llvm::sys::path::replace_extension(Path,
".cache");
3664 llvm::sys::path::append(Path,
"modules");
3665 }
else if (Path.empty()) {
3673 const char Arg[] =
"-fmodules-cache-path=";
3674 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3675 CmdArgs.push_back(Args.MakeArgString(Path));
3681 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3682 CmdArgs.push_back(Args.MakeArgString(
3683 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3686 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3687 options::OPT_fno_prebuilt_implicit_modules,
false))
3688 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3689 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3690 options::OPT_fno_modules_validate_input_files_content,
3692 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3697 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3701 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3705 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3707 llvm::sys::path::append(BuiltinModuleMap,
"include");
3708 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3709 if (llvm::sys::fs::exists(BuiltinModuleMap))
3711 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3719 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3721 Args.ClaimAllArgs(options::OPT_fmodule_file);
3725 if (HaveClangModules && C.isForDiagnostics()) {
3727 llvm::sys::path::replace_extension(VFSDir,
".cache");
3729 C.addTempFile(Args.MakeArgString(VFSDir));
3731 llvm::sys::path::append(VFSDir,
"vfs");
3732 CmdArgs.push_back(
"-module-dependency-dir");
3733 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3736 if (HaveClangModules)
3737 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3740 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3741 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3742 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3744 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3746 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3747 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3748 D.
Diag(diag::err_drv_argument_not_allowed_with)
3749 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3751 llvm::sys::fs::file_status Status;
3752 if (llvm::sys::fs::status(A->getValue(), Status))
3753 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3754 CmdArgs.push_back(Args.MakeArgString(
3755 "-fbuild-session-timestamp=" +
3756 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3757 Status.getLastModificationTime().time_since_epoch())
3761 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3762 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3763 options::OPT_fbuild_session_file))
3764 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3766 Args.AddLastArg(CmdArgs,
3767 options::OPT_fmodules_validate_once_per_build_session);
3770 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
3771 options::OPT_fno_modules_validate_system_headers,
3773 CmdArgs.push_back(
"-fmodules-validate-system-headers");
3775 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
3779 ArgStringList &CmdArgs) {
3781 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
3782 options::OPT_fno_signed_char,
3783 options::OPT_funsigned_char,
3784 options::OPT_fno_unsigned_char)) {
3785 if (A->getOption().matches(options::OPT_funsigned_char) ||
3786 A->getOption().matches(options::OPT_fno_signed_char)) {
3787 CmdArgs.push_back(
"-fno-signed-char");
3790 CmdArgs.push_back(
"-fno-signed-char");
3794 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
3796 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3797 options::OPT_fno_short_wchar)) {
3798 if (A->getOption().matches(options::OPT_fshort_wchar)) {
3799 CmdArgs.push_back(
"-fwchar-type=short");
3800 CmdArgs.push_back(
"-fno-signed-wchar");
3802 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
3803 CmdArgs.push_back(
"-fwchar-type=int");
3805 (IsARM && !(T.isOSWindows() || T.isOSNetBSD() || T.isOSOpenBSD())))
3806 CmdArgs.push_back(
"-fno-signed-wchar");
3808 CmdArgs.push_back(
"-fsigned-wchar");
3814 const llvm::Triple &T,
const ArgList &Args,
3816 const InputInfo &Input, ArgStringList &CmdArgs) {
3817 const llvm::Triple::ArchType Arch = TC.
getArch();
3823 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3824 options::OPT_fno_objc_legacy_dispatch,
3827 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
3829 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
3835 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
3837 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
3844 CmdArgs.push_back(
"-fobjc-arc");
3851 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
3853 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
3858 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3859 options::OPT_fno_objc_arc_exceptions,
3861 CmdArgs.push_back(
"-fobjc-arc-exceptions");
3866 if (Args.hasArg(options::OPT_fno_objc_arc)) {
3867 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
3868 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
3874 auto *Arg = Args.getLastArg(
3875 options::OPT_fobjc_convert_messages_to_runtime_calls,
3876 options::OPT_fno_objc_convert_messages_to_runtime_calls);
3878 Arg->getOption().matches(
3879 options::OPT_fno_objc_convert_messages_to_runtime_calls))
3880 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
3885 if (InferCovariantReturns)
3886 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
3891 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
3895 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
3896 D.
Diag(diag::err_objc_weak_unsupported);
3898 WeakArg->render(Args, CmdArgs);
3902 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
3903 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
3907 ArgStringList &CmdArgs) {
3908 bool CaretDefault =
true;
3909 bool ColumnDefault =
true;
3911 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
3912 options::OPT__SLASH_diagnostics_column,
3913 options::OPT__SLASH_diagnostics_caret)) {
3914 switch (A->getOption().getID()) {
3915 case options::OPT__SLASH_diagnostics_caret:
3916 CaretDefault =
true;
3917 ColumnDefault =
true;
3919 case options::OPT__SLASH_diagnostics_column:
3920 CaretDefault =
false;
3921 ColumnDefault =
true;
3923 case options::OPT__SLASH_diagnostics_classic:
3924 CaretDefault =
false;
3925 ColumnDefault =
false;
3931 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3932 options::OPT_fno_caret_diagnostics, CaretDefault))
3933 CmdArgs.push_back(
"-fno-caret-diagnostics");
3935 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
3936 options::OPT_fno_diagnostics_fixit_info);
3937 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
3938 options::OPT_fno_diagnostics_show_option);
3941 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3942 CmdArgs.push_back(
"-fdiagnostics-show-category");
3943 CmdArgs.push_back(A->getValue());
3946 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
3947 options::OPT_fno_diagnostics_show_hotness);
3950 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
3952 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
3953 CmdArgs.push_back(Args.MakeArgString(Opt));
3956 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3957 CmdArgs.push_back(
"-fdiagnostics-format");
3958 CmdArgs.push_back(A->getValue());
3961 if (
const Arg *A = Args.getLastArg(
3962 options::OPT_fdiagnostics_show_note_include_stack,
3963 options::OPT_fno_diagnostics_show_note_include_stack)) {
3964 const Option &O = A->getOption();
3965 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
3966 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
3968 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
3975 Args.getLastArg(options::OPT_fcolor_diagnostics,
3976 options::OPT_fno_color_diagnostics);
3977 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
3978 StringRef
Value(A->getValue());
3980 D.
Diag(diag::err_drv_invalid_argument_to_option)
3981 <<
Value << A->getOption().getName();
3985 CmdArgs.push_back(
"-fcolor-diagnostics");
3987 if (Args.hasArg(options::OPT_fansi_escape_codes))
3988 CmdArgs.push_back(
"-fansi-escape-codes");
3990 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
3991 options::OPT_fno_show_source_location);
3993 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
3994 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
3996 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
3998 CmdArgs.push_back(
"-fno-show-column");
4000 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4001 options::OPT_fno_spell_checking);
4007 const ArgList &Args, Arg *&Arg) {
4008 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4009 options::OPT_gno_split_dwarf);
4010 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4013 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4016 StringRef
Value = Arg->getValue();
4017 if (
Value ==
"split")
4019 if (
Value ==
"single")
4022 D.
Diag(diag::err_drv_unsupported_option_argument)
4023 << Arg->getOption().getName() << Arg->getValue();
4028 const ArgList &Args, ArgStringList &CmdArgs,
4029 unsigned DwarfVersion) {
4030 auto *DwarfFormatArg =
4031 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4032 if (!DwarfFormatArg)
4035 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4036 if (DwarfVersion < 3)
4037 D.
Diag(diag::err_drv_argument_only_allowed_with)
4038 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4039 else if (!T.isArch64Bit())
4040 D.
Diag(diag::err_drv_argument_only_allowed_with)
4041 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4042 else if (!T.isOSBinFormatELF())
4043 D.
Diag(diag::err_drv_argument_only_allowed_with)
4044 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4047 DwarfFormatArg->render(Args, CmdArgs);
4051 const llvm::Triple &T,
const ArgList &Args,
4052 bool EmitCodeView,
bool IRInput,
4053 ArgStringList &CmdArgs,
4056 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4057 options::OPT_fno_debug_info_for_profiling,
false) &&
4059 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4060 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4073 bool SplitDWARFInlining =
4074 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4075 options::OPT_fno_split_dwarf_inlining,
false);
4080 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4086 SplitDWARFInlining =
false;
4089 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4094 A->getOption().matches(options::OPT_gN_Group)) {
4103 SplitDWARFInlining))
4110 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4112 if (A->getOption().matches(options::OPT_glldb))
4113 DebuggerTuning = llvm::DebuggerKind::LLDB;
4114 else if (A->getOption().matches(options::OPT_gsce))
4115 DebuggerTuning = llvm::DebuggerKind::SCE;
4116 else if (A->getOption().matches(options::OPT_gdbx))
4117 DebuggerTuning = llvm::DebuggerKind::DBX;
4119 DebuggerTuning = llvm::DebuggerKind::GDB;
4125 bool EmitDwarf =
false;
4133 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview)) {
4135 EmitCodeView =
true;
4140 if (!EmitCodeView && !EmitDwarf &&
4144 EmitCodeView =
true;
4152 unsigned RequestedDWARFVersion = 0;
4153 unsigned EffectiveDWARFVersion = 0;
4159 assert(RequestedDWARFVersion &&
4160 "toolchain default DWARF version must be nonzero");
4164 if (DefaultDWARFVersion)
4165 RequestedDWARFVersion = DefaultDWARFVersion;
4170 RequestedDWARFVersion = ExplicitVersion;
4172 EffectiveDWARFVersion =
4177 if (RequestedDWARFVersion == 0 &&
4183 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4185 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4186 DebuggerTuning == llvm::DebuggerKind::DBX))
4187 CmdArgs.push_back(
"-gstrict-dwarf");
4190 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4198 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4200 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4202 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4203 DebuggerTuning != llvm::DebuggerKind::DBX)))
4204 CmdArgs.push_back(
"-gno-column-info");
4208 if (
const Arg *A = Args.getLastArg(options::OPT_gmodules))
4213 CmdArgs.push_back(
"-dwarf-ext-refs");
4214 CmdArgs.push_back(
"-fmodule-format=obj");
4218 if (T.isOSBinFormatELF() && SplitDWARFInlining)
4219 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4226 bool NeedFullDebug = Args.hasFlag(
4227 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4228 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4230 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4235 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4236 options::OPT_feliminate_unused_debug_types,
false))
4238 else if (NeedFullDebug)
4242 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4248 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4249 if (RequestedDWARFVersion < 5)
4250 D.
Diag(diag::err_drv_argument_only_allowed_with)
4251 << A->getAsString(Args) <<
"-gdwarf-5";
4252 else if (EffectiveDWARFVersion < 5)
4255 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4257 << EffectiveDWARFVersion;
4259 CmdArgs.push_back(
"-gembed-source");
4263 CmdArgs.push_back(
"-gcodeview");
4266 if (Args.hasFlag(options::OPT_gcodeview_ghash,
4267 options::OPT_gno_codeview_ghash,
false)) {
4268 CmdArgs.push_back(
"-gcodeview-ghash");
4273 if (Args.hasFlag(options::OPT_gno_inline_line_tables,
4274 options::OPT_ginline_line_tables,
false)) {
4275 CmdArgs.push_back(
"-gno-inline-line-tables");
4290 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4294 CmdArgs.push_back(
"-debug-info-macro");
4297 const auto *PubnamesArg =
4298 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4299 options::OPT_gpubnames, options::OPT_gno_pubnames);
4303 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4304 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
4305 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4306 options::OPT_gpubnames)
4308 :
"-ggnu-pubnames");
4309 const auto *SimpleTemplateNamesArg =
4310 Args.getLastArg(options::OPT_gsimple_template_names,
4311 options::OPT_gno_simple_template_names);
4312 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4313 if (SimpleTemplateNamesArg &&
4315 const auto &Opt = SimpleTemplateNamesArg->getOption();
4316 if (Opt.matches(options::OPT_gsimple_template_names)) {
4317 ForwardTemplateParams =
true;
4318 CmdArgs.push_back(
"-gsimple-template-names=simple");
4322 if (Args.hasFlag(options::OPT_fdebug_ranges_base_address,
4323 options::OPT_fno_debug_ranges_base_address,
false)) {
4324 CmdArgs.push_back(
"-fdebug-ranges-base-address");
4330 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4331 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4334 CmdArgs.push_back(
"-mllvm");
4335 CmdArgs.push_back(
"-generate-arange-section");
4338 if (Args.hasFlag(options::OPT_fforce_dwarf_frame,
4339 options::OPT_fno_force_dwarf_frame,
false))
4340 CmdArgs.push_back(
"-fforce-dwarf-frame");
4342 if (Args.hasFlag(options::OPT_fdebug_types_section,
4343 options::OPT_fno_debug_types_section,
false)) {
4344 if (!(T.isOSBinFormatELF() || T.isOSBinFormatWasm())) {
4345 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4346 << Args.getLastArg(options::OPT_fdebug_types_section)
4350 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4352 CmdArgs.push_back(
"-mllvm");
4353 CmdArgs.push_back(
"-generate-type-units");
4360 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4361 options::OPT_fno_dwarf_directory_asm,
4363 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4367 if (ForwardTemplateParams)
4368 CmdArgs.push_back(
"-debug-forward-template-params");
4372 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4373 CmdArgs.push_back(
"-dwarf-explicit-import");
4381 const ArgList &Args,
const char *LinkingOutput)
const {
4382 const auto &TC = getToolChain();
4383 const llvm::Triple &RawTriple = TC.
getTriple();
4385 const std::string &TripleStr = Triple.getTriple();
4388 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4390 ArgStringList CmdArgs;
4392 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4404 bool IsHeaderModulePrecompile = isa<HeaderModulePrecompileJobAction>(JA);
4405 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4408 bool IsHostOffloadingAction =
4410 Args.hasFlag(options::OPT_fopenmp_new_driver,
4411 options::OPT_no_offload_new_driver,
true)) ||
4413 Args.hasFlag(options::OPT_offload_new_driver,
4414 options::OPT_no_offload_new_driver,
false));
4416 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4417 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4421 const char *ModuleName = [&]{
4422 auto *ModuleNameArg = Args.getLastArg(options::OPT_fmodule_name_EQ);
4423 return ModuleNameArg ? ModuleNameArg->getValue() :
"";
4425 InputInfo HeaderModuleInput(Inputs[0].getType(), ModuleName, ModuleName);
4429 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4433 if (IsHeaderModulePrecompile)
4434 return HeaderModuleInput;
4436 return ExtractAPIPlaceholderInput;
4443 const InputInfo *CudaDeviceInput =
nullptr;
4444 const InputInfo *OpenMPDeviceInput =
nullptr;
4448 }
else if (IsHeaderModulePrecompile &&
4452 D.
Diag(diag::err_drv_module_header_wrong_kind)
4456 ModuleHeaderInputs.push_back(I);
4457 }
else if (IsExtractAPI) {
4458 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4459 if (I.getType() != ExpectedInputType) {
4460 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4464 ExtractAPIInputs.push_back(I);
4465 }
else if (IsHostOffloadingAction) {
4466 HostOffloadingInputs.push_back(I);
4467 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4468 CudaDeviceInput = &I;
4469 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4470 OpenMPDeviceInput = &I;
4472 llvm_unreachable(
"unexpectedly given multiple inputs");
4476 const llvm::Triple *AuxTriple =
4478 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4479 bool IsIAMCU = RawTriple.isOSIAMCU();
4484 if (IsCuda || IsHIP)
4485 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4489 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4494 CmdArgs.push_back(
"-cc1");
4497 CmdArgs.push_back(
"-triple");
4498 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4500 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4501 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
4502 Args.ClaimAllArgs(options::OPT_MJ);
4503 }
else if (
const Arg *GenCDBFragment =
4504 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4505 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(), C,
4506 TripleStr, Output, Input, Args);
4507 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4510 if (IsCuda || IsHIP) {
4531 assert(CTC &&
"Expected valid CUDA Toolchain.");
4533 CmdArgs.push_back(Args.MakeArgString(
4534 Twine(
"-target-sdk-version=") +
4538 CmdArgs.push_back(
"-aux-triple");
4539 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4542 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4543 CmdArgs.push_back(
"-fsycl-is-device");
4545 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4546 A->render(Args, CmdArgs);
4549 CmdArgs.push_back(
"-sycl-std=2020");
4553 if (IsOpenMPDevice) {
4559 CmdArgs.push_back(
"-aux-triple");
4560 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4563 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4564 Triple.getArch() == llvm::Triple::thumb)) {
4565 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4566 unsigned Version = 0;
4568 Triple.getArchName().substr(
Offset).consumeInteger(10, Version);
4569 if (Failure || Version < 7)
4570 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4580 if (Triple.isSPIR() || Triple.isSPIRV())
4581 CmdArgs.push_back(
"-Wspir-compat");
4584 RewriteKind rewriteKind = RK_None;
4593 if (!isa<AssembleJobAction>(JA)) {
4597 Args.ClaimAllArgs(options::OPT_mrelax_all);
4598 Args.ClaimAllArgs(options::OPT_mno_relax_all);
4599 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4600 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4601 switch (C.getDefaultToolChain().getArch()) {
4602 case llvm::Triple::arm:
4603 case llvm::Triple::armeb:
4604 case llvm::Triple::thumb:
4605 case llvm::Triple::thumbeb:
4606 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4612 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4613 Args.ClaimAllArgs(options::OPT_Xassembler);
4616 if (isa<AnalyzeJobAction>(JA)) {
4617 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
4618 CmdArgs.push_back(
"-analyze");
4619 }
else if (isa<MigrateJobAction>(JA)) {
4620 CmdArgs.push_back(
"-migrate");
4621 }
else if (isa<PreprocessJobAction>(JA)) {
4622 if (Output.
getType() == types::TY_Dependencies)
4623 CmdArgs.push_back(
"-Eonly");
4625 CmdArgs.push_back(
"-E");
4626 if (Args.hasArg(options::OPT_rewrite_objc) &&
4627 !Args.hasArg(options::OPT_g_Group))
4628 CmdArgs.push_back(
"-P");
4629 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
4630 CmdArgs.push_back(
"-fdirectives-only");
4632 }
else if (isa<AssembleJobAction>(JA)) {
4633 CmdArgs.push_back(
"-emit-obj");
4638 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4639 }
else if (isa<PrecompileJobAction>(JA)) {
4640 if (JA.
getType() == types::TY_Nothing)
4641 CmdArgs.push_back(
"-fsyntax-only");
4642 else if (JA.
getType() == types::TY_ModuleFile)
4643 CmdArgs.push_back(IsHeaderModulePrecompile
4644 ?
"-emit-header-module"
4645 :
"-emit-module-interface");
4646 else if (JA.
getType() == types::TY_HeaderUnit)
4647 CmdArgs.push_back(
"-emit-header-unit");
4649 CmdArgs.push_back(
"-emit-pch");
4650 }
else if (isa<VerifyPCHJobAction>(JA)) {
4651 CmdArgs.push_back(
"-verify-pch");
4652 }
else if (isa<ExtractAPIJobAction>(JA)) {
4653 assert(JA.
getType() == types::TY_API_INFO &&
4654 "Extract API actions must generate a API information.");
4655 CmdArgs.push_back(
"-extract-api");
4656 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
4657 ProductNameArg->render(Args, CmdArgs);
4659 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
4660 "Invalid action for clang tool.");
4661 if (JA.
getType() == types::TY_Nothing) {
4662 CmdArgs.push_back(
"-fsyntax-only");
4663 }
else if (JA.
getType() == types::TY_LLVM_IR ||
4664 JA.
getType() == types::TY_LTO_IR) {
4665 CmdArgs.push_back(
"-emit-llvm");
4666 }
else if (JA.
getType() == types::TY_LLVM_BC ||
4667 JA.
getType() == types::TY_LTO_BC) {
4669 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
4670 Args.hasArg(options::OPT_emit_llvm)) {
4671 CmdArgs.push_back(
"-emit-llvm");
4673 CmdArgs.push_back(
"-emit-llvm-bc");
4675 }
else if (JA.
getType() == types::TY_IFS ||
4676 JA.
getType() == types::TY_IFS_CPP) {
4678 Args.hasArg(options::OPT_interface_stub_version_EQ)
4679 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
4681 CmdArgs.push_back(
"-emit-interface-stubs");
4683 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
4684 }
else if (JA.
getType() == types::TY_PP_Asm) {
4685 CmdArgs.push_back(
"-S");
4686 }
else if (JA.
getType() == types::TY_AST) {
4687 CmdArgs.push_back(
"-emit-pch");
4688 }
else if (JA.
getType() == types::TY_ModuleFile) {
4689 CmdArgs.push_back(
"-module-file-info");
4690 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
4691 CmdArgs.push_back(
"-rewrite-objc");
4692 rewriteKind = RK_NonFragile;
4693 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
4694 CmdArgs.push_back(
"-rewrite-objc");
4695 rewriteKind = RK_Fragile;
4697 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
4704 if (JA.
getType() == types::TY_LLVM_BC)
4705 CmdArgs.push_back(
"-emit-llvm-uselists");
4709 if (IsDeviceOffloadAction &&
4710 !Args.hasFlag(options::OPT_fopenmp_new_driver,
4711 options::OPT_no_offload_new_driver,
true) &&
4712 !Args.hasFlag(options::OPT_offload_new_driver,
4713 options::OPT_no_offload_new_driver,
false) &&
4714 !Triple.isAMDGPU()) {
4715 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4716 << Args.getLastArg(options::OPT_foffload_lto,
4717 options::OPT_foffload_lto_EQ)
4719 << Triple.getTriple();
4722 CmdArgs.push_back(Args.MakeArgString(
4723 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
4724 CmdArgs.push_back(
"-flto-unit");
4729 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
4731 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
4732 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
4735 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
4736 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
4738 if (Args.getLastArg(options::OPT_save_temps_EQ))
4739 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
4741 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
4742 options::OPT_fmemory_profile_EQ,
4743 options::OPT_fno_memory_profile);
4745 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
4746 MemProfArg->render(Args, CmdArgs);
4750 if (C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
4751 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
4753 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
4755 CmdArgs.push_back(
"-disable-llvm-passes");
4762 static const constexpr
unsigned kBitcodeOptionIgnorelist[] = {
4763 options::OPT_mkernel,
4764 options::OPT_fapple_kext,
4765 options::OPT_ffunction_sections,
4766 options::OPT_fno_function_sections,
4767 options::OPT_fdata_sections,
4768 options::OPT_fno_data_sections,
4769 options::OPT_fbasic_block_sections_EQ,
4770 options::OPT_funique_internal_linkage_names,
4771 options::OPT_fno_unique_internal_linkage_names,
4772 options::OPT_funique_section_names,
4773 options::OPT_fno_unique_section_names,
4774 options::OPT_funique_basic_block_section_names,
4775 options::OPT_fno_unique_basic_block_section_names,
4776 options::OPT_mrestrict_it,
4777 options::OPT_mno_restrict_it,
4778 options::OPT_mstackrealign,
4779 options::OPT_mno_stackrealign,
4780 options::OPT_mstack_alignment,
4781 options::OPT_mcmodel_EQ,
4782 options::OPT_mlong_calls,
4783 options::OPT_mno_long_calls,
4784 options::OPT_ggnu_pubnames,
4785 options::OPT_gdwarf_aranges,
4786 options::OPT_fdebug_types_section,
4787 options::OPT_fno_debug_types_section,
4788 options::OPT_fdwarf_directory_asm,
4789 options::OPT_fno_dwarf_directory_asm,
4790 options::OPT_mrelax_all,
4791 options::OPT_mno_relax_all,
4792 options::OPT_ftrap_function_EQ,
4793 options::OPT_ffixed_r9,
4794 options::OPT_mfix_cortex_a53_835769,
4795 options::OPT_mno_fix_cortex_a53_835769,
4796 options::OPT_ffixed_x18,
4797 options::OPT_mglobal_merge,
4798 options::OPT_mno_global_merge,
4799 options::OPT_mred_zone,
4800 options::OPT_mno_red_zone,
4801 options::OPT_Wa_COMMA,
4802 options::OPT_Xassembler,
4805 for (
const auto &A : Args)
4806 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
4807 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
4810 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
4811 options::OPT_fno_optimize_sibling_calls);
4819 case llvm::Triple::arm:
4820 case llvm::Triple::armeb:
4821 case llvm::Triple::thumbeb:
4822 RenderARMABI(D, Triple, Args, CmdArgs);
4824 case llvm::Triple::aarch64:
4825 case llvm::Triple::aarch64_32:
4826 case llvm::Triple::aarch64_be:
4827 RenderAArch64ABI(Triple, Args, CmdArgs);
4832 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4833 if (A->getOption().matches(options::OPT_O4)) {
4834 CmdArgs.push_back(
"-O3");
4835 D.
Diag(diag::warn_O4_is_O3);
4837 A->render(Args, CmdArgs);
4842 if (Output.
getType() == types::TY_Dependencies) {
4845 CmdArgs.push_back(
"-o");
4848 assert(Output.
isNothing() &&
"Input output.");
4851 for (
const auto &II : Inputs) {
4853 if (II.isFilename())
4854 CmdArgs.push_back(II.getFilename());
4856 II.getInputArg().renderAsInput(Args, CmdArgs);
4859 C.addCommand(std::make_unique<Command>(
4861 CmdArgs, Inputs, Output));
4865 if (C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
4866 CmdArgs.push_back(
"-fembed-bitcode=marker");
4871 if (!C.isForDiagnostics())
4872 CmdArgs.push_back(
"-disable-free");
4873 CmdArgs.push_back(
"-clear-ast-before-backend");
4876 const bool IsAssertBuild =
false;
4878 const bool IsAssertBuild =
true;
4883 CmdArgs.push_back(
"-disable-llvm-verifier");
4886 if (Args.hasFlag(options::OPT_fdiscard_value_names,
4887 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
4888 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
4890 return types::isLLVMIR(II.getType());
4892 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
4894 CmdArgs.push_back(
"-discard-value-names");
4899 CmdArgs.push_back(
"-main-file-name");
4900 CmdArgs.push_back(getBaseInputName(Args, Input));
4904 if (Args.hasArg(options::OPT_static))
4905 CmdArgs.push_back(
"-static-define");
4907 if (Args.hasArg(options::OPT_municode))
4908 CmdArgs.push_back(
"-DUNICODE");
4910 if (isa<AnalyzeJobAction>(JA))
4913 if (isa<AnalyzeJobAction>(JA) ||
4914 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
4915 CmdArgs.push_back(
"-setup-static-analyzer");
4920 bool FoundAnalyzerConfig =
false;
4921 for (
auto Arg : Args.filtered(options::OPT_Xclang))
4922 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
4923 FoundAnalyzerConfig =
true;
4926 if (!FoundAnalyzerConfig)
4927 for (
auto Arg : Args.filtered(options::OPT_Xanalyzer))
4928 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
4929 FoundAnalyzerConfig =
true;
4932 if (FoundAnalyzerConfig)
4933 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
4938 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
4939 if (FunctionAlignment) {
4940 CmdArgs.push_back(
"-function-alignment");
4941 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
4946 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
4948 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
4950 << A->getAsString(Args) << A->getValue();
4952 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
4953 << A->getAsString(Args) << A->getValue();
4956 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
4960 llvm::Reloc::Model RelocationModel;
4963 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
4965 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
4966 RelocationModel == llvm::Reloc::ROPI_RWPI;
4967 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
4968 RelocationModel == llvm::Reloc::ROPI_RWPI;
4970 if (Args.hasArg(options::OPT_mcmse) &&
4971 !Args.hasArg(options::OPT_fallow_unsupported)) {
4973 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
4975 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
4979 !Args.hasArg(options::OPT_fallow_unsupported))
4980 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
4984 CmdArgs.push_back(
"-mrelocation-model");
4985 CmdArgs.push_back(RMName);
4988 CmdArgs.push_back(
"-pic-level");
4989 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
4991 CmdArgs.push_back(
"-pic-is-pie");
4994 if (RelocationModel == llvm::Reloc::ROPI ||
4995 RelocationModel == llvm::Reloc::ROPI_RWPI)
4996 CmdArgs.push_back(
"-fropi");
4997 if (RelocationModel == llvm::Reloc::RWPI ||
4998 RelocationModel == llvm::Reloc::ROPI_RWPI)
4999 CmdArgs.push_back(
"-frwpi");
5001 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5002 CmdArgs.push_back(
"-meabi");
5003 CmdArgs.push_back(A->getValue());
5017 if (Triple.isOSBinFormatELF()) {
5018 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5019 options::OPT_fno_semantic_interposition);
5020 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5022 bool SupportsLocalAlias =
5023 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5025 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5026 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5027 A->render(Args, CmdArgs);
5028 else if (!SupportsLocalAlias)
5029 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5035 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5037 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5038 << A->getValue() << A->getAsString(Args);
5039 Model = A->getValue();
5042 if (Model !=
"posix") {
5043 CmdArgs.push_back(
"-mthread-model");
5044 CmdArgs.push_back(Args.MakeArgString(Model));
5048 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
5050 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5051 options::OPT_fno_merge_all_constants,
false))
5052 CmdArgs.push_back(
"-fmerge-all-constants");
5054 if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks,
5055 options::OPT_fdelete_null_pointer_checks,
false))
5056 CmdArgs.push_back(
"-fno-delete-null-pointer-checks");
5060 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file_EQ)) {
5061 StringRef Map = A->getValue();
5062 if (!llvm::sys::fs::exists(Map)) {
5063 D.
Diag(diag::err_drv_no_such_file) << Map;
5065 A->render(Args, CmdArgs);
5070 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_vec_extabi,
5071 options::OPT_mabi_EQ_vec_default)) {
5072 if (!Triple.isOSAIX())
5073 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5074 << A->getSpelling() << RawTriple.str();
5075 if (A->getOption().getID() == options::OPT_mabi_EQ_vec_extabi)
5076 CmdArgs.push_back(
"-mabi=vec-extabi");
5078 CmdArgs.push_back(
"-mabi=vec-default");
5081 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5084 if (Triple.isOSAIX())
5085 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5086 << A->getSpelling() << RawTriple.str();
5089 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5090 StringRef
v = A->getValue();
5094 D.
Diag(diag::err_drv_missing_argument) << A->getSpelling() << 1;
5096 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
v));
5100 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5101 options::OPT_fno_jump_tables);
5102 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5103 options::OPT_fno_profile_sample_accurate);
5104 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5105 options::OPT_fno_preserve_as_comments);
5107 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5108 CmdArgs.push_back(
"-mregparm");
5109 CmdArgs.push_back(A->getValue());
5112 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5113 options::OPT_msvr4_struct_return)) {
5115 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5116 << A->getSpelling() << RawTriple.str();
5117 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5118 CmdArgs.push_back(
"-maix-struct-return");
5120 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5121 CmdArgs.push_back(
"-msvr4-struct-return");
5125 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5126 options::OPT_freg_struct_return)) {
5127 if (TC.
getArch() != llvm::Triple::x86) {
5128 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5129 << A->getSpelling() << RawTriple.str();
5130 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5131 CmdArgs.push_back(
"-fpcc-struct-return");
5133 assert(A->getOption().matches(options::OPT_freg_struct_return));
5134 CmdArgs.push_back(
"-freg-struct-return");
5138 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
5139 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5141 if (Args.hasArg(options::OPT_fenable_matrix)) {
5143 CmdArgs.push_back(
"-fenable-matrix");
5144 CmdArgs.push_back(
"-mllvm");
5145 CmdArgs.push_back(
"-enable-matrix");
5150 const char *FPKeepKindStr =
nullptr;
5151 switch (FPKeepKind) {
5153 FPKeepKindStr =
"-mframe-pointer=none";
5156 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5159 FPKeepKindStr =
"-mframe-pointer=all";
5162 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5163 CmdArgs.push_back(FPKeepKindStr);
5165 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5166 options::OPT_fno_zero_initialized_in_bss);
5171 OptSpecifier StrictAliasingAliasOption =
5172 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5175 bool TBAAOnByDefault = !D.
IsCLMode();
5176 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5177 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5178 CmdArgs.push_back(
"-relaxed-aliasing");
5179 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5180 options::OPT_fno_struct_path_tbaa,
true))
5181 CmdArgs.push_back(
"-no-struct-path-tbaa");
5182 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5183 options::OPT_fno_strict_enums);
5184 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5185 options::OPT_fno_strict_return);
5186 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5187 options::OPT_fno_allow_editor_placeholders);
5188 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5189 options::OPT_fno_strict_vtable_pointers);
5190 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5191 options::OPT_fno_force_emit_vtables);
5192 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5193 options::OPT_fno_optimize_sibling_calls);
5194 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5195 options::OPT_fno_escaping_block_tail_calls);
5197 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5198 options::OPT_fno_fine_grained_bitfield_accesses);
5200 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5201 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5204 if (Args.hasFlag(options::OPT_fsplit_stack, options::OPT_fno_split_stack,
5206 CmdArgs.push_back(
"-fsplit-stack");
5209 if (Args.hasFlag(options::OPT_fprotect_parens,
5210 options::OPT_fno_protect_parens,
false))
5211 CmdArgs.push_back(
"-fprotect-parens");
5215 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5216 const llvm::Triple::ArchType Arch = TC.
getArch();
5217 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5218 StringRef
V = A->getValue();
5220 CmdArgs.push_back(
"-fextend-arguments=64");
5222 D.
Diag(diag::err_drv_invalid_argument_to_option)
5223 << A->getValue() << A->getOption().getName();
5225 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5226 << A->getOption().getName() << TripleStr;
5229 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5230 if (TC.
getArch() == llvm::Triple::avr)
5231 A->render(Args, CmdArgs);
5233 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5234 << A->getAsString(Args) << TripleStr;
5237 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5239 A->render(Args, CmdArgs);
5241 (A->getOption().getID() != options::OPT_mlong_double_80))
5242 A->render(Args, CmdArgs);
5244 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5245 << A->getAsString(Args) << TripleStr;
5251 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5252 IsIntegratedAssemblerDefault))
5253 CmdArgs.push_back(
"-fno-verbose-asm");
5257 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5258 StringRef
V = A->getValue();
5261 A->render(Args, CmdArgs);
5262 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5263 (
V.empty() || (
V.consume_front(
".") &&
5264 !
V.consumeInteger(10, Num) &&
V.empty())))
5265 A->render(Args, CmdArgs);
5267 D.
Diag(diag::err_drv_invalid_argument_to_option)
5268 << A->getValue() << A->getOption().getName();
5274 CmdArgs.push_back(
"-no-integrated-as");
5276 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5277 CmdArgs.push_back(
"-mdebug-pass");
5278 CmdArgs.push_back(
"Structure");
5280 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5281 CmdArgs.push_back(
"-mdebug-pass");
5282 CmdArgs.push_back(
"Arguments");
5288 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5289 CmdArgs.push_back(
"-mconstructor-aliases");
5293 if (KernelOrKext && RawTriple.isOSDarwin())
5294 CmdArgs.push_back(
"-fforbid-guard-variables");
5296 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5297 Triple.isWindowsGNUEnvironment())) {
5298 CmdArgs.push_back(
"-mms-bitfields");
5304 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5305 options::OPT_fno_direct_access_external_data))
5306 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5308 A->render(Args, CmdArgs);
5310 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5311 CmdArgs.push_back(
"-fno-plt");
5318 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5321 CmdArgs.push_back(
"-ffreestanding");
5323 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5329 bool AsyncUnwindTables = Args.hasFlag(
5330 options::OPT_fasynchronous_unwind_tables,
5331 options::OPT_fno_asynchronous_unwind_tables,
5334 bool UnwindTables = Args.hasFlag(options::OPT_funwind_tables,
5335 options::OPT_fno_unwind_tables,
false);
5336 if (AsyncUnwindTables)
5337 CmdArgs.push_back(
"-funwind-tables=2");
5338 else if (UnwindTables)
5339 CmdArgs.push_back(
"-funwind-tables=1");
5343 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5344 (IsCudaDevice || IsHIPDevice)) {
5345 const ArgList &HostArgs =
5349 if (!HostCPU.empty()) {
5350 CmdArgs.push_back(
"-aux-target-cpu");
5351 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5360 (void)Args.hasArg(options::OPT_mtune_EQ);
5362 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5363 StringRef CM = A->getValue();
5364 if (CM ==
"small" || CM ==
"kernel" || CM ==
"medium" || CM ==
"large" ||
5366 if (Triple.isOSAIX() && CM ==
"medium")
5367 CmdArgs.push_back(
"-mcmodel=large");
5369 A->render(Args, CmdArgs);
5371 D.
Diag(diag::err_drv_invalid_argument_to_option)
5372 << CM << A->getOption().getName();
5376 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5377 StringRef
Value = A->getValue();
5378 unsigned TLSSize = 0;
5379 Value.getAsInteger(10, TLSSize);
5380 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5381 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5382 << A->getOption().getName() << TripleStr;
5383 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5384 D.
Diag(diag::err_drv_invalid_int_value)
5385 << A->getOption().getName() <<
Value;
5386 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5392 CmdArgs.push_back(
"-target-cpu");
5393 CmdArgs.push_back(Args.MakeArgString(CPU));
5396 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5408 if (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5409 isa<BackendJobAction>(JA)) {
5410 CmdArgs.push_back(
"-mllvm");
5411 CmdArgs.push_back(
"-treat-scalable-fixed-error-as-warning");
5416 bool EmitCodeView =
false;
5421 AddClangCLArgs(Args, InputType, CmdArgs, &
DebugInfoKind, &EmitCodeView);
5429 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
5430 if (TC.
getTriple().isOSBinFormatELF()) {
5432 CmdArgs.push_back(
"-fjmc");
5434 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
5437 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
5446 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5447 isa<BackendJobAction>(JA));
5449 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
5450 CmdArgs.push_back(
"-split-dwarf-file");
5451 CmdArgs.push_back(SplitDWARFOut);
5453 CmdArgs.push_back(
"-split-dwarf-output");
5454 CmdArgs.push_back(SplitDWARFOut);
5459 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5460 CmdArgs.push_back(
"-target-linker-version");
5461 CmdArgs.push_back(A->getValue());
5466 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
5468 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
5469 TC.
getArch() == llvm::Triple::x86) {
5470 if ((
Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
5471 (
Unsupported = Args.getLastArg(options::OPT_mkernel)))
5472 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
5476 if ((
Unsupported = Args.getLastArg(options::OPT_faltivec)))
5477 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5479 <<
"please use -maltivec and include altivec.h explicitly";
5480 if ((
Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
5481 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5482 <<
Unsupported->getOption().getName() <<
"please use -mno-altivec";
5485 Args.AddAllArgs(CmdArgs, options::OPT_v);
5487 if (Args.getLastArg(options::OPT_H)) {
5488 CmdArgs.push_back(
"-H");
5489 CmdArgs.push_back(
"-sys-header-deps");
5491 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
5494 CmdArgs.push_back(
"-header-include-file");
5498 CmdArgs.push_back(
"-sys-header-deps");
5500 Args.AddLastArg(CmdArgs, options::OPT_P);
5501 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
5504 CmdArgs.push_back(
"-diagnostic-log-file");
5513 CmdArgs.push_back(
"-disable-pragma-debug-crash");
5517 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
5518 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
5519 CmdArgs.push_back(
"-mllvm");
5520 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
5525 if (Args.hasFlag(options::OPT_ffunction_sections,
5526 options::OPT_fno_function_sections, UseSeparateSections)) {
5527 CmdArgs.push_back(
"-ffunction-sections");
5530 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
5531 StringRef Val = A->getValue();
5532 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5533 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
5534 !Val.startswith(
"list="))
5535 D.
Diag(diag::err_drv_invalid_value)
5536 << A->getAsString(Args) << A->getValue();
5538 A->render(Args, CmdArgs);
5539 }
else if (Triple.isNVPTX()) {
5542 }
else if (Val !=
"none") {
5545 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5546 << A->getAsString(Args) << TripleStr;
5550 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
5551 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
5552 UseSeparateSections || HasDefaultDataSections)) {
5553 CmdArgs.push_back(
"-fdata-sections");
5556 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
5557 options::OPT_fno_unique_section_names);
5558 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
5559 options::OPT_fno_unique_internal_linkage_names);
5560 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
5561 options::OPT_fno_unique_basic_block_section_names);
5563 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
5564 options::OPT_fno_split_machine_functions)) {
5566 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5567 if (A->getOption().matches(options::OPT_fsplit_machine_functions))
5568 A->render(Args, CmdArgs);
5570 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5571 << A->getAsString(Args) << TripleStr;
5575 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
5576 options::OPT_finstrument_functions_after_inlining,
5577 options::OPT_finstrument_function_entry_bare);
5582 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
5585 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
5588 if (RawTriple.isPS() &&
5589 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
5595 if (Args.hasArg(options::OPT_nostdinc)) {
5596 CmdArgs.push_back(
"-nostdsysteminc");
5597 CmdArgs.push_back(
"-nobuiltininc");
5599 if (Args.hasArg(options::OPT_nostdlibinc))
5600 CmdArgs.push_back(
"-nostdsysteminc");
5601 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
5602 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
5606 CmdArgs.push_back(
"-resource-dir");
5609 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
5618 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
5624 Args.ClaimAllArgs(options::OPT_D);
5627 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5628 if (A->getOption().matches(options::OPT_O4)) {
5629 CmdArgs.push_back(
"-O3");
5630 D.
Diag(diag::warn_O4_is_O3);
5632 A->render(Args, CmdArgs);
5638 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
5639 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
5644 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
5645 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
5651 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
5654 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
5656 if (A->getOption().getID() == options::OPT__SLASH_wd) {
5657 unsigned WarningNumber;
5658 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
5659 D.
Diag(diag::err_drv_invalid_int_value)
5660 << A->getAsString(Args) << A->getValue();
5665 CmdArgs.push_back(Args.MakeArgString(
5670 A->render(Args, CmdArgs);
5673 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
5674 CmdArgs.push_back(
"-pedantic");
5675 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
5676 Args.AddLastArg(CmdArgs, options::OPT_w);
5679 if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
5681 Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
5683 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
5684 A->render(Args, CmdArgs);
5686 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5687 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5689 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
5690 A->render(Args, CmdArgs);
5697 bool ImplyVCPPCVer =
false;
5698 bool ImplyVCPPCXXVer =
false;
5699 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
5701 if (
Std->getOption().matches(options::OPT_ansi))
5703 CmdArgs.push_back(
"-std=c++98");
5705 CmdArgs.push_back(
"-std=c89");
5707 Std->render(Args, CmdArgs);
5710 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
5711 options::OPT_ftrigraphs,
5712 options::OPT_fno_trigraphs))
5714 A->render(Args, CmdArgs);
5723 if (!Args.hasArg(options::OPT__SLASH_std)) {
5724 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
5727 ImplyVCPPCVer =
true;
5729 else if (IsWindowsMSVC)
5730 ImplyVCPPCXXVer =
true;
5732 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
5733 options::OPT_fno_trigraphs);
5738 CmdArgs.push_back(IsWindowsMSVC ?
"-std=c++14" :
"-std=c++11");
5754 Args.getLastArg(options::OPT_Wwrite_strings,
5755 options::OPT_Wno_write_strings, options::OPT_w);
5757 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
5758 CmdArgs.push_back(
"-fconst-strings");
5765 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
5767 CmdArgs.push_back(
"-fdeprecated-macro");
5771 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
5772 if (
Asm->getOption().matches(options::OPT_fasm))
5773 CmdArgs.push_back(
"-fgnu-keywords");
5775 CmdArgs.push_back(
"-fno-gnu-keywords");
5779 CmdArgs.push_back(
"-fno-autolink");
5782 const char *DebugCompilationDir =
5787 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
5788 options::OPT_ftemplate_depth_EQ)) {
5789 CmdArgs.push_back(
"-ftemplate-depth");
5790 CmdArgs.push_back(A->getValue());
5793 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
5794 CmdArgs.push_back(
"-foperator-arrow-depth");
5795 CmdArgs.push_back(A->getValue());
5798 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
5799 CmdArgs.push_back(
"-fconstexpr-depth");
5800 CmdArgs.push_back(A->getValue());
5803 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
5804 CmdArgs.push_back(
"-fconstexpr-steps");
5805 CmdArgs.push_back(A->getValue());
5808 if (Args.hasArg(options::OPT_funstable)) {
5809 CmdArgs.push_back(
"-funstable");
5810 if (!Args.hasArg(options::OPT_fno_coroutines_ts))
5811 CmdArgs.push_back(
"-fcoroutines-ts");
5812 CmdArgs.push_back(
"-fmodules-ts");
5815 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
5816 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
5818 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
5819 CmdArgs.push_back(
"-fbracket-depth");
5820 CmdArgs.push_back(A->getValue());
5823 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
5824 options::OPT_Wlarge_by_value_copy_def)) {
5825 if (A->getNumValues()) {
5826 StringRef
bytes = A->getValue();
5827 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
5829 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
5832 if (Args.hasArg(options::OPT_relocatable_pch))
5833 CmdArgs.push_back(
"-relocatable-pch");
5835 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
5836 static const char *kCFABIs[] = {
5837 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
5840 if (find(kCFABIs, StringRef(A->getValue())) == std::end(kCFABIs))
5841 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
5843 A->render(Args, CmdArgs);
5846 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
5847 CmdArgs.push_back(
"-fconstant-string-class");
5848 CmdArgs.push_back(A->getValue());
5851 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
5852 CmdArgs.push_back(
"-ftabstop");
5853 CmdArgs.push_back(A->getValue());
5856 if (Args.hasFlag(options::OPT_fstack_size_section,
5857 options::OPT_fno_stack_size_section, RawTriple.isPS4()))
5858 CmdArgs.push_back(
"-fstack-size-section");
5860 if (Args.hasArg(options::OPT_fstack_usage)) {
5861 CmdArgs.push_back(
"-stack-usage-file");
5863 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
5865 llvm::sys::path::replace_extension(OutputFilename,
"su");
5866 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
5869 Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) +
".su"));
5872 CmdArgs.push_back(
"-ferror-limit");
5873 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
5874 CmdArgs.push_back(A->getValue());
5876 CmdArgs.push_back(
"19");
5878 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
5879 CmdArgs.push_back(
"-fmacro-backtrace-limit");
5880 CmdArgs.push_back(A->getValue());
5883 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
5884 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
5885 CmdArgs.push_back(A->getValue());
5888 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
5889 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
5890 CmdArgs.push_back(A->getValue());
5893 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
5894 CmdArgs.push_back(
"-fspell-checking-limit");
5895 CmdArgs.push_back(A->getValue());
5899 unsigned MessageLength = 0;
5900 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
5901 StringRef
V(A->getValue());
5902 if (
V.getAsInteger(0, MessageLength))
5903 D.
Diag(diag::err_drv_invalid_argument_to_option)
5904 <<
V << A->getOption().getName();
5908 MessageLength = llvm::sys::Process::StandardErrColumns();
5910 if (MessageLength != 0)
5912 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
5914 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
5916 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
5918 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
5919 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
5920 Twine(A->getValue(0))));
5923 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
5924 options::OPT_fvisibility_ms_compat)) {
5925 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
5926 CmdArgs.push_back(
"-fvisibility");
5927 CmdArgs.push_back(A->getValue());
5929 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
5930 CmdArgs.push_back(
"-fvisibility");
5931 CmdArgs.push_back(
"hidden");
5932 CmdArgs.push_back(
"-ftype-visibility");
5933 CmdArgs.push_back(
"default");
5935 }
else if (IsOpenMPDevice) {
5939 CmdArgs.push_back(
"-fvisibility");
5940 CmdArgs.push_back(
"protected");
5943 if (!RawTriple.isPS4())
5945 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
5946 options::OPT_fno_visibility_from_dllstorageclass)) {
5947 if (A->getOption().matches(
5948 options::OPT_fvisibility_from_dllstorageclass)) {
5949 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
5950 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
5951 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
5952 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
5953 Args.AddLastArg(CmdArgs,
5954 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
5958 if (
const Arg *A = Args.getLastArg(options::OPT_mignore_xcoff_visibility)) {
5959 if (Triple.isOSAIX())
5960 CmdArgs.push_back(
"-mignore-xcoff-visibility");
5962 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5963 << A->getAsString(Args) << TripleStr;
5967 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
5968 options::OPT_fno_visibility_inlines_hidden,
false))
5969 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
5971 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
5972 options::OPT_fno_visibility_inlines_hidden_static_local_var);
5973 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
5974 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
5976 if (Args.hasFlag(options::OPT_fnew_infallible,
5977 options::OPT_fno_new_infallible,
false))
5978 CmdArgs.push_back(
"-fnew-infallible");
5980 if (Args.hasFlag(options::OPT_fno_operator_names,
5981 options::OPT_foperator_names,
false))
5982 CmdArgs.push_back(
"-fno-operator-names");
5985 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
5986 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
5987 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
5988 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls,
5989 options::OPT_fno_emulated_tls);
5990 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
5992 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
5996 if (!Triple.isX86() && !Triple.isAArch64())
5997 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5998 << A->getAsString(Args) << TripleStr;
6002 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
6003 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6005 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6006 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6010 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6011 options::OPT_fno_openmp,
false) &&
6018 CmdArgs.push_back(
"-fopenmp");
6023 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6024 options::OPT_fnoopenmp_use_tls,
true))
6025 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6026 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6027 options::OPT_fno_openmp_simd);
6028 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6029 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6030 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6031 options::OPT_fno_openmp_extensions,
true))
6032 CmdArgs.push_back(
"-fno-openmp-extensions");
6033 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6034 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6035 Args.AddAllArgs(CmdArgs,
6036 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6037 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6038 options::OPT_fno_openmp_optimistic_collapse,
6040 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6044 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6045 options::OPT_fno_openmp_cuda_mode,
false))
6046 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6049 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6050 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6051 options::OPT_fno_openmp_target_debug,
false))
6052 CmdArgs.push_back(
"-fopenmp-target-debug");
6056 if (Args.hasFlag(options::OPT_fopenmp_cuda_force_full_runtime,
6057 options::OPT_fno_openmp_cuda_force_full_runtime,
6059 CmdArgs.push_back(
"-fopenmp-cuda-force-full-runtime");
6063 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6064 options::OPT_fno_openmp_assume_teams_oversubscription,
6066 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6067 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6068 options::OPT_fno_openmp_assume_threads_oversubscription,
6070 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6071 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6072 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6073 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6074 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6086 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6087 options::OPT_fno_openmp_simd);
6088 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6089 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6090 options::OPT_fno_openmp_extensions);
6094 if (Args.hasArg(options::OPT_offload_new_driver))
6095 CmdArgs.push_back(
"--offload-new-driver");
6097 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
6100 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6103 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6105 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" +
Filename));
6110 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6111 StringRef S0 = A->getValue(), S = S0;
6112 unsigned Size,
Offset = 0;
6113 if (!Triple.isAArch64() && !Triple.isRISCV() && !Triple.isX86())
6114 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6115 << A->getAsString(Args) << TripleStr;
6116 else if (S.consumeInteger(10, Size) ||
6117 (!S.empty() && (!S.consume_front(
",") ||
6118 S.consumeInteger(10,
Offset) || !S.empty())))
6119 D.
Diag(diag::err_drv_invalid_argument_to_option)
6120 << S0 << A->getOption().getName();
6122 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6124 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6125 CmdArgs.push_back(Args.MakeArgString(
6126 "-fpatchable-function-entry-offset=" + Twine(
Offset)));
6130 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6133 Args.AddLastArg(CmdArgs, options::OPT_pg);
6135 llvm::Triple::ArchType Arch = TC.
getArch();
6136 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6137 if (Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6138 A->render(Args, CmdArgs);
6140 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6141 << A->getAsString(Args) << TripleStr;
6143 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6144 if (Arch == llvm::Triple::systemz)
6145 A->render(Args, CmdArgs);
6147 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6148 << A->getAsString(Args) << TripleStr;
6150 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6151 if (Arch == llvm::Triple::systemz)
6152 A->render(Args, CmdArgs);
6154 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6155 << A->getAsString(Args) << TripleStr;
6159 if (Args.getLastArg(options::OPT_fapple_kext) ||
6160 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6161 CmdArgs.push_back(
"-fapple-kext");
6163 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6164 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6165 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6166 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6167 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6168 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6169 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6170 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace);
6171 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6172 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6173 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6174 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6176 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6177 CmdArgs.push_back(
"-ftrapv-handler");
6178 CmdArgs.push_back(A->getValue());
6181 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6185 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
6186 if (A->getOption().matches(options::OPT_fwrapv))
6187 CmdArgs.push_back(
"-fwrapv");
6188 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
6189 options::OPT_fno_strict_overflow)) {
6190 if (A->getOption().matches(options::OPT_fno_strict_overflow))
6191 CmdArgs.push_back(
"-fwrapv");
6194 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
6195 options::OPT_fno_reroll_loops))
6196 if (A->getOption().matches(options::OPT_freroll_loops))
6197 CmdArgs.push_back(
"-freroll-loops");
6199 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6200 options::OPT_fno_finite_loops);
6202 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6203 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6204 options::OPT_fno_unroll_loops);
6206 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6208 if (Args.hasFlag(options::OPT_mspeculative_load_hardening,
6209 options::OPT_mno_speculative_load_hardening,
false))
6210 CmdArgs.push_back(Args.MakeArgString(
"-mspeculative-load-hardening"));
6216 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6219 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
6221 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
6223 if (Args.hasArg(options::OPT_mstack_alignment)) {
6224 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
6225 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
6228 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6229 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6232 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6234 CmdArgs.push_back(
"-mstack-probe-size=0");
6237 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6238 options::OPT_mno_stack_arg_probe);
6240 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6241 options::OPT_mno_restrict_it)) {
6242 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6243 CmdArgs.push_back(
"-mllvm");
6244 CmdArgs.push_back(
"-arm-restrict-it");
6246 CmdArgs.push_back(
"-mllvm");
6247 CmdArgs.push_back(
"-arm-default-it");
6255 if (C.getDriver().IsDXCMode())
6259 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6260 options::OPT_fno_hip_new_launch_api,
true))
6261 CmdArgs.push_back(
"-fhip-new-launch-api");
6262 if (Args.hasFlag(options::OPT_fgpu_allow_device_init,
6263 options::OPT_fno_gpu_allow_device_init,
false))
6264 CmdArgs.push_back(
"-fgpu-allow-device-init");
6267 if (IsCuda || IsHIP) {
6268 if (!Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false) &&
6269 Args.hasArg(options::OPT_offload_new_driver))
6270 D.
Diag(diag::err_drv_no_rdc_new_driver);
6271 if (Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false))
6272 CmdArgs.push_back(
"-fgpu-rdc");
6273 if (Args.hasFlag(options::OPT_fgpu_defer_diag,
6274 options::OPT_fno_gpu_defer_diag,
false))
6275 CmdArgs.push_back(
"-fgpu-defer-diag");
6276 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6277 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6279 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6280 CmdArgs.push_back(
"-fgpu-defer-diag");