35 #include "clang/Config/config.h"
44 #include "llvm/ADT/SmallSet.h"
45 #include "llvm/ADT/StringExtras.h"
46 #include "llvm/Config/llvm-config.h"
47 #include "llvm/Option/ArgList.h"
48 #include "llvm/Support/ARMTargetParserCommon.h"
49 #include "llvm/Support/CodeGen.h"
50 #include "llvm/Support/Compiler.h"
51 #include "llvm/Support/Compression.h"
52 #include "llvm/Support/FileSystem.h"
53 #include "llvm/Support/Host.h"
54 #include "llvm/Support/Path.h"
55 #include "llvm/Support/Process.h"
56 #include "llvm/Support/YAMLParser.h"
61 using namespace clang;
65 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
66 options::OPT_fminimize_whitespace,
67 options::OPT_fno_minimize_whitespace)) {
68 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
69 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
70 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
71 << A->getBaseArg().getAsString(Args)
72 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
79 if (Args.hasArg(options::OPT_static))
81 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
82 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
109 llvm::function_ref<
void(
const ToolChain &)> Work) {
111 Work(RegularToolChain);
126 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
141 const Arg &A,
size_t &Position) {
142 const char RefinementStepToken =
':';
143 Position = In.find(RefinementStepToken);
144 if (Position != StringRef::npos) {
145 StringRef Option = A.getOption().getName();
146 StringRef RefStep = In.substr(Position + 1);
154 if (RefStep.size() != 1) {
155 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
158 char RefStepChar = RefStep[0];
159 if (RefStepChar < '0' || RefStepChar >
'9') {
160 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
169 ArgStringList &OutStrings) {
170 StringRef DisabledPrefixIn =
"!";
171 StringRef DisabledPrefixOut =
"!";
172 StringRef EnabledPrefixOut =
"";
173 StringRef Out =
"-mrecip=";
175 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
179 unsigned NumOptions = A->getNumValues();
180 if (NumOptions == 0) {
182 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
187 if (NumOptions == 1) {
188 StringRef Val = A->getValue(0);
192 StringRef ValBase = Val.slice(0, RefStepLoc);
193 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
194 OutStrings.push_back(Args.MakeArgString(Out + Val));
203 llvm::StringMap<bool> OptionStrings;
204 OptionStrings.insert(std::make_pair(
"divd",
false));
205 OptionStrings.insert(std::make_pair(
"divf",
false));
206 OptionStrings.insert(std::make_pair(
"divh",
false));
207 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
208 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
209 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
210 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
211 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
212 OptionStrings.insert(std::make_pair(
"sqrth",
false));
213 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
214 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
215 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
217 for (
unsigned i = 0; i != NumOptions; ++i) {
218 StringRef Val = A->getValue(i);
220 bool IsDisabled = Val.startswith(DisabledPrefixIn);
229 StringRef ValBase = Val.slice(0, RefStep);
230 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
231 if (OptionIter == OptionStrings.end()) {
233 OptionIter = OptionStrings.find(ValBase.str() +
'f');
234 if (OptionIter == OptionStrings.end()) {
236 D.
Diag(diag::err_drv_unknown_argument) << Val;
242 if (OptionStrings[ValBase.str() +
'd'] ||
243 OptionStrings[ValBase.str() +
'h']) {
244 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
249 if (OptionIter->second ==
true) {
251 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
256 OptionIter->second =
true;
260 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
261 OptionStrings[ValBase.str() +
'd'] =
true;
262 OptionStrings[ValBase.str() +
'h'] =
true;
266 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
267 Out = Args.MakeArgString(Out + Prefix + Val);
268 if (i != NumOptions - 1)
269 Out = Args.MakeArgString(Out +
",");
272 OutStrings.push_back(Args.MakeArgString(Out));
278 ArgStringList &CmdArgs) {
279 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
283 StringRef
Value = A->getValue();
284 if (
Value ==
"none") {
285 CmdArgs.push_back(
"-mprefer-vector-width=none");
288 if (
Value.getAsInteger(10, Width)) {
289 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
292 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
298 const llvm::Triple &Triple) {
305 if (!Triple.isMacOSX())
308 return (!Triple.isMacOSXVersionLT(10, 5) &&
309 (Triple.getArch() == llvm::Triple::x86_64 ||
310 Triple.getArch() == llvm::Triple::arm));
320 ArgStringList &CmdArgs) {
321 const llvm::Triple &Triple = TC.
getTriple();
326 Args.ClaimAllArgs(options::OPT_fexceptions);
327 Args.ClaimAllArgs(options::OPT_fno_exceptions);
328 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
329 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
330 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
331 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
332 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
333 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
338 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
341 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
342 options::OPT_fno_async_exceptions,
false);
344 CmdArgs.push_back(
"-fasync-exceptions");
351 Args.hasFlag(options::OPT_fobjc_exceptions,
352 options::OPT_fno_objc_exceptions,
true)) {
353 CmdArgs.push_back(
"-fobjc-exceptions");
360 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
361 !Triple.isPS() && !Triple.isDriverKit();
362 Arg *ExceptionArg = Args.getLastArg(
363 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
364 options::OPT_fexceptions, options::OPT_fno_exceptions);
366 CXXExceptionsEnabled =
367 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
368 ExceptionArg->getOption().matches(options::OPT_fexceptions);
370 if (CXXExceptionsEnabled) {
371 CmdArgs.push_back(
"-fcxx-exceptions");
380 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
383 CmdArgs.push_back(
"-fexceptions");
399 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
406 assert(A.getOption().matches(options::OPT_gN_Group) &&
407 "Not a -g option that specifies a debug-info level");
408 if (A.getOption().matches(options::OPT_g0) ||
409 A.getOption().matches(options::OPT_ggdb0))
411 if (A.getOption().matches(options::OPT_gline_tables_only) ||
412 A.getOption().matches(options::OPT_ggdb1))
414 if (A.getOption().matches(options::OPT_gline_directives_only))
420 switch (Triple.getArch()){
423 case llvm::Triple::arm:
424 case llvm::Triple::thumb:
427 return Triple.isOSDarwin();
432 const llvm::Triple &Triple) {
433 if (Args.hasArg(options::OPT_pg) && !Args.hasArg(options::OPT_mfentry))
436 switch (Triple.getArch()) {
437 case llvm::Triple::xcore:
438 case llvm::Triple::wasm32:
439 case llvm::Triple::wasm64:
440 case llvm::Triple::msp430:
444 case llvm::Triple::ppc:
445 case llvm::Triple::ppcle:
446 case llvm::Triple::ppc64:
447 case llvm::Triple::ppc64le:
448 case llvm::Triple::riscv32:
449 case llvm::Triple::riscv64:
450 case llvm::Triple::sparc:
451 case llvm::Triple::sparcel:
452 case llvm::Triple::sparcv9:
453 case llvm::Triple::amdgcn:
454 case llvm::Triple::r600:
455 case llvm::Triple::csky:
456 case llvm::Triple::loongarch32:
457 case llvm::Triple::loongarch64:
463 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
467 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI ||
469 switch (Triple.getArch()) {
471 case llvm::Triple::arm:
472 case llvm::Triple::armeb:
473 case llvm::Triple::thumb:
474 case llvm::Triple::thumbeb:
475 if (Triple.isAndroid())
478 case llvm::Triple::mips64:
479 case llvm::Triple::mips64el:
480 case llvm::Triple::mips:
481 case llvm::Triple::mipsel:
482 case llvm::Triple::systemz:
483 case llvm::Triple::x86:
484 case llvm::Triple::x86_64:
491 if (Triple.isOSWindows()) {
492 switch (Triple.getArch()) {
493 case llvm::Triple::x86:
495 case llvm::Triple::x86_64:
496 return Triple.isOSBinFormatMachO();
497 case llvm::Triple::arm:
498 case llvm::Triple::thumb:
523 Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
524 options::OPT_fno_omit_frame_pointer);
525 bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer);
527 A && A->getOption().matches(options::OPT_fno_omit_frame_pointer);
529 Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
530 options::OPT_mno_omit_leaf_frame_pointer,
531 Triple.isAArch64() || Triple.isPS() || Triple.isVE());
543 ArgStringList &CmdArgs,
544 const llvm::vfs::FileSystem &VFS) {
545 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
546 options::OPT_fdebug_compilation_dir_EQ)) {
547 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
548 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
551 A->render(Args, CmdArgs);
552 }
else if (llvm::ErrorOr<std::string> CWD =
553 VFS.getCurrentWorkingDirectory()) {
554 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
556 StringRef Path(CmdArgs.back());
557 return Path.substr(Path.find(
'=') + 1).data();
561 const char *DebugCompilationDir,
562 const char *OutputFileName) {
564 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
565 if (StringRef(Arg->getValue()).startswith(
"-object-file-name"))
568 if (Args.hasArg(options::OPT_object_file_name_EQ))
572 if (ObjFileNameForDebug !=
"-" &&
573 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
574 (!DebugCompilationDir ||
575 llvm::sys::path::is_absolute(DebugCompilationDir))) {
577 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
580 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
585 const ArgList &Args, ArgStringList &CmdArgs) {
586 auto AddOneArg = [&](StringRef Map, StringRef Name) {
587 if (!Map.contains(
'='))
588 D.
Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
590 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
593 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
594 options::OPT_fdebug_prefix_map_EQ)) {
595 AddOneArg(A->getValue(), A->getOption().getName());
599 if (GlobalRemapEntry.empty())
601 AddOneArg(GlobalRemapEntry,
"environment");
606 ArgStringList &CmdArgs) {
607 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
608 options::OPT_fmacro_prefix_map_EQ)) {
609 StringRef Map = A->getValue();
610 if (!Map.contains(
'='))
611 D.
Diag(diag::err_drv_invalid_argument_to_option)
612 << Map << A->getOption().getName();
614 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
621 ArgStringList &CmdArgs) {
622 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
623 options::OPT_fcoverage_prefix_map_EQ)) {
624 StringRef Map = A->getValue();
625 if (!Map.contains(
'='))
626 D.
Diag(diag::err_drv_invalid_argument_to_option)
627 << Map << A->getOption().getName();
629 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
638 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
639 if (A->getOption().matches(options::OPT_O4) ||
640 A->getOption().matches(options::OPT_Ofast))
643 if (A->getOption().matches(options::OPT_O0))
646 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
649 StringRef S(A->getValue());
657 unsigned OptLevel = 0;
658 if (S.getAsInteger(10, OptLevel))
669 ArgStringList &CmdArgs) {
672 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
675 CmdArgs.push_back(
"-x");
676 if (Args.hasArg(options::OPT_rewrite_objc))
682 const char *ClangType;
684 case types::TY_CXXModule:
687 case types::TY_PP_CXXModule:
688 ClangType =
"c++-cpp-output";
694 CmdArgs.push_back(ClangType);
701 ArgStringList &CmdArgs) {
703 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
704 options::OPT_fprofile_generate_EQ,
705 options::OPT_fno_profile_generate);
706 if (PGOGenerateArg &&
707 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
708 PGOGenerateArg =
nullptr;
710 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
711 options::OPT_fcs_profile_generate_EQ,
712 options::OPT_fno_profile_generate);
713 if (CSPGOGenerateArg &&
714 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
715 CSPGOGenerateArg =
nullptr;
717 auto *ProfileGenerateArg = Args.getLastArg(
718 options::OPT_fprofile_instr_generate,
719 options::OPT_fprofile_instr_generate_EQ,
720 options::OPT_fno_profile_instr_generate);
721 if (ProfileGenerateArg &&
722 ProfileGenerateArg->getOption().matches(
723 options::OPT_fno_profile_instr_generate))
724 ProfileGenerateArg =
nullptr;
726 if (PGOGenerateArg && ProfileGenerateArg)
727 D.
Diag(diag::err_drv_argument_not_allowed_with)
728 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
732 if (PGOGenerateArg && ProfileUseArg)
733 D.
Diag(diag::err_drv_argument_not_allowed_with)
734 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
736 if (ProfileGenerateArg && ProfileUseArg)
737 D.
Diag(diag::err_drv_argument_not_allowed_with)
738 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
740 if (CSPGOGenerateArg && PGOGenerateArg) {
741 D.
Diag(diag::err_drv_argument_not_allowed_with)
742 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
743 PGOGenerateArg =
nullptr;
747 if (ProfileGenerateArg)
748 D.
Diag(diag::err_drv_unsupported_opt_for_target)
749 << ProfileGenerateArg->getSpelling() << TC.
getTriple().str();
751 D.
Diag(diag::err_drv_unsupported_opt_for_target)
752 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
755 if (ProfileGenerateArg) {
756 if (ProfileGenerateArg->getOption().matches(
757 options::OPT_fprofile_instr_generate_EQ))
758 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
759 ProfileGenerateArg->getValue()));
761 CmdArgs.push_back(
"-fprofile-instrument=clang");
762 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
764 CmdArgs.push_back(Args.MakeArgString(
769 Arg *PGOGenArg =
nullptr;
770 if (PGOGenerateArg) {
771 assert(!CSPGOGenerateArg);
772 PGOGenArg = PGOGenerateArg;
773 CmdArgs.push_back(
"-fprofile-instrument=llvm");
775 if (CSPGOGenerateArg) {
776 assert(!PGOGenerateArg);
777 PGOGenArg = CSPGOGenerateArg;
778 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
781 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
783 CmdArgs.push_back(Args.MakeArgString(
786 if (PGOGenArg->getOption().matches(
787 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
788 : options::OPT_fcs_profile_generate_EQ)) {
790 llvm::sys::path::append(Path,
"default_%m.profraw");
792 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
797 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
798 CmdArgs.push_back(Args.MakeArgString(
799 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
800 else if ((ProfileUseArg->getOption().matches(
801 options::OPT_fprofile_use_EQ) ||
802 ProfileUseArg->getOption().matches(
803 options::OPT_fprofile_instr_use))) {
805 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
806 if (Path.empty() || llvm::sys::fs::is_directory(Path))
807 llvm::sys::path::append(Path,
"default.profdata");
809 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
813 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
814 options::OPT_fno_test_coverage,
false) ||
815 Args.hasArg(options::OPT_coverage);
818 CmdArgs.push_back(
"-ftest-coverage");
820 CmdArgs.push_back(
"-fprofile-arcs");
822 if (Args.hasFlag(options::OPT_fcoverage_mapping,
823 options::OPT_fno_coverage_mapping,
false)) {
824 if (!ProfileGenerateArg)
825 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
826 <<
"-fcoverage-mapping"
827 <<
"-fprofile-instr-generate";
829 CmdArgs.push_back(
"-fcoverage-mapping");
832 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
833 options::OPT_fcoverage_compilation_dir_EQ)) {
834 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
835 CmdArgs.push_back(Args.MakeArgString(
836 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
838 A->render(Args, CmdArgs);
839 }
else if (llvm::ErrorOr<std::string> CWD =
840 D.
getVFS().getCurrentWorkingDirectory()) {
841 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
844 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
845 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
846 if (!Args.hasArg(options::OPT_coverage))
847 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
848 <<
"-fprofile-exclude-files="
851 StringRef
v = Arg->getValue();
853 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
856 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
857 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
858 if (!Args.hasArg(options::OPT_coverage))
859 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
860 <<
"-fprofile-filter-files="
863 StringRef
v = Arg->getValue();
864 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
867 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
868 StringRef Val = A->getValue();
869 if (Val ==
"atomic" || Val ==
"prefer-atomic")
870 CmdArgs.push_back(
"-fprofile-update=atomic");
871 else if (Val !=
"single")
872 D.
Diag(diag::err_drv_unsupported_option_argument)
873 << A->getSpelling() << Val;
875 CmdArgs.push_back(
"-fprofile-update=atomic");
878 int FunctionGroups = 1;
879 int SelectedFunctionGroup = 0;
880 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
881 StringRef Val = A->getValue();
882 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
883 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
886 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
887 StringRef Val = A->getValue();
888 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
889 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
890 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
892 if (FunctionGroups != 1)
893 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
894 Twine(FunctionGroups)));
895 if (SelectedFunctionGroup != 0)
896 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
897 Twine(SelectedFunctionGroup)));
903 Arg *FProfileDir =
nullptr;
904 if (Args.hasArg(options::OPT_fprofile_arcs) ||
905 Args.hasArg(options::OPT_coverage))
906 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
913 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
914 (EmitCovNotes || EmitCovData) && Output.
isFilename()) {
916 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT__SLASH_Fo))
917 OutputFilename = FinalOutput->getValue();
918 else if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
919 OutputFilename = FinalOutput->getValue();
921 OutputFilename = llvm::sys::path::filename(Output.
getBaseInput());
923 if (llvm::sys::path::is_relative(CoverageFilename))
924 (void)D.
getVFS().makeAbsolute(CoverageFilename);
925 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
927 CmdArgs.push_back(
"-coverage-notes-file");
928 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
932 CoverageFilename = FProfileDir->getValue();
933 llvm::sys::path::append(CoverageFilename, OutputFilename);
935 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
936 CmdArgs.push_back(
"-coverage-data-file");
937 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
944 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
953 bool RelaxDefault =
true;
955 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
956 RelaxDefault = A->getOption().matches(options::OPT_O0);
959 RelaxDefault =
false;
960 for (
const auto &Act : C.getActions()) {
968 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
974 unsigned DwarfVersion,
975 llvm::DebuggerKind DebuggerTuning) {
978 CmdArgs.push_back(
"-debug-info-kind=line-directives-only");
981 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
984 CmdArgs.push_back(
"-debug-info-kind=constructor");
987 CmdArgs.push_back(
"-debug-info-kind=limited");
990 CmdArgs.push_back(
"-debug-info-kind=standalone");
993 CmdArgs.push_back(
"-debug-info-kind=unused-types");
998 if (DwarfVersion > 0)
1000 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
1001 switch (DebuggerTuning) {
1002 case llvm::DebuggerKind::GDB:
1003 CmdArgs.push_back(
"-debugger-tuning=gdb");
1005 case llvm::DebuggerKind::LLDB:
1006 CmdArgs.push_back(
"-debugger-tuning=lldb");
1008 case llvm::DebuggerKind::SCE:
1009 CmdArgs.push_back(
"-debugger-tuning=sce");
1011 case llvm::DebuggerKind::DBX:
1012 CmdArgs.push_back(
"-debugger-tuning=dbx");
1021 assert(A &&
"Expected non-nullptr argument.");
1024 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
1030 ArgStringList &CmdArgs,
1033 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
1037 StringRef
Value = A->getValue();
1038 if (
Value ==
"none") {
1039 CmdArgs.push_back(
"--compress-debug-sections=none");
1040 }
else if (
Value ==
"zlib") {
1041 if (llvm::compression::zlib::isAvailable()) {
1043 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1045 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
1047 }
else if (
Value ==
"zstd") {
1048 if (llvm::compression::zstd::isAvailable()) {
1050 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1052 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
1055 D.
Diag(diag::err_drv_unsupported_option_argument)
1056 << A->getSpelling() <<
Value;
1062 const ArgList &Args,
1063 ArgStringList &CmdArgs,
1064 bool IsCC1As =
false) {
1072 CmdArgs.insert(CmdArgs.begin() + 1,
1073 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
1074 Twine(CodeObjVer)));
1075 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
1078 CmdArgs.insert(CmdArgs.begin() + 1,
1079 Args.MakeArgString(Twine(
"-mcode-object-version=") +
1080 Twine(CodeObjVer)));
1085 const Driver &D,
const ArgList &Args,
1086 ArgStringList &CmdArgs,
1089 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
1093 Args.AddLastArg(CmdArgs, options::OPT_C);
1094 Args.AddLastArg(CmdArgs, options::OPT_CC);
1097 Arg *ArgM = Args.getLastArg(options::OPT_MM);
1099 ArgM = Args.getLastArg(options::OPT_M);
1100 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1102 ArgMD = Args.getLastArg(options::OPT_MD);
1106 CmdArgs.push_back(
"-w");
1112 const char *DepFile;
1113 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1114 DepFile = MF->getValue();
1115 C.addFailureResultFile(DepFile, &JA);
1116 }
else if (Output.
getType() == types::TY_Dependencies) {
1118 }
else if (!ArgMD) {
1121 DepFile = getDependencyFileName(Args, Inputs);
1122 C.addFailureResultFile(DepFile, &JA);
1124 CmdArgs.push_back(
"-dependency-file");
1125 CmdArgs.push_back(DepFile);
1127 bool HasTarget =
false;
1128 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1131 if (A->getOption().matches(options::OPT_MT)) {
1132 A->render(Args, CmdArgs);
1134 CmdArgs.push_back(
"-MT");
1137 CmdArgs.push_back(Args.MakeArgString(Quoted));
1143 const char *DepTarget;
1147 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1148 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1149 DepTarget = OutputOpt->getValue();
1155 llvm::sys::path::replace_extension(
P,
"o");
1156 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1159 CmdArgs.push_back(
"-MT");
1162 CmdArgs.push_back(Args.MakeArgString(Quoted));
1165 if (ArgM->getOption().matches(options::OPT_M) ||
1166 ArgM->getOption().matches(options::OPT_MD))
1167 CmdArgs.push_back(
"-sys-header-deps");
1168 if ((isa<PrecompileJobAction>(JA) &&
1169 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1170 Args.hasArg(options::OPT_fmodule_file_deps))
1171 CmdArgs.push_back(
"-module-file-deps");
1174 if (Args.hasArg(options::OPT_MG)) {
1175 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1176 ArgM->getOption().matches(options::OPT_MMD))
1177 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1178 CmdArgs.push_back(
"-MG");
1181 Args.AddLastArg(CmdArgs, options::OPT_MP);
1182 Args.AddLastArg(CmdArgs, options::OPT_MV);
1189 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1191 getToolChain().AddHIPIncludeArgs(Args, CmdArgs);
1196 !Args.hasArg(options::OPT_nostdinc) &&
1197 !Args.hasArg(options::OPT_nogpuinc) &&
1198 (getToolChain().getTriple().isNVPTX() ||
1199 getToolChain().getTriple().isAMDGCN())) {
1200 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1204 llvm::sys::path::append(
P,
"include");
1205 llvm::sys::path::append(
P,
"openmp_wrappers");
1206 CmdArgs.push_back(
"-internal-isystem");
1207 CmdArgs.push_back(Args.MakeArgString(
P));
1210 CmdArgs.push_back(
"-include");
1211 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1220 if (getToolChain().getDriver().IsCLMode()) {
1221 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1222 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1225 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1228 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1229 options::OPT_fno_pch_instantiate_templates,
true))
1230 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1232 if (YcArg || YuArg) {
1233 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1234 if (!isa<PrecompileJobAction>(JA)) {
1235 CmdArgs.push_back(
"-include-pch");
1237 C, !ThroughHeader.empty()
1239 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1242 if (ThroughHeader.empty()) {
1243 CmdArgs.push_back(Args.MakeArgString(
1244 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1247 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1252 bool RenderedImplicitInclude =
false;
1253 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1254 if (A->getOption().matches(options::OPT_include) &&
1257 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1258 RenderedImplicitInclude =
true;
1260 bool FoundPCH =
false;
1265 llvm::sys::path::replace_extension(
P,
"pch");
1270 llvm::sys::path::replace_extension(
P,
"gch");
1277 if (IsFirstImplicitInclude) {
1279 CmdArgs.push_back(
"-include-pch");
1280 CmdArgs.push_back(Args.MakeArgString(
P));
1284 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1285 << A->getAsString(Args);
1288 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1295 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1302 A->render(Args, CmdArgs);
1305 Args.AddAllArgs(CmdArgs,
1306 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1307 options::OPT_F, options::OPT_index_header_map});
1315 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1316 options::OPT_Xpreprocessor);
1319 if (Arg *A = Args.getLastArg(options::OPT_I_))
1320 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1324 StringRef sysroot =
C.getSysRoot();
1325 if (sysroot !=
"") {
1326 if (!Args.hasArg(options::OPT_isysroot)) {
1327 CmdArgs.push_back(
"-isysroot");
1328 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1345 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1353 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1355 C, JA, getToolChain(),
1356 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1365 [&Args, &CmdArgs](
const ToolChain &TC) {
1370 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1376 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1377 options::OPT_fno_file_reproducible);
1379 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1380 CmdArgs.push_back(
"-source-date-epoch");
1381 CmdArgs.push_back(Args.MakeArgString(Epoch));
1387 switch (Triple.getArch()) {
1391 case llvm::Triple::aarch64:
1392 case llvm::Triple::aarch64_32:
1393 case llvm::Triple::aarch64_be:
1394 case llvm::Triple::arm:
1395 case llvm::Triple::armeb:
1396 case llvm::Triple::thumb:
1397 case llvm::Triple::thumbeb:
1398 if (Triple.isOSDarwin() || Triple.isOSWindows())
1402 case llvm::Triple::ppc:
1403 case llvm::Triple::ppc64:
1404 if (Triple.isOSDarwin())
1408 case llvm::Triple::hexagon:
1409 case llvm::Triple::ppcle:
1410 case llvm::Triple::ppc64le:
1411 case llvm::Triple::riscv32:
1412 case llvm::Triple::riscv64:
1413 case llvm::Triple::systemz:
1414 case llvm::Triple::xcore:
1420 const ArgList &Args) {
1423 if (!Triple.isOSDarwin())
1427 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1431 const llvm::Triple &Triple) {
1436 bool hasExplicitOutputFile =
1437 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1439 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1440 <<
"-foptimization-record-file";
1447 const llvm::Triple &Triple,
1450 StringRef Format =
"yaml";
1451 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1452 Format = A->getValue();
1454 CmdArgs.push_back(
"-opt-record-file");
1456 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1458 CmdArgs.push_back(A->getValue());
1460 bool hasMultipleArchs =
1461 Triple.isOSDarwin() &&
1462 Args.getAllArgValues(options::OPT_arch).size() > 1;
1466 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1467 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1468 F = FinalOutput->getValue();
1470 if (Format !=
"yaml" &&
1471 Triple.isOSDarwin() &&
1485 llvm::sys::path::replace_extension(F,
"");
1487 Triple.normalize());
1497 if (hasMultipleArchs) {
1501 llvm::sys::path::replace_extension(F,
"");
1504 F += Triple.getArchName();
1506 llvm::sys::path::replace_extension(F, OldExtension);
1510 Extension +=
"opt.";
1511 Extension += Format;
1513 llvm::sys::path::replace_extension(F, Extension);
1514 CmdArgs.push_back(Args.MakeArgString(F));
1518 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1519 CmdArgs.push_back(
"-opt-record-passes");
1520 CmdArgs.push_back(A->getValue());
1523 if (!Format.empty()) {
1524 CmdArgs.push_back(
"-opt-record-format");
1525 CmdArgs.push_back(Format.data());
1530 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1531 options::OPT_fno_aapcs_bitfield_width,
true))
1532 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1534 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1535 CmdArgs.push_back(
"-faapcs-bitfield-load");
1539 void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1540 const ArgList &Args, ArgStringList &CmdArgs) {
1544 const char *ABIName =
nullptr;
1545 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1546 ABIName = A->getValue();
1549 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1552 CmdArgs.push_back(
"-target-abi");
1553 CmdArgs.push_back(ABIName);
1556 void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1557 auto StrictAlignIter =
1558 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1559 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1561 if (StrictAlignIter != CmdArgs.rend() &&
1562 StringRef(*StrictAlignIter) ==
"+strict-align")
1563 CmdArgs.push_back(
"-Wunaligned-access");
1568 ArgStringList &CmdArgs,
bool isAArch64) {
1569 const Arg *A = isAArch64
1570 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1571 options::OPT_mbranch_protection_EQ)
1572 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1578 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1579 D.
Diag(diag::warn_incompatible_branch_protection_option)
1580 << Triple.getArchName();
1582 StringRef
Scope, Key;
1583 bool IndirectBranches;
1585 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1586 Scope = A->getValue();
1588 D.
Diag(diag::err_drv_unsupported_option_argument)
1589 << A->getSpelling() <<
Scope;
1591 IndirectBranches =
false;
1594 llvm::ARM::ParsedBranchProtection PBP;
1595 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg))
1596 D.
Diag(diag::err_drv_unsupported_option_argument)
1597 << A->getSpelling() << DiagMsg;
1598 if (!isAArch64 && PBP.Key ==
"b_key")
1599 D.
Diag(diag::warn_unsupported_branch_protection)
1600 <<
"b-key" << A->getAsString(Args);
1603 IndirectBranches = PBP.BranchTargetEnforcement;
1607 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1608 if (!
Scope.equals(
"none"))
1610 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1611 if (IndirectBranches)
1612 CmdArgs.push_back(
"-mbranch-target-enforce");
1615 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1616 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1617 RenderARMABI(getToolChain().getDriver(), Triple, Args, CmdArgs);
1624 CmdArgs.push_back(
"-msoft-float");
1625 CmdArgs.push_back(
"-mfloat-abi");
1626 CmdArgs.push_back(
"soft");
1629 CmdArgs.push_back(
"-mfloat-abi");
1630 CmdArgs.push_back(
"soft");
1634 CmdArgs.push_back(
"-mfloat-abi");
1635 CmdArgs.push_back(
"hard");
1639 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1640 options::OPT_mno_global_merge)) {
1641 CmdArgs.push_back(
"-mllvm");
1642 if (A->getOption().matches(options::OPT_mno_global_merge))
1643 CmdArgs.push_back(
"-arm-global-merge=false");
1645 CmdArgs.push_back(
"-arm-global-merge=true");
1648 if (!Args.hasFlag(options::OPT_mimplicit_float,
1649 options::OPT_mno_implicit_float,
true))
1650 CmdArgs.push_back(
"-no-implicit-float");
1652 if (Args.getLastArg(options::OPT_mcmse))
1653 CmdArgs.push_back(
"-mcmse");
1660 AddUnalignedAccessWarning(CmdArgs);
1663 void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1664 const ArgList &Args,
bool KernelOrKext,
1665 ArgStringList &CmdArgs)
const {
1676 case llvm::Triple::arm:
1677 case llvm::Triple::armeb:
1678 case llvm::Triple::thumb:
1679 case llvm::Triple::thumbeb:
1681 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1684 case llvm::Triple::aarch64:
1685 case llvm::Triple::aarch64_32:
1686 case llvm::Triple::aarch64_be:
1687 AddAArch64TargetArgs(Args, CmdArgs);
1690 case llvm::Triple::loongarch32:
1691 case llvm::Triple::loongarch64:
1692 AddLoongArchTargetArgs(Args, CmdArgs);
1695 case llvm::Triple::mips:
1696 case llvm::Triple::mipsel:
1697 case llvm::Triple::mips64:
1698 case llvm::Triple::mips64el:
1699 AddMIPSTargetArgs(Args, CmdArgs);
1702 case llvm::Triple::ppc:
1703 case llvm::Triple::ppcle:
1704 case llvm::Triple::ppc64:
1705 case llvm::Triple::ppc64le:
1706 AddPPCTargetArgs(Args, CmdArgs);
1709 case llvm::Triple::riscv32:
1710 case llvm::Triple::riscv64:
1711 AddRISCVTargetArgs(Args, CmdArgs);
1714 case llvm::Triple::sparc:
1715 case llvm::Triple::sparcel:
1716 case llvm::Triple::sparcv9:
1717 AddSparcTargetArgs(Args, CmdArgs);
1720 case llvm::Triple::systemz:
1721 AddSystemZTargetArgs(Args, CmdArgs);
1724 case llvm::Triple::x86:
1725 case llvm::Triple::x86_64:
1726 AddX86TargetArgs(Args, CmdArgs);
1729 case llvm::Triple::lanai:
1730 AddLanaiTargetArgs(Args, CmdArgs);
1733 case llvm::Triple::hexagon:
1734 AddHexagonTargetArgs(Args, CmdArgs);
1737 case llvm::Triple::wasm32:
1738 case llvm::Triple::wasm64:
1739 AddWebAssemblyTargetArgs(Args, CmdArgs);
1742 case llvm::Triple::ve:
1743 AddVETargetArgs(Args, CmdArgs);
1749 void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1750 ArgStringList &CmdArgs) {
1751 const char *ABIName =
nullptr;
1752 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1753 ABIName = A->getValue();
1754 else if (Triple.isOSDarwin())
1755 ABIName =
"darwinpcs";
1759 CmdArgs.push_back(
"-target-abi");
1760 CmdArgs.push_back(ABIName);
1764 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1765 ArgStringList &CmdArgs)
const {
1766 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1768 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1769 Args.hasArg(options::OPT_mkernel) ||
1770 Args.hasArg(options::OPT_fapple_kext))
1771 CmdArgs.push_back(
"-disable-red-zone");
1773 if (!Args.hasFlag(options::OPT_mimplicit_float,
1774 options::OPT_mno_implicit_float,
true))
1775 CmdArgs.push_back(
"-no-implicit-float");
1777 RenderAArch64ABI(Triple, Args, CmdArgs);
1780 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1781 options::OPT_mno_global_merge)) {
1782 CmdArgs.push_back(
"-mllvm");
1783 if (A->getOption().matches(options::OPT_mno_global_merge))
1784 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1786 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1793 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1794 StringRef Val = A->getValue();
1795 const Driver &D = getToolChain().getDriver();
1796 if (Val.equals(
"128") || Val.equals(
"256") || Val.equals(
"512") ||
1797 Val.equals(
"1024") || Val.equals(
"2048") || Val.equals(
"128+") ||
1798 Val.equals(
"256+") || Val.equals(
"512+") || Val.equals(
"1024+") ||
1799 Val.equals(
"2048+")) {
1801 if (Val.endswith(
"+"))
1802 Val = Val.substr(0, Val.size() - 1);
1804 bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid;
1805 assert(!Invalid &&
"Failed to parse value");
1807 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1810 bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid;
1811 assert(!Invalid &&
"Failed to parse value");
1813 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1815 }
else if (!Val.equals(
"scalable"))
1817 D.
Diag(diag::err_drv_unsupported_option_argument)
1818 << A->getSpelling() << Val;
1823 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1824 CmdArgs.push_back(
"-tune-cpu");
1825 if (strcmp(A->getValue(),
"native") == 0)
1826 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1828 CmdArgs.push_back(A->getValue());
1831 AddUnalignedAccessWarning(CmdArgs);
1834 void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1835 ArgStringList &CmdArgs)
const {
1836 CmdArgs.push_back(
"-target-abi");
1838 getToolChain().getTriple())
1842 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1843 ArgStringList &CmdArgs)
const {
1844 const Driver &D = getToolChain().getDriver();
1847 const llvm::Triple &Triple = getToolChain().getTriple();
1850 CmdArgs.push_back(
"-target-abi");
1851 CmdArgs.push_back(ABIName.data());
1856 CmdArgs.push_back(
"-msoft-float");
1857 CmdArgs.push_back(
"-mfloat-abi");
1858 CmdArgs.push_back(
"soft");
1862 CmdArgs.push_back(
"-mfloat-abi");
1863 CmdArgs.push_back(
"hard");
1866 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1867 options::OPT_mno_ldc1_sdc1)) {
1868 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1869 CmdArgs.push_back(
"-mllvm");
1870 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1874 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1875 options::OPT_mno_check_zero_division)) {
1876 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1877 CmdArgs.push_back(
"-mllvm");
1878 CmdArgs.push_back(
"-mno-check-zero-division");
1882 if (Args.getLastArg(options::OPT_mfix4300)) {
1883 CmdArgs.push_back(
"-mllvm");
1884 CmdArgs.push_back(
"-mfix4300");
1887 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1888 StringRef
v = A->getValue();
1889 CmdArgs.push_back(
"-mllvm");
1890 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1894 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1896 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1909 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1911 llvm::Reloc::Model RelocationModel;
1914 std::tie(RelocationModel, PICLevel, IsPIE) =
1917 NoABICalls = NoABICalls ||
1918 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1920 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1922 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1923 CmdArgs.push_back(
"-mllvm");
1924 CmdArgs.push_back(
"-mgpopt");
1926 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1927 options::OPT_mno_local_sdata);
1928 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1929 options::OPT_mno_extern_sdata);
1930 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1931 options::OPT_mno_embedded_data);
1933 CmdArgs.push_back(
"-mllvm");
1934 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1935 CmdArgs.push_back(
"-mlocal-sdata=1");
1937 CmdArgs.push_back(
"-mlocal-sdata=0");
1939 LocalSData->claim();
1943 CmdArgs.push_back(
"-mllvm");
1944 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1945 CmdArgs.push_back(
"-mextern-sdata=1");
1947 CmdArgs.push_back(
"-mextern-sdata=0");
1949 ExternSData->claim();
1953 CmdArgs.push_back(
"-mllvm");
1954 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1955 CmdArgs.push_back(
"-membedded-data=1");
1957 CmdArgs.push_back(
"-membedded-data=0");
1959 EmbeddedData->claim();
1962 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1963 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1968 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1969 StringRef Val = StringRef(A->getValue());
1971 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1972 CmdArgs.push_back(
"-mllvm");
1973 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1975 D.
Diag(diag::err_drv_unsupported_option_argument)
1976 << A->getSpelling() << Val;
1978 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1981 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1982 options::OPT_mno_relax_pic_calls)) {
1983 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1984 CmdArgs.push_back(
"-mllvm");
1985 CmdArgs.push_back(
"-mips-jalr-reloc=0");
1990 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1991 ArgStringList &CmdArgs)
const {
1992 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1993 CmdArgs.push_back(
"-tune-cpu");
1994 if (strcmp(A->getValue(),
"native") == 0)
1995 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1997 CmdArgs.push_back(A->getValue());
2001 const char *ABIName =
nullptr;
2002 const llvm::Triple &T = getToolChain().getTriple();
2003 if (T.isOSBinFormatELF()) {
2004 switch (getToolChain().getArch()) {
2005 case llvm::Triple::ppc64: {
2006 if ((T.isOSFreeBSD() && T.getOSMajorVersion() >= 13) ||
2007 T.isOSOpenBSD() || T.isMusl())
2013 case llvm::Triple::ppc64le:
2021 bool IEEELongDouble = getToolChain().defaultToIEEELongDouble();
2022 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2023 StringRef
V = A->getValue();
2024 if (
V ==
"ieeelongdouble")
2025 IEEELongDouble =
true;
2026 else if (
V ==
"ibmlongdouble")
2027 IEEELongDouble =
false;
2028 else if (
V !=
"altivec")
2032 ABIName = A->getValue();
2035 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2042 CmdArgs.push_back(
"-msoft-float");
2043 CmdArgs.push_back(
"-mfloat-abi");
2044 CmdArgs.push_back(
"soft");
2048 CmdArgs.push_back(
"-mfloat-abi");
2049 CmdArgs.push_back(
"hard");
2053 CmdArgs.push_back(
"-target-abi");
2054 CmdArgs.push_back(ABIName);
2059 ArgStringList &CmdArgs) {
2061 const llvm::Triple &Triple = TC.
getTriple();
2063 const char *SmallDataLimit =
"8";
2065 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2066 options::OPT_fPIC)) {
2068 SmallDataLimit =
"0";
2069 if (Args.hasArg(options::OPT_G)) {
2070 D.
Diag(diag::warn_drv_unsupported_sdata);
2072 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2073 .equals_insensitive(
"large") &&
2074 (Triple.getArch() == llvm::Triple::riscv64)) {
2076 SmallDataLimit =
"0";
2077 if (Args.hasArg(options::OPT_G)) {
2078 D.
Diag(diag::warn_drv_unsupported_sdata);
2080 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2081 SmallDataLimit = A->getValue();
2084 CmdArgs.push_back(
"-msmall-data-limit");
2085 CmdArgs.push_back(SmallDataLimit);
2088 void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2089 ArgStringList &CmdArgs)
const {
2090 const llvm::Triple &Triple = getToolChain().getTriple();
2093 CmdArgs.push_back(
"-target-abi");
2094 CmdArgs.push_back(ABIName.data());
2098 if (!Args.hasFlag(options::OPT_mimplicit_float,
2099 options::OPT_mno_implicit_float,
true))
2100 CmdArgs.push_back(
"-no-implicit-float");
2102 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2103 CmdArgs.push_back(
"-tune-cpu");
2104 if (strcmp(A->getValue(),
"native") == 0)
2105 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2107 CmdArgs.push_back(A->getValue());
2111 void Clang::AddSparcTargetArgs(
const ArgList &Args,
2112 ArgStringList &CmdArgs)
const {
2118 CmdArgs.push_back(
"-msoft-float");
2119 CmdArgs.push_back(
"-mfloat-abi");
2120 CmdArgs.push_back(
"soft");
2124 CmdArgs.push_back(
"-mfloat-abi");
2125 CmdArgs.push_back(
"hard");
2128 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2129 StringRef Name = A->getValue();
2131 if (Name ==
"native")
2132 TuneCPU =
std::string(llvm::sys::getHostCPUName());
2136 CmdArgs.push_back(
"-tune-cpu");
2137 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2141 void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2142 ArgStringList &CmdArgs)
const {
2143 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2144 CmdArgs.push_back(
"-tune-cpu");
2145 if (strcmp(A->getValue(),
"native") == 0)
2146 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2148 CmdArgs.push_back(A->getValue());
2152 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2153 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2154 options::OPT_mno_packed_stack,
false);
2158 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2159 const Driver &D = getToolChain().getDriver();
2160 D.
Diag(diag::err_drv_unsupported_opt)
2161 <<
"-mpacked-stack -mbackchain -mhard-float";
2164 CmdArgs.push_back(
"-mbackchain");
2166 CmdArgs.push_back(
"-mpacked-stack");
2169 CmdArgs.push_back(
"-msoft-float");
2170 CmdArgs.push_back(
"-mfloat-abi");
2171 CmdArgs.push_back(
"soft");
2175 void Clang::AddX86TargetArgs(
const ArgList &Args,
2176 ArgStringList &CmdArgs)
const {
2177 const Driver &D = getToolChain().getDriver();
2180 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2181 Args.hasArg(options::OPT_mkernel) ||
2182 Args.hasArg(options::OPT_fapple_kext))
2183 CmdArgs.push_back(
"-disable-red-zone");
2185 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2186 options::OPT_mno_tls_direct_seg_refs,
true))
2187 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2191 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2192 Args.hasArg(options::OPT_fapple_kext));
2193 if (Arg *A = Args.getLastArg(
2194 options::OPT_msoft_float, options::OPT_mno_soft_float,
2195 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2196 const Option &O = A->getOption();
2197 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2198 O.matches(options::OPT_msoft_float));
2200 if (NoImplicitFloat)
2201 CmdArgs.push_back(
"-no-implicit-float");
2203 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2204 StringRef
Value = A->getValue();
2206 CmdArgs.push_back(
"-mllvm");
2207 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2208 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2210 D.
Diag(diag::err_drv_unsupported_option_argument)
2211 << A->getSpelling() <<
Value;
2214 CmdArgs.push_back(
"-mllvm");
2215 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2218 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2219 options::OPT_mno_skip_rax_setup))
2220 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2221 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2224 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2225 CmdArgs.push_back(
"-mfloat-abi");
2226 CmdArgs.push_back(
"soft");
2227 CmdArgs.push_back(
"-mstack-alignment=4");
2234 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2235 !getToolChain().getTriple().isPS())
2236 TuneCPU =
"generic";
2239 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2240 StringRef Name = A->getValue();
2242 if (Name ==
"native") {
2243 Name = llvm::sys::getHostCPUName();
2250 if (!TuneCPU.empty()) {
2251 CmdArgs.push_back(
"-tune-cpu");
2252 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2256 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2257 ArgStringList &CmdArgs)
const {
2258 CmdArgs.push_back(
"-mqdsp6-compat");
2259 CmdArgs.push_back(
"-Wreturn-type");
2262 CmdArgs.push_back(
"-mllvm");
2264 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2267 if (!Args.hasArg(options::OPT_fno_short_enums))
2268 CmdArgs.push_back(
"-fshort-enums");
2269 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2270 CmdArgs.push_back(
"-mllvm");
2271 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2273 CmdArgs.push_back(
"-mllvm");
2274 CmdArgs.push_back(
"-machine-sink-split=0");
2277 void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2278 ArgStringList &CmdArgs)
const {
2279 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2280 StringRef CPUName = A->getValue();
2282 CmdArgs.push_back(
"-target-cpu");
2283 CmdArgs.push_back(Args.MakeArgString(CPUName));
2285 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2286 StringRef
Value = A->getValue();
2290 if (
Value.getAsInteger(10, Mregparm)) {
2291 if (Mregparm != 4) {
2292 getToolChain().getDriver().Diag(
2293 diag::err_drv_unsupported_option_argument)
2294 << A->getSpelling() <<
Value;
2300 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2301 ArgStringList &CmdArgs)
const {
2303 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2304 options::OPT_fvisibility_ms_compat))
2305 CmdArgs.push_back(
"-fvisibility=hidden");
2308 void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2310 CmdArgs.push_back(
"-mfloat-abi");
2311 CmdArgs.push_back(
"hard");
2315 StringRef Target,
const InputInfo &Output,
2316 const InputInfo &Input,
const ArgList &Args)
const {
2318 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2321 using llvm::yaml::escape;
2322 const Driver &D = getToolChain().getDriver();
2324 if (!CompilationDatabase) {
2326 auto File = std::make_unique<llvm::raw_fd_ostream>(
2328 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2330 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2334 CompilationDatabase = std::move(File);
2336 auto &CDB = *CompilationDatabase;
2337 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2340 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2341 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2342 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2347 CDB <<
", \"" << escape(Buf) <<
"\"";
2348 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2351 CDB <<
", \"" << escape(Buf) <<
"\"";
2353 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2354 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2355 for (
auto &A: Args) {
2356 auto &O = A->getOption();
2358 if (O.getID() == options::OPT_x)
2361 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2363 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2366 if (O.getKind() == Option::InputClass)
2369 if (O.getID() == options::OPT_o)
2373 A->render(Args, ASL);
2375 CDB <<
", \"" << escape(it) <<
"\"";
2379 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2382 void Clang::DumpCompilationDatabaseFragmentToDir(
2384 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2386 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2389 if (CompilationDatabase)
2390 DumpCompilationDatabase(C,
"", Target, Output, Input, Args);
2393 const auto &
Driver =
C.getDriver();
2395 auto Err = llvm::sys::fs::create_directory(Path,
true);
2397 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2401 llvm::sys::path::append(
2403 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2406 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2407 llvm::sys::fs::OF_Text);
2409 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2412 CompilationDatabase =
2413 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2414 DumpCompilationDatabase(C,
"", Target, Output, Input, Args);
2424 CmdArgs.push_back(
"-mllvm");
2425 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2429 const ArgList &Args,
2430 ArgStringList &CmdArgs,
2433 CmdArgs.push_back(
"-mrelax-all");
2437 bool DefaultIncrementalLinkerCompatible =
2438 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2439 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2440 options::OPT_mno_incremental_linker_compatible,
2441 DefaultIncrementalLinkerCompatible))
2442 CmdArgs.push_back(
"-mincremental-linker-compatible");
2444 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2454 bool TakeNextArg =
false;
2456 bool UseRelaxRelocations = C.getDefaultToolChain().useRelaxRelocations();
2457 bool UseNoExecStack =
false;
2458 const char *MipsTargetFeature =
nullptr;
2459 StringRef ImplicitIt;
2461 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2462 options::OPT_mimplicit_it_EQ)) {
2465 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2466 switch (C.getDefaultToolChain().getArch()) {
2467 case llvm::Triple::arm:
2468 case llvm::Triple::armeb:
2469 case llvm::Triple::thumb:
2470 case llvm::Triple::thumbeb:
2472 ImplicitIt = A->getValue();
2474 D.
Diag(diag::err_drv_unsupported_option_argument)
2475 << A->getSpelling() << ImplicitIt;
2482 for (StringRef
Value : A->getValues()) {
2484 CmdArgs.push_back(
Value.data());
2485 TakeNextArg =
false;
2489 if (C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2490 Value ==
"-mbig-obj")
2493 switch (C.getDefaultToolChain().getArch()) {
2496 case llvm::Triple::wasm32:
2497 case llvm::Triple::wasm64:
2498 if (
Value ==
"--no-type-check") {
2499 CmdArgs.push_back(
"-mno-type-check");
2503 case llvm::Triple::thumb:
2504 case llvm::Triple::thumbeb:
2505 case llvm::Triple::arm:
2506 case llvm::Triple::armeb:
2507 if (
Value.startswith(
"-mimplicit-it=")) {
2509 ImplicitIt =
Value.split(
"=").second;
2513 if (
Value ==
"-mthumb")
2518 case llvm::Triple::mips:
2519 case llvm::Triple::mipsel:
2520 case llvm::Triple::mips64:
2521 case llvm::Triple::mips64el:
2522 if (
Value ==
"--trap") {
2523 CmdArgs.push_back(
"-target-feature");
2524 CmdArgs.push_back(
"+use-tcc-in-div");
2527 if (
Value ==
"--break") {
2528 CmdArgs.push_back(
"-target-feature");
2529 CmdArgs.push_back(
"-use-tcc-in-div");
2532 if (
Value.startswith(
"-msoft-float")) {
2533 CmdArgs.push_back(
"-target-feature");
2534 CmdArgs.push_back(
"+soft-float");
2537 if (
Value.startswith(
"-mhard-float")) {
2538 CmdArgs.push_back(
"-target-feature");
2539 CmdArgs.push_back(
"-soft-float");
2543 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2544 .Case(
"-mips1",
"+mips1")
2545 .Case(
"-mips2",
"+mips2")
2546 .Case(
"-mips3",
"+mips3")
2547 .Case(
"-mips4",
"+mips4")
2548 .Case(
"-mips5",
"+mips5")
2549 .Case(
"-mips32",
"+mips32")
2550 .Case(
"-mips32r2",
"+mips32r2")
2551 .Case(
"-mips32r3",
"+mips32r3")
2552 .Case(
"-mips32r5",
"+mips32r5")
2553 .Case(
"-mips32r6",
"+mips32r6")
2554 .Case(
"-mips64",
"+mips64")
2555 .Case(
"-mips64r2",
"+mips64r2")
2556 .Case(
"-mips64r3",
"+mips64r3")
2557 .Case(
"-mips64r5",
"+mips64r5")
2558 .Case(
"-mips64r6",
"+mips64r6")
2560 if (MipsTargetFeature)
2564 if (
Value ==
"-force_cpusubtype_ALL") {
2566 }
else if (
Value ==
"-L") {
2567 CmdArgs.push_back(
"-msave-temp-labels");
2568 }
else if (
Value ==
"--fatal-warnings") {
2569 CmdArgs.push_back(
"-massembler-fatal-warnings");
2570 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2571 CmdArgs.push_back(
"-massembler-no-warn");
2572 }
else if (
Value ==
"--noexecstack") {
2573 UseNoExecStack =
true;
2574 }
else if (
Value.startswith(
"-compress-debug-sections") ||
2575 Value.startswith(
"--compress-debug-sections") ||
2576 Value ==
"-nocompress-debug-sections" ||
2577 Value ==
"--nocompress-debug-sections") {
2578 CmdArgs.push_back(
Value.data());
2579 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2580 Value ==
"--mrelax-relocations=yes") {
2581 UseRelaxRelocations =
true;
2582 }
else if (
Value ==
"-mrelax-relocations=no" ||
2583 Value ==
"--mrelax-relocations=no") {
2584 UseRelaxRelocations =
false;
2585 }
else if (
Value.startswith(
"-I")) {
2586 CmdArgs.push_back(
Value.data());
2591 }
else if (
Value.startswith(
"-gdwarf-")) {
2594 if (DwarfVersion == 0) {
2595 CmdArgs.push_back(
Value.data());
2599 DwarfVersion, llvm::DebuggerKind::Default);
2601 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2602 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2604 }
else if (
Value ==
"-defsym") {
2605 if (A->getNumValues() != 2) {
2606 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2609 const char *S = A->getValue(1);
2610 auto Pair = StringRef(S).split(
'=');
2611 auto Sym = Pair.first;
2612 auto SVal = Pair.second;
2614 if (Sym.empty() || SVal.empty()) {
2615 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2619 if (SVal.getAsInteger(0, IVal)) {
2620 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2623 CmdArgs.push_back(
Value.data());
2625 }
else if (
Value ==
"-fdebug-compilation-dir") {
2626 CmdArgs.push_back(
"-fdebug-compilation-dir");
2628 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2632 CmdArgs.push_back(
"-fdebug-compilation-dir");
2633 CmdArgs.push_back(
Value.data());
2634 }
else if (
Value ==
"--version") {
2637 D.
Diag(diag::err_drv_unsupported_option_argument)
2638 << A->getSpelling() <<
Value;
2642 if (ImplicitIt.size())
2644 if (!UseRelaxRelocations)
2645 CmdArgs.push_back(
"-mrelax-relocations=no");
2647 CmdArgs.push_back(
"-mnoexecstack");
2648 if (MipsTargetFeature !=
nullptr) {
2649 CmdArgs.push_back(
"-target-feature");
2650 CmdArgs.push_back(MipsTargetFeature);
2654 if (C.getDriver().embedBitcodeEnabled() ||
2655 C.getDriver().embedBitcodeMarkerOnly())
2656 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2658 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2659 CmdArgs.push_back(
"-as-secure-log-file");
2660 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2665 bool OFastEnabled,
const ArgList &Args,
2666 ArgStringList &CmdArgs,
2673 bool HonorINFs =
true;
2674 bool HonorNaNs =
true;
2675 bool ApproxFunc =
false;
2678 bool AssociativeMath =
false;
2679 bool ReciprocalMath =
false;
2680 bool SignedZeros =
true;
2681 bool TrappingMath =
false;
2682 bool TrappingMathPresent =
false;
2684 bool RoundingFPMath =
false;
2685 bool RoundingMathPresent =
false;
2687 StringRef FPModel =
"";
2689 StringRef FPExceptionBehavior =
"";
2691 StringRef FPEvalMethod =
"";
2692 const llvm::DenormalMode DefaultDenormalFPMath =
2694 const llvm::DenormalMode DefaultDenormalFP32Math =
2697 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
2698 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
2701 StringRef FPContract;
2702 StringRef LastSeenFfpContractOption;
2703 bool SeenUnsafeMathModeOption =
false;
2707 bool StrictFPModel =
false;
2708 StringRef Float16ExcessPrecision =
"";
2710 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2711 CmdArgs.push_back(
"-mlimit-float-precision");
2712 CmdArgs.push_back(A->getValue());
2715 for (
const Arg *A : Args) {
2716 auto optID = A->getOption().getID();
2717 bool PreciseFPModel =
false;
2721 case options::OPT_ffp_model_EQ: {
2728 AssociativeMath =
false;
2729 ReciprocalMath =
false;
2733 DenormalFPMath = llvm::DenormalMode::getIEEE();
2737 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2739 StringRef Val = A->getValue();
2740 if (OFastEnabled && !Val.equals(
"fast")) {
2742 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2743 << Args.MakeArgString(
"-ffp-model=" + Val)
2747 StrictFPModel =
false;
2748 PreciseFPModel =
true;
2752 if (!FPModel.empty() && !FPModel.equals(Val))
2753 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2754 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2755 << Args.MakeArgString(
"-ffp-model=" + Val);
2756 if (Val.equals(
"fast")) {
2757 optID = options::OPT_ffast_math;
2759 FPContract =
"fast";
2760 }
else if (Val.equals(
"precise")) {
2761 optID = options::OPT_ffp_contract;
2764 PreciseFPModel =
true;
2765 }
else if (Val.equals(
"strict")) {
2766 StrictFPModel =
true;
2767 optID = options::OPT_frounding_math;
2768 FPExceptionBehavior =
"strict";
2771 TrappingMath =
true;
2773 D.
Diag(diag::err_drv_unsupported_option_argument)
2774 << A->getSpelling() << Val;
2784 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2785 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2786 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2787 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2788 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2789 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2790 case options::OPT_fmath_errno: MathErrno =
true;
break;
2791 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2792 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2793 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2794 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2795 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2796 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2797 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2798 case options::OPT_ftrapping_math:
2799 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2800 !FPExceptionBehavior.equals(
"strict"))
2802 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2803 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2804 <<
"-ftrapping-math";
2805 TrappingMath =
true;
2806 TrappingMathPresent =
true;
2807 FPExceptionBehavior =
"strict";
2809 case options::OPT_fno_trapping_math:
2810 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2811 !FPExceptionBehavior.equals(
"ignore"))
2813 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2814 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2815 <<
"-fno-trapping-math";
2816 TrappingMath =
false;
2817 TrappingMathPresent =
true;
2818 FPExceptionBehavior =
"ignore";
2821 case options::OPT_frounding_math:
2822 RoundingFPMath =
true;
2823 RoundingMathPresent =
true;
2826 case options::OPT_fno_rounding_math:
2827 RoundingFPMath =
false;
2828 RoundingMathPresent =
false;
2831 case options::OPT_fdenormal_fp_math_EQ:
2832 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
2833 DenormalFP32Math = DenormalFPMath;
2834 if (!DenormalFPMath.isValid()) {
2835 D.
Diag(diag::err_drv_invalid_value)
2836 << A->getAsString(Args) << A->getValue();
2840 case options::OPT_fdenormal_fp_math_f32_EQ:
2841 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
2842 if (!DenormalFP32Math.isValid()) {
2843 D.
Diag(diag::err_drv_invalid_value)
2844 << A->getAsString(Args) << A->getValue();
2849 case options::OPT_ffp_contract: {
2850 StringRef Val = A->getValue();
2851 if (PreciseFPModel) {
2856 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off")) {
2858 LastSeenFfpContractOption = Val;
2860 D.
Diag(diag::err_drv_unsupported_option_argument)
2861 << A->getSpelling() << Val;
2866 case options::OPT_ffp_model_EQ:
2873 case options::OPT_ffp_exception_behavior_EQ: {
2874 StringRef Val = A->getValue();
2875 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2876 !FPExceptionBehavior.equals(Val))
2878 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2879 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2880 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
2881 TrappingMath = TrappingMathPresent =
false;
2882 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
2883 FPExceptionBehavior = Val;
2884 else if (Val.equals(
"strict")) {
2885 FPExceptionBehavior = Val;
2886 TrappingMath = TrappingMathPresent =
true;
2888 D.
Diag(diag::err_drv_unsupported_option_argument)
2889 << A->getSpelling() << Val;
2894 case options::OPT_ffp_eval_method_EQ: {
2895 StringRef Val = A->getValue();
2896 if (Val.equals(
"double") || Val.equals(
"extended") ||
2897 Val.equals(
"source"))
2900 D.
Diag(diag::err_drv_unsupported_option_argument)
2901 << A->getSpelling() << Val;
2905 case options::OPT_fexcess_precision_EQ: {
2906 StringRef Val = A->getValue();
2907 const llvm::Triple::ArchType Arch = TC.
getArch();
2908 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
2909 if (Val.equals(
"standard") || Val.equals(
"fast"))
2910 Float16ExcessPrecision = Val;
2914 else if (Val.equals(
"16"))
2915 Float16ExcessPrecision =
"none";
2917 D.
Diag(diag::err_drv_unsupported_option_argument)
2918 << A->getSpelling() << Val;
2920 if (!(Val.equals(
"standard") || Val.equals(
"fast")))
2921 D.
Diag(diag::err_drv_unsupported_option_argument)
2922 << A->getSpelling() << Val;
2926 case options::OPT_ffinite_math_only:
2930 case options::OPT_fno_finite_math_only:
2935 case options::OPT_funsafe_math_optimizations:
2936 AssociativeMath =
true;
2937 ReciprocalMath =
true;
2938 SignedZeros =
false;
2940 TrappingMath =
false;
2941 FPExceptionBehavior =
"";
2942 FPContract =
"fast";
2943 SeenUnsafeMathModeOption =
true;
2945 case options::OPT_fno_unsafe_math_optimizations:
2946 AssociativeMath =
false;
2947 ReciprocalMath =
false;
2950 TrappingMath =
true;
2951 FPExceptionBehavior =
"strict";
2954 DenormalFPMath = llvm::DenormalMode::getIEEE();
2955 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2958 if (LastSeenFfpContractOption !=
"") {
2959 FPContract = LastSeenFfpContractOption;
2960 }
else if (SeenUnsafeMathModeOption)
2965 case options::OPT_Ofast:
2970 case options::OPT_ffast_math:
2974 AssociativeMath =
true;
2975 ReciprocalMath =
true;
2977 SignedZeros =
false;
2978 TrappingMath =
false;
2979 RoundingFPMath =
false;
2980 FPExceptionBehavior =
"";
2982 FPContract =
"fast";
2983 SeenUnsafeMathModeOption =
true;
2985 case options::OPT_fno_fast_math:
2992 AssociativeMath =
false;
2993 ReciprocalMath =
false;
2997 DenormalFPMath = DefaultDenormalFPMath;
2998 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3001 if (LastSeenFfpContractOption !=
"") {
3002 FPContract = LastSeenFfpContractOption;
3003 }
else if (SeenUnsafeMathModeOption)
3008 if (StrictFPModel) {
3011 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3012 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3013 DenormalFPMath == llvm::DenormalMode::getIEEE() &&
3014 DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
3015 FPContract.equals(
"off"))
3019 StrictFPModel =
false;
3021 auto RHS = (A->getNumValues() == 0)
3023 : Args.MakeArgString(A->getSpelling() + A->getValue());
3024 if (RHS !=
"-ffp-model=strict")
3025 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3026 <<
"-ffp-model=strict" << RHS;
3035 CmdArgs.push_back(
"-menable-no-infs");
3038 CmdArgs.push_back(
"-menable-no-nans");
3041 CmdArgs.push_back(
"-fapprox-func");
3044 CmdArgs.push_back(
"-fmath-errno");
3046 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3048 CmdArgs.push_back(
"-funsafe-math-optimizations");
3051 CmdArgs.push_back(
"-fno-signed-zeros");
3053 if (AssociativeMath && !SignedZeros && !TrappingMath)
3054 CmdArgs.push_back(
"-mreassociate");
3057 CmdArgs.push_back(
"-freciprocal-math");
3061 assert(FPExceptionBehavior.equals(
"strict"));
3065 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3067 llvm::raw_svector_ostream ArgStr(DenormFlag);
3068 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3069 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3073 if (DenormalFP32Math != DenormalFPMath) {
3075 llvm::raw_svector_ostream ArgStr(DenormFlag);
3076 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3077 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3080 if (!FPContract.empty())
3081 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3083 if (!RoundingFPMath)
3084 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3086 if (RoundingFPMath && RoundingMathPresent)
3087 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3089 if (!FPExceptionBehavior.empty())
3090 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3091 FPExceptionBehavior));
3093 if (!FPEvalMethod.empty())
3094 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3096 if (!Float16ExcessPrecision.empty())
3097 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3098 Float16ExcessPrecision));
3105 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3106 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3107 CmdArgs.push_back(
"-ffast-math");
3108 if (FPModel.equals(
"fast")) {
3109 if (FPContract.equals(
"fast"))
3112 else if (FPContract.empty())
3114 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3116 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3117 <<
"-ffp-model=fast"
3118 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3123 if (!HonorINFs && !HonorNaNs)
3124 CmdArgs.push_back(
"-ffinite-math-only");
3126 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3127 CmdArgs.push_back(
"-mfpmath");
3128 CmdArgs.push_back(A->getValue());
3132 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3133 options::OPT_fstrict_float_cast_overflow,
false))
3134 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3138 const llvm::Triple &Triple,
3141 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3142 CmdArgs.push_back(
"-analyzer-checker=core");
3143 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3145 if (!Triple.isWindowsMSVCEnvironment()) {
3146 CmdArgs.push_back(
"-analyzer-checker=unix");
3149 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3150 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3151 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3152 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3153 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3154 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3158 if (Triple.isPS()) {
3159 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3160 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3163 if (Triple.isOSDarwin()) {
3164 CmdArgs.push_back(
"-analyzer-checker=osx");
3166 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3168 else if (Triple.isOSFuchsia())
3169 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3171 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3174 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3176 if (!Triple.isPS()) {
3177 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3178 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3179 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3180 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3181 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3182 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3186 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3187 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3191 CmdArgs.push_back(
"-analyzer-output");
3192 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3193 CmdArgs.push_back(A->getValue());
3195 CmdArgs.push_back(
"plist");
3200 CmdArgs.push_back(
"-w");
3203 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3210 if (std::isdigit(S[0]))
3213 return llvm::all_of(S, [](
char C) {
return std::isalnum(C) || C ==
'_'; });
3217 const ArgList &Args, ArgStringList &CmdArgs,
3218 bool KernelOrKext) {
3223 if (EffectiveTriple.isNVPTX())
3231 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3232 options::OPT_fstack_protector_all,
3233 options::OPT_fstack_protector_strong,
3234 options::OPT_fstack_protector)) {
3235 if (A->getOption().matches(options::OPT_fstack_protector))
3236 StackProtectorLevel =
3238 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3240 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3244 D.
Diag(diag::warn_drv_unsupported_option_for_target)
3245 << A->getSpelling() << EffectiveTriple.getTriple();
3246 StackProtectorLevel = DefaultStackProtectorLevel;
3249 StackProtectorLevel = DefaultStackProtectorLevel;
3252 if (StackProtectorLevel) {
3253 CmdArgs.push_back(
"-stack-protector");
3254 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3258 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3259 StringRef Str(A->getValue());
3260 if (Str.startswith(
"ssp-buffer-size=")) {
3261 if (StackProtectorLevel) {
3262 CmdArgs.push_back(
"-stack-protector-buffer-size");
3264 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3270 const std::string &TripleStr = EffectiveTriple.getTriple();
3271 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3272 StringRef
Value = A->getValue();
3273 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3274 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3275 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3276 << A->getAsString(Args) << TripleStr;
3277 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3278 EffectiveTriple.isThumb()) &&
3280 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3281 << A->getOption().getName() <<
Value <<
"tls global";
3284 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3286 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3287 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3288 << A->getAsString(Args);
3293 D.
Diag(diag::err_target_unsupported_tp_hard)
3294 << EffectiveTriple.getArchName();
3298 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3299 StringRef
Value = A->getValue();
3300 if (
Value !=
"cp15") {
3301 D.
Diag(diag::err_drv_argument_not_allowed_with)
3302 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3306 CmdArgs.push_back(
"-target-feature");
3307 CmdArgs.push_back(
"+read-tp-hard");
3309 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3310 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3311 << A->getOption().getName() <<
Value <<
"sysreg global";
3314 A->render(Args, CmdArgs);
3317 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3318 StringRef
Value = A->getValue();
3319 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3320 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3321 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3322 << A->getAsString(Args) << TripleStr;
3325 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3328 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3329 (Offset < 0 || Offset > 0xfffff)) {
3330 D.
Diag(diag::err_drv_invalid_int_value)
3331 << A->getOption().getName() <<
Value;
3334 A->render(Args, CmdArgs);
3337 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3338 StringRef
Value = A->getValue();
3339 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3340 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3341 << A->getAsString(Args) << TripleStr;
3342 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3343 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3344 << A->getOption().getName() <<
Value <<
"fs gs";
3347 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3348 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3351 A->render(Args, CmdArgs);
3354 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3355 StringRef
Value = A->getValue();
3357 D.
Diag(diag::err_drv_argument_only_allowed_with)
3358 << A->getOption().getName() <<
"legal symbol name";
3361 A->render(Args, CmdArgs);
3366 ArgStringList &CmdArgs) {
3369 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3372 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3373 !EffectiveTriple.isPPC64())
3376 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3377 options::OPT_fno_stack_clash_protection);
3382 const ArgList &Args,
3383 ArgStringList &CmdArgs) {
3385 StringRef TrivialAutoVarInit =
"";
3387 for (
const Arg *A : Args) {
3388 switch (A->getOption().getID()) {
3391 case options::OPT_ftrivial_auto_var_init: {
3393 StringRef Val = A->getValue();
3394 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3395 TrivialAutoVarInit = Val;
3397 D.
Diag(diag::err_drv_unsupported_option_argument)
3398 << A->getSpelling() << Val;
3404 if (TrivialAutoVarInit.empty())
3405 switch (DefaultTrivialAutoVarInit) {
3409 TrivialAutoVarInit =
"pattern";
3412 TrivialAutoVarInit =
"zero";
3416 if (!TrivialAutoVarInit.empty()) {
3418 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3422 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3423 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3425 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3427 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3429 StringRef Val = A->getValue();
3430 if (std::stoi(Val.str()) <= 0)
3431 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3433 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3441 const unsigned ForwardedArguments[] = {
3442 options::OPT_cl_opt_disable,
3443 options::OPT_cl_strict_aliasing,
3444 options::OPT_cl_single_precision_constant,
3445 options::OPT_cl_finite_math_only,
3446 options::OPT_cl_kernel_arg_info,
3447 options::OPT_cl_unsafe_math_optimizations,
3448 options::OPT_cl_fast_relaxed_math,
3449 options::OPT_cl_mad_enable,
3450 options::OPT_cl_no_signed_zeros,
3451 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3452 options::OPT_cl_uniform_work_group_size
3455 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3457 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3458 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3460 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
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,
3483 options::OPT_emit_llvm,
3484 options::OPT_emit_obj,
3485 options::OPT_disable_llvm_passes,
3486 options::OPT_fnative_half_type,
3487 options::OPT_hlsl_entrypoint};
3490 for (
const auto &Arg : ForwardedArguments)
3491 if (
const auto *A = Args.getLastArg(Arg))
3492 A->renderAsInput(Args, CmdArgs);
3494 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3495 !Args.hasArg(options::OPT_nostdinc))
3496 CmdArgs.push_back(
"-finclude-default-header");
3500 ArgStringList &CmdArgs) {
3501 bool ARCMTEnabled =
false;
3502 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3503 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3504 options::OPT_ccc_arcmt_modify,
3505 options::OPT_ccc_arcmt_migrate)) {
3506 ARCMTEnabled =
true;
3507 switch (A->getOption().getID()) {
3508 default: llvm_unreachable(
"missed a case");
3509 case options::OPT_ccc_arcmt_check:
3510 CmdArgs.push_back(
"-arcmt-action=check");
3512 case options::OPT_ccc_arcmt_modify:
3513 CmdArgs.push_back(
"-arcmt-action=modify");
3515 case options::OPT_ccc_arcmt_migrate:
3516 CmdArgs.push_back(
"-arcmt-action=migrate");
3517 CmdArgs.push_back(
"-mt-migrate-directory");
3518 CmdArgs.push_back(A->getValue());
3520 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3521 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3526 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3527 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3528 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3531 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3533 D.
Diag(diag::err_drv_argument_not_allowed_with)
3534 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3536 CmdArgs.push_back(
"-mt-migrate-directory");
3537 CmdArgs.push_back(A->getValue());
3539 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3540 options::OPT_objcmt_migrate_subscripting,
3541 options::OPT_objcmt_migrate_property)) {
3543 CmdArgs.push_back(
"-objcmt-migrate-literals");
3544 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3545 CmdArgs.push_back(
"-objcmt-migrate-property");
3547 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3548 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3549 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3552 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3553 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3554 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3555 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3556 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3557 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3558 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3559 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3560 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3561 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3562 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3563 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3564 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3565 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3566 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3567 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3572 const ArgList &Args, ArgStringList &CmdArgs) {
3575 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3576 !Args.hasArg(options::OPT_mkernel));
3578 CmdArgs.push_back(
"-fno-builtin");
3581 if (Args.hasArg(options::OPT_ffreestanding))
3582 UseBuiltins =
false;
3585 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3591 A->render(Args, CmdArgs);
3597 if (TC.
getArch() == llvm::Triple::le32)
3598 CmdArgs.push_back(
"-fno-math-builtin");
3602 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
3604 Path.toVector(Result);
3605 return Path.getSingleStringRef() !=
"";
3607 if (llvm::sys::path::cache_directory(Result)) {
3608 llvm::sys::path::append(Result,
"clang");
3609 llvm::sys::path::append(Result,
"ModuleCache");
3616 const ArgList &Args,
const InputInfo &Input,
3618 ArgStringList &CmdArgs) {
3622 bool HaveStdCXXModules =
3624 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"c++20") ||
3625 Std->containsValue(
"c++2b") ||
Std->containsValue(
"c++latest"));
3626 bool HaveModules = HaveStdCXXModules;
3631 bool HaveClangModules =
false;
3632 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3633 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3634 options::OPT_fno_cxx_modules,
true);
3635 if (AllowedInCXX || !IsCXX) {
3636 CmdArgs.push_back(
"-fmodules");
3637 HaveClangModules =
true;
3641 HaveModules |= HaveClangModules;
3642 if (Args.hasArg(options::OPT_fmodules_ts)) {
3643 D.
Diag(diag::warn_deprecated_fmodules_ts_flag);
3644 CmdArgs.push_back(
"-fmodules-ts");
3650 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3651 options::OPT_fno_implicit_module_maps, HaveClangModules))
3652 CmdArgs.push_back(
"-fimplicit-module-maps");
3655 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3656 options::OPT_fno_modules_decluse);
3660 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3661 options::OPT_fno_modules_strict_decluse,
false))
3662 CmdArgs.push_back(
"-fmodules-strict-decluse");
3665 bool ImplicitModules =
false;
3666 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3667 options::OPT_fno_implicit_modules, HaveClangModules)) {
3669 CmdArgs.push_back(
"-fno-implicit-modules");
3670 }
else if (HaveModules) {
3671 ImplicitModules =
true;
3675 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3676 Path = A->getValue();
3678 bool HasPath =
true;
3679 if (C.isForDiagnostics()) {
3683 llvm::sys::path::replace_extension(Path,
".cache");
3684 llvm::sys::path::append(Path,
"modules");
3685 }
else if (Path.empty()) {
3693 const char Arg[] =
"-fmodules-cache-path=";
3694 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3695 CmdArgs.push_back(Args.MakeArgString(Path));
3701 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3702 CmdArgs.push_back(Args.MakeArgString(
3703 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3706 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3707 options::OPT_fno_prebuilt_implicit_modules,
false))
3708 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3709 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3710 options::OPT_fno_modules_validate_input_files_content,
3712 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3717 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3721 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3725 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3727 llvm::sys::path::append(BuiltinModuleMap,
"include");
3728 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3729 if (llvm::sys::fs::exists(BuiltinModuleMap))
3731 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3739 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3741 Args.ClaimAllArgs(options::OPT_fmodule_file);
3745 if (HaveClangModules && C.isForDiagnostics()) {
3747 llvm::sys::path::replace_extension(VFSDir,
".cache");
3749 C.addTempFile(Args.MakeArgString(VFSDir));
3751 llvm::sys::path::append(VFSDir,
"vfs");
3752 CmdArgs.push_back(
"-module-dependency-dir");
3753 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3756 if (HaveClangModules)
3757 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3760 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3761 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3762 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3764 if (HaveClangModules) {
3765 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3767 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3768 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3769 D.
Diag(diag::err_drv_argument_not_allowed_with)
3770 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3772 llvm::sys::fs::file_status Status;
3773 if (llvm::sys::fs::status(A->getValue(), Status))
3774 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3775 CmdArgs.push_back(Args.MakeArgString(
3776 "-fbuild-session-timestamp=" +
3777 Twine((
uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3778 Status.getLastModificationTime().time_since_epoch())
3782 if (Args.getLastArg(
3783 options::OPT_fmodules_validate_once_per_build_session)) {
3784 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3785 options::OPT_fbuild_session_file))
3786 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3788 Args.AddLastArg(CmdArgs,
3789 options::OPT_fmodules_validate_once_per_build_session);
3792 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
3793 options::OPT_fno_modules_validate_system_headers,
3795 CmdArgs.push_back(
"-fmodules-validate-system-headers");
3797 Args.AddLastArg(CmdArgs,
3798 options::OPT_fmodules_disable_diagnostic_validation);
3800 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
3801 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
3802 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
3803 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
3804 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
3805 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
3809 Args.ClaimAllArgs(options::OPT_fmodule_output);
3810 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
3816 ArgStringList &CmdArgs) {
3818 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
3819 options::OPT_fno_signed_char,
3820 options::OPT_funsigned_char,
3821 options::OPT_fno_unsigned_char)) {
3822 if (A->getOption().matches(options::OPT_funsigned_char) ||
3823 A->getOption().matches(options::OPT_fno_signed_char)) {
3824 CmdArgs.push_back(
"-fno-signed-char");
3827 CmdArgs.push_back(
"-fno-signed-char");
3831 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
3833 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3834 options::OPT_fno_short_wchar)) {
3835 if (A->getOption().matches(options::OPT_fshort_wchar)) {
3836 CmdArgs.push_back(
"-fwchar-type=short");
3837 CmdArgs.push_back(
"-fno-signed-wchar");
3839 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
3840 CmdArgs.push_back(
"-fwchar-type=int");
3842 (IsARM && !(T.isOSWindows() || T.isOSNetBSD() || T.isOSOpenBSD())))
3843 CmdArgs.push_back(
"-fno-signed-wchar");
3845 CmdArgs.push_back(
"-fsigned-wchar");
3851 const llvm::Triple &T,
const ArgList &Args,
3853 const InputInfo &Input, ArgStringList &CmdArgs) {
3854 const llvm::Triple::ArchType Arch = TC.
getArch();
3860 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3861 options::OPT_fno_objc_legacy_dispatch,
3864 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
3866 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
3872 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
3874 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
3881 CmdArgs.push_back(
"-fobjc-arc");
3888 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
3890 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
3895 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3896 options::OPT_fno_objc_arc_exceptions,
3898 CmdArgs.push_back(
"-fobjc-arc-exceptions");
3903 if (Args.hasArg(options::OPT_fno_objc_arc)) {
3904 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
3905 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
3911 auto *Arg = Args.getLastArg(
3912 options::OPT_fobjc_convert_messages_to_runtime_calls,
3913 options::OPT_fno_objc_convert_messages_to_runtime_calls);
3915 Arg->getOption().matches(
3916 options::OPT_fno_objc_convert_messages_to_runtime_calls))
3917 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
3922 if (InferCovariantReturns)
3923 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
3928 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
3932 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
3933 D.
Diag(diag::err_objc_weak_unsupported);
3935 WeakArg->render(Args, CmdArgs);
3939 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
3940 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
3944 ArgStringList &CmdArgs) {
3945 bool CaretDefault =
true;
3946 bool ColumnDefault =
true;
3948 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
3949 options::OPT__SLASH_diagnostics_column,
3950 options::OPT__SLASH_diagnostics_caret)) {
3951 switch (A->getOption().getID()) {
3952 case options::OPT__SLASH_diagnostics_caret:
3953 CaretDefault =
true;
3954 ColumnDefault =
true;
3956 case options::OPT__SLASH_diagnostics_column:
3957 CaretDefault =
false;
3958 ColumnDefault =
true;
3960 case options::OPT__SLASH_diagnostics_classic:
3961 CaretDefault =
false;
3962 ColumnDefault =
false;
3968 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3969 options::OPT_fno_caret_diagnostics, CaretDefault))
3970 CmdArgs.push_back(
"-fno-caret-diagnostics");
3972 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
3973 options::OPT_fno_diagnostics_fixit_info);
3974 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
3975 options::OPT_fno_diagnostics_show_option);
3978 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3979 CmdArgs.push_back(
"-fdiagnostics-show-category");
3980 CmdArgs.push_back(A->getValue());
3983 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
3984 options::OPT_fno_diagnostics_show_hotness);
3987 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
3989 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
3990 CmdArgs.push_back(Args.MakeArgString(Opt));
3993 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3994 CmdArgs.push_back(
"-fdiagnostics-format");
3995 CmdArgs.push_back(A->getValue());
3996 if (StringRef(A->getValue()) ==
"sarif" ||
3997 StringRef(A->getValue()) ==
"SARIF")
3998 D.
Diag(diag::warn_drv_sarif_format_unstable);
4001 if (
const Arg *A = Args.getLastArg(
4002 options::OPT_fdiagnostics_show_note_include_stack,
4003 options::OPT_fno_diagnostics_show_note_include_stack)) {
4004 const Option &O = A->getOption();
4005 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4006 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4008 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4015 Args.getLastArg(options::OPT_fcolor_diagnostics,
4016 options::OPT_fno_color_diagnostics);
4017 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4018 StringRef
Value(A->getValue());
4020 D.
Diag(diag::err_drv_invalid_argument_to_option)
4021 <<
Value << A->getOption().getName();
4025 CmdArgs.push_back(
"-fcolor-diagnostics");
4027 if (Args.hasArg(options::OPT_fansi_escape_codes))
4028 CmdArgs.push_back(
"-fansi-escape-codes");
4030 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4031 options::OPT_fno_show_source_location);
4033 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4034 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4036 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4038 CmdArgs.push_back(
"-fno-show-column");
4040 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4041 options::OPT_fno_spell_checking);
4045 const ArgList &Args, Arg *&Arg) {
4046 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4047 options::OPT_gno_split_dwarf);
4048 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4051 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4054 StringRef
Value = Arg->getValue();
4055 if (
Value ==
"split")
4057 if (
Value ==
"single")
4060 D.
Diag(diag::err_drv_unsupported_option_argument)
4061 << Arg->getSpelling() << Arg->getValue();
4066 const ArgList &Args, ArgStringList &CmdArgs,
4067 unsigned DwarfVersion) {
4068 auto *DwarfFormatArg =
4069 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4070 if (!DwarfFormatArg)
4073 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4074 if (DwarfVersion < 3)
4075 D.
Diag(diag::err_drv_argument_only_allowed_with)
4076 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4077 else if (!T.isArch64Bit())
4078 D.
Diag(diag::err_drv_argument_only_allowed_with)
4079 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4080 else if (!T.isOSBinFormatELF())
4081 D.
Diag(diag::err_drv_argument_only_allowed_with)
4082 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4085 DwarfFormatArg->render(Args, CmdArgs);
4089 const llvm::Triple &T,
const ArgList &Args,
4090 bool EmitCodeView,
bool IRInput,
4091 ArgStringList &CmdArgs,
4094 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4095 options::OPT_fno_debug_info_for_profiling,
false) &&
4097 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4098 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4111 bool SplitDWARFInlining =
4112 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4113 options::OPT_fno_split_dwarf_inlining,
false);
4118 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4124 SplitDWARFInlining =
false;
4127 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4132 A->getOption().matches(options::OPT_gN_Group)) {
4141 SplitDWARFInlining))
4147 bool HasDebuggerTuning =
false;
4149 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4150 HasDebuggerTuning =
true;
4152 if (A->getOption().matches(options::OPT_glldb))
4153 DebuggerTuning = llvm::DebuggerKind::LLDB;
4154 else if (A->getOption().matches(options::OPT_gsce))
4155 DebuggerTuning = llvm::DebuggerKind::SCE;
4156 else if (A->getOption().matches(options::OPT_gdbx))
4157 DebuggerTuning = llvm::DebuggerKind::DBX;
4159 DebuggerTuning = llvm::DebuggerKind::GDB;
4164 bool EmitDwarf =
false;
4168 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4173 if (!EmitCodeView && !EmitDwarf &&
4177 EmitCodeView =
true;
4185 unsigned RequestedDWARFVersion = 0;
4186 unsigned EffectiveDWARFVersion = 0;
4191 EffectiveDWARFVersion =
4194 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4198 if (RequestedDWARFVersion == 0 &&
4204 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4206 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4207 DebuggerTuning == llvm::DebuggerKind::DBX))
4208 CmdArgs.push_back(
"-gstrict-dwarf");
4211 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4219 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4221 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4223 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4224 DebuggerTuning != llvm::DebuggerKind::DBX)))
4225 CmdArgs.push_back(
"-gno-column-info");
4228 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4236 CmdArgs.push_back(
"-dwarf-ext-refs");
4237 CmdArgs.push_back(
"-fmodule-format=obj");
4242 if (T.isOSBinFormatELF() && SplitDWARFInlining)
4243 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4250 bool NeedFullDebug = Args.hasFlag(
4251 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4252 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4254 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4259 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4260 options::OPT_feliminate_unused_debug_types,
false))
4262 else if (NeedFullDebug)
4266 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4272 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4273 if (RequestedDWARFVersion < 5)
4274 D.
Diag(diag::err_drv_argument_only_allowed_with)
4275 << A->getAsString(Args) <<
"-gdwarf-5";
4276 else if (EffectiveDWARFVersion < 5)
4279 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4281 << EffectiveDWARFVersion;
4283 CmdArgs.push_back(
"-gembed-source");
4287 CmdArgs.push_back(
"-gcodeview");
4289 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4290 options::OPT_gno_codeview_ghash);
4292 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4293 options::OPT_gno_codeview_command_line);
4296 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4297 options::OPT_gno_inline_line_tables);
4310 T.isOSAIX() && !HasDebuggerTuning
4311 ? llvm::DebuggerKind::Default
4315 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4319 CmdArgs.push_back(
"-debug-info-macro");
4322 const auto *PubnamesArg =
4323 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4324 options::OPT_gpubnames, options::OPT_gno_pubnames);
4328 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4329 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
4330 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4331 options::OPT_gpubnames)
4333 :
"-ggnu-pubnames");
4334 const auto *SimpleTemplateNamesArg =
4335 Args.getLastArg(options::OPT_gsimple_template_names,
4336 options::OPT_gno_simple_template_names);
4337 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4338 if (SimpleTemplateNamesArg &&
4340 const auto &Opt = SimpleTemplateNamesArg->getOption();
4341 if (Opt.matches(options::OPT_gsimple_template_names)) {
4342 ForwardTemplateParams =
true;
4343 CmdArgs.push_back(
"-gsimple-template-names=simple");
4347 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4348 StringRef
v = A->getValue();
4349 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4352 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4353 options::OPT_fno_debug_ranges_base_address);
4358 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4359 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4362 CmdArgs.push_back(
"-mllvm");
4363 CmdArgs.push_back(
"-generate-arange-section");
4366 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4367 options::OPT_fno_force_dwarf_frame);
4369 if (Args.hasFlag(options::OPT_fdebug_types_section,
4370 options::OPT_fno_debug_types_section,
false)) {
4371 if (!(T.isOSBinFormatELF() || T.isOSBinFormatWasm())) {
4372 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4373 << Args.getLastArg(options::OPT_fdebug_types_section)
4377 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4379 CmdArgs.push_back(
"-mllvm");
4380 CmdArgs.push_back(
"-generate-type-units");
4387 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4388 options::OPT_fno_dwarf_directory_asm,
4390 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4394 if (ForwardTemplateParams)
4395 CmdArgs.push_back(
"-debug-forward-template-params");
4399 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4400 CmdArgs.push_back(
"-dwarf-explicit-import");
4407 ArgStringList &CmdArgs) {
4408 unsigned RTOptionID = options::OPT__SLASH_MT;
4410 if (Args.hasArg(options::OPT__SLASH_LDd))
4413 RTOptionID = options::OPT__SLASH_MTd;
4415 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4416 RTOptionID = A->getOption().getID();
4418 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4419 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4420 .Case(
"static", options::OPT__SLASH_MT)
4421 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4422 .Case(
"dll", options::OPT__SLASH_MD)
4423 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4424 .Default(options::OPT__SLASH_MT);
4427 StringRef FlagForCRT;
4428 switch (RTOptionID) {
4429 case options::OPT__SLASH_MD:
4430 if (Args.hasArg(options::OPT__SLASH_LDd))
4431 CmdArgs.push_back(
"-D_DEBUG");
4432 CmdArgs.push_back(
"-D_MT");
4433 CmdArgs.push_back(
"-D_DLL");
4434 FlagForCRT =
"--dependent-lib=msvcrt";
4436 case options::OPT__SLASH_MDd:
4437 CmdArgs.push_back(
"-D_DEBUG");
4438 CmdArgs.push_back(
"-D_MT");
4439 CmdArgs.push_back(
"-D_DLL");
4440 FlagForCRT =
"--dependent-lib=msvcrtd";
4442 case options::OPT__SLASH_MT:
4443 if (Args.hasArg(options::OPT__SLASH_LDd))
4444 CmdArgs.push_back(
"-D_DEBUG");
4445 CmdArgs.push_back(
"-D_MT");
4446 CmdArgs.push_back(
"-flto-visibility-public-std");
4447 FlagForCRT =
"--dependent-lib=libcmt";
4449 case options::OPT__SLASH_MTd:
4450 CmdArgs.push_back(
"-D_DEBUG");
4451 CmdArgs.push_back(
"-D_MT");
4452 CmdArgs.push_back(
"-flto-visibility-public-std");
4453 FlagForCRT =
"--dependent-lib=libcmtd";
4456 llvm_unreachable(
"Unexpected option ID.");
4459 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4460 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4462 CmdArgs.push_back(FlagForCRT.data());
4467 CmdArgs.push_back(
"--dependent-lib=oldnames");
4473 const ArgList &Args,
const char *LinkingOutput)
const {
4474 const auto &TC = getToolChain();
4475 const llvm::Triple &RawTriple = TC.
getTriple();
4477 const std::string &TripleStr = Triple.getTriple();
4480 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4482 ArgStringList CmdArgs;
4484 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4496 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4499 bool IsHostOffloadingAction =
4502 Args.hasFlag(options::OPT_offload_new_driver,
4503 options::OPT_no_offload_new_driver,
false));
4506 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4507 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4508 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4512 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4516 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4520 const InputInfo *CudaDeviceInput =
nullptr;
4521 const InputInfo *OpenMPDeviceInput =
nullptr;
4523 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4525 }
else if (IsExtractAPI) {
4526 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4527 if (I.getType() != ExpectedInputType) {
4528 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4532 ExtractAPIInputs.push_back(I);
4533 }
else if (IsHostOffloadingAction) {
4534 HostOffloadingInputs.push_back(I);
4535 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4536 CudaDeviceInput = &I;
4537 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4538 OpenMPDeviceInput = &I;
4540 llvm_unreachable(
"unexpectedly given multiple inputs");
4544 const llvm::Triple *AuxTriple =
4546 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4547 bool IsIAMCU = RawTriple.isOSIAMCU();
4552 if (IsCuda || IsHIP)
4553 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4557 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4562 CmdArgs.push_back(
"-cc1");
4565 CmdArgs.push_back(
"-triple");
4566 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4568 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4569 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
4570 Args.ClaimAllArgs(options::OPT_MJ);
4571 }
else if (
const Arg *GenCDBFragment =
4572 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4573 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(), C,
4574 TripleStr, Output, Input, Args);
4575 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4578 if (IsCuda || IsHIP) {
4599 assert(CTC &&
"Expected valid CUDA Toolchain.");
4601 CmdArgs.push_back(Args.MakeArgString(
4602 Twine(
"-target-sdk-version=") +
4606 CmdArgs.push_back(
"-aux-triple");
4607 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4610 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4611 CmdArgs.push_back(
"-fsycl-is-device");
4613 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4614 A->render(Args, CmdArgs);
4617 CmdArgs.push_back(
"-sycl-std=2020");
4621 if (IsOpenMPDevice) {
4627 CmdArgs.push_back(
"-aux-triple");
4628 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4631 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4632 Triple.getArch() == llvm::Triple::thumb)) {
4633 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4634 unsigned Version = 0;
4636 Triple.getArchName().substr(
Offset).consumeInteger(10, Version);
4637 if (Failure || Version < 7)
4638 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4648 if (Triple.isSPIR() || Triple.isSPIRV())
4649 CmdArgs.push_back(
"-Wspir-compat");
4652 RewriteKind rewriteKind = RK_None;
4661 if (!isa<AssembleJobAction>(JA)) {
4665 Args.ClaimAllArgs(options::OPT_mrelax_all);
4666 Args.ClaimAllArgs(options::OPT_mno_relax_all);
4667 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4668 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4669 switch (C.getDefaultToolChain().getArch()) {
4670 case llvm::Triple::arm:
4671 case llvm::Triple::armeb:
4672 case llvm::Triple::thumb:
4673 case llvm::Triple::thumbeb:
4674 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4680 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4681 Args.ClaimAllArgs(options::OPT_Xassembler);
4682 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
4685 if (isa<AnalyzeJobAction>(JA)) {
4686 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
4687 CmdArgs.push_back(
"-analyze");
4688 }
else if (isa<MigrateJobAction>(JA)) {
4689 CmdArgs.push_back(
"-migrate");
4690 }
else if (isa<PreprocessJobAction>(JA)) {
4691 if (Output.
getType() == types::TY_Dependencies)
4692 CmdArgs.push_back(
"-Eonly");
4694 CmdArgs.push_back(
"-E");
4695 if (Args.hasArg(options::OPT_rewrite_objc) &&
4696 !Args.hasArg(options::OPT_g_Group))
4697 CmdArgs.push_back(
"-P");
4698 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
4699 CmdArgs.push_back(
"-fdirectives-only");
4701 }
else if (isa<AssembleJobAction>(JA)) {
4702 CmdArgs.push_back(
"-emit-obj");
4707 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4708 }
else if (isa<PrecompileJobAction>(JA)) {
4709 if (JA.
getType() == types::TY_Nothing)
4710 CmdArgs.push_back(
"-fsyntax-only");
4711 else if (JA.
getType() == types::TY_ModuleFile)
4712 CmdArgs.push_back(
"-emit-module-interface");
4713 else if (JA.
getType() == types::TY_HeaderUnit)
4714 CmdArgs.push_back(
"-emit-header-unit");
4716 CmdArgs.push_back(
"-emit-pch");
4717 }
else if (isa<VerifyPCHJobAction>(JA)) {
4718 CmdArgs.push_back(
"-verify-pch");
4719 }
else if (isa<ExtractAPIJobAction>(JA)) {
4720 assert(JA.
getType() == types::TY_API_INFO &&
4721 "Extract API actions must generate a API information.");
4722 CmdArgs.push_back(
"-extract-api");
4723 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
4724 ProductNameArg->render(Args, CmdArgs);
4725 if (Arg *ExtractAPIIgnoresFileArg =
4726 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
4727 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
4729 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
4730 "Invalid action for clang tool.");
4731 if (JA.
getType() == types::TY_Nothing) {
4732 CmdArgs.push_back(
"-fsyntax-only");
4733 }
else if (JA.
getType() == types::TY_LLVM_IR ||
4734 JA.
getType() == types::TY_LTO_IR) {
4735 CmdArgs.push_back(
"-emit-llvm");
4736 }
else if (JA.
getType() == types::TY_LLVM_BC ||
4737 JA.
getType() == types::TY_LTO_BC) {
4739 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
4740 Args.hasArg(options::OPT_emit_llvm)) {
4741 CmdArgs.push_back(
"-emit-llvm");
4743 CmdArgs.push_back(
"-emit-llvm-bc");
4745 }
else if (JA.
getType() == types::TY_IFS ||
4746 JA.
getType() == types::TY_IFS_CPP) {
4748 Args.hasArg(options::OPT_interface_stub_version_EQ)
4749 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
4751 CmdArgs.push_back(
"-emit-interface-stubs");
4753 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
4754 }
else if (JA.
getType() == types::TY_PP_Asm) {
4755 CmdArgs.push_back(
"-S");
4756 }
else if (JA.
getType() == types::TY_AST) {
4757 CmdArgs.push_back(
"-emit-pch");
4758 }
else if (JA.
getType() == types::TY_ModuleFile) {
4759 CmdArgs.push_back(
"-module-file-info");
4760 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
4761 CmdArgs.push_back(
"-rewrite-objc");
4762 rewriteKind = RK_NonFragile;
4763 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
4764 CmdArgs.push_back(
"-rewrite-objc");
4765 rewriteKind = RK_Fragile;
4767 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
4774 if (JA.
getType() == types::TY_LLVM_BC)
4775 CmdArgs.push_back(
"-emit-llvm-uselists");
4779 !Args.hasFlag(options::OPT_offload_new_driver,
4780 options::OPT_no_offload_new_driver,
false) &&
4781 !Triple.isAMDGPU()) {
4782 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4783 << Args.getLastArg(options::OPT_foffload_lto,
4784 options::OPT_foffload_lto_EQ)
4786 << Triple.getTriple();
4787 }
else if (Triple.isNVPTX() && !IsRDCMode &&
4789 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
4790 << Args.getLastArg(options::OPT_foffload_lto,
4791 options::OPT_foffload_lto_EQ)
4796 CmdArgs.push_back(Args.MakeArgString(
4797 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
4798 CmdArgs.push_back(
"-flto-unit");
4803 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
4805 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
4806 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
4809 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
4810 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
4812 if (Args.getLastArg(options::OPT_save_temps_EQ))
4813 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
4815 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
4816 options::OPT_fmemory_profile_EQ,
4817 options::OPT_fno_memory_profile);
4819 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
4820 MemProfArg->render(Args, CmdArgs);
4824 if (C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
4825 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
4827 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
4829 CmdArgs.push_back(
"-disable-llvm-passes");
4836 static const constexpr
unsigned kBitcodeOptionIgnorelist[] = {
4837 options::OPT_mkernel,
4838 options::OPT_fapple_kext,
4839 options::OPT_ffunction_sections,
4840 options::OPT_fno_function_sections,
4841 options::OPT_fdata_sections,
4842 options::OPT_fno_data_sections,
4843 options::OPT_fbasic_block_sections_EQ,
4844 options::OPT_funique_internal_linkage_names,
4845 options::OPT_fno_unique_internal_linkage_names,
4846 options::OPT_funique_section_names,
4847 options::OPT_fno_unique_section_names,
4848 options::OPT_funique_basic_block_section_names,
4849 options::OPT_fno_unique_basic_block_section_names,
4850 options::OPT_mrestrict_it,
4851 options::OPT_mno_restrict_it,
4852 options::OPT_mstackrealign,
4853 options::OPT_mno_stackrealign,
4854 options::OPT_mstack_alignment,
4855 options::OPT_mcmodel_EQ,
4856 options::OPT_mlong_calls,
4857 options::OPT_mno_long_calls,
4858 options::OPT_ggnu_pubnames,
4859 options::OPT_gdwarf_aranges,
4860 options::OPT_fdebug_types_section,
4861 options::OPT_fno_debug_types_section,
4862 options::OPT_fdwarf_directory_asm,
4863 options::OPT_fno_dwarf_directory_asm,
4864 options::OPT_mrelax_all,
4865 options::OPT_mno_relax_all,
4866 options::OPT_ftrap_function_EQ,
4867 options::OPT_ffixed_r9,
4868 options::OPT_mfix_cortex_a53_835769,
4869 options::OPT_mno_fix_cortex_a53_835769,
4870 options::OPT_ffixed_x18,
4871 options::OPT_mglobal_merge,
4872 options::OPT_mno_global_merge,
4873 options::OPT_mred_zone,
4874 options::OPT_mno_red_zone,
4875 options::OPT_Wa_COMMA,
4876 options::OPT_Xassembler,
4879 for (
const auto &A : Args)
4880 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
4881 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
4884 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
4885 options::OPT_fno_optimize_sibling_calls);
4893 case llvm::Triple::arm:
4894 case llvm::Triple::armeb:
4895 case llvm::Triple::thumbeb:
4896 RenderARMABI(D, Triple, Args, CmdArgs);
4898 case llvm::Triple::aarch64:
4899 case llvm::Triple::aarch64_32:
4900 case llvm::Triple::aarch64_be:
4901 RenderAArch64ABI(Triple, Args, CmdArgs);
4906 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4907 if (A->getOption().matches(options::OPT_O4)) {
4908 CmdArgs.push_back(
"-O3");
4909 D.
Diag(diag::warn_O4_is_O3);
4911 A->render(Args, CmdArgs);
4916 if (Output.
getType() == types::TY_Dependencies) {
4919 CmdArgs.push_back(
"-o");
4922 assert(Output.
isNothing() &&
"Input output.");
4925 for (
const auto &II : Inputs) {
4927 if (II.isFilename())
4928 CmdArgs.push_back(II.getFilename());
4930 II.getInputArg().renderAsInput(Args, CmdArgs);
4933 C.addCommand(std::make_unique<Command>(
4935 CmdArgs, Inputs, Output));
4939 if (C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
4940 CmdArgs.push_back(
"-fembed-bitcode=marker");
4945 if (!C.isForDiagnostics())
4946 CmdArgs.push_back(
"-disable-free");
4947 CmdArgs.push_back(
"-clear-ast-before-backend");
4950 const bool IsAssertBuild =
false;
4952 const bool IsAssertBuild =
true;
4957 CmdArgs.push_back(
"-disable-llvm-verifier");
4960 if (Args.hasFlag(options::OPT_fdiscard_value_names,
4961 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
4962 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
4964 return types::isLLVMIR(II.getType());
4966 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
4968 CmdArgs.push_back(
"-discard-value-names");
4973 CmdArgs.push_back(
"-main-file-name");
4974 CmdArgs.push_back(getBaseInputName(Args, Input));
4978 if (Args.hasArg(options::OPT_static))
4979 CmdArgs.push_back(
"-static-define");
4981 if (Args.hasArg(options::OPT_municode))
4982 CmdArgs.push_back(
"-DUNICODE");
4984 if (isa<AnalyzeJobAction>(JA))
4987 if (isa<AnalyzeJobAction>(JA) ||
4988 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
4989 CmdArgs.push_back(
"-setup-static-analyzer");
4994 bool FoundAnalyzerConfig =
false;
4995 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
4996 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
4997 FoundAnalyzerConfig =
true;
5000 if (!FoundAnalyzerConfig)
5001 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5002 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5003 FoundAnalyzerConfig =
true;
5006 if (FoundAnalyzerConfig)
5007 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5012 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5013 if (FunctionAlignment) {
5014 CmdArgs.push_back(
"-function-alignment");
5015 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5020 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5022 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5024 << A->getAsString(Args) << A->getValue();
5026 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5027 << A->getAsString(Args) << A->getValue();
5030 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5034 llvm::Reloc::Model RelocationModel;
5037 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5038 Arg *LastPICDataRelArg =
5039 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5040 options::OPT_mpic_data_is_text_relative);
5041 bool NoPICDataIsTextRelative =
false;
5042 if (LastPICDataRelArg) {
5043 if (LastPICDataRelArg->getOption().matches(
5044 options::OPT_mno_pic_data_is_text_relative)) {
5045 NoPICDataIsTextRelative =
true;
5047 D.
Diag(diag::err_drv_argument_only_allowed_with)
5048 <<
"-mno-pic-data-is-text-relative"
5051 if (!Triple.isSystemZ())
5052 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5053 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5054 :
"-mpic-data-is-text-relative")
5058 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5059 RelocationModel == llvm::Reloc::ROPI_RWPI;
5060 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5061 RelocationModel == llvm::Reloc::ROPI_RWPI;
5063 if (Args.hasArg(options::OPT_mcmse) &&
5064 !Args.hasArg(options::OPT_fallow_unsupported)) {
5066 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5068 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5072 !Args.hasArg(options::OPT_fallow_unsupported))
5073 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5077 CmdArgs.push_back(
"-mrelocation-model");
5078 CmdArgs.push_back(RMName);
5081 CmdArgs.push_back(
"-pic-level");
5082 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5084 CmdArgs.push_back(
"-pic-is-pie");
5085 if (NoPICDataIsTextRelative)
5086 CmdArgs.push_back(
"-mcmodel=medium");
5089 if (RelocationModel == llvm::Reloc::ROPI ||
5090 RelocationModel == llvm::Reloc::ROPI_RWPI)
5091 CmdArgs.push_back(
"-fropi");
5092 if (RelocationModel == llvm::Reloc::RWPI ||
5093 RelocationModel == llvm::Reloc::ROPI_RWPI)
5094 CmdArgs.push_back(
"-frwpi");
5096 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5097 CmdArgs.push_back(
"-meabi");
5098 CmdArgs.push_back(A->getValue());
5112 if (Triple.isOSBinFormatELF()) {
5113 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5114 options::OPT_fno_semantic_interposition);
5115 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5117 bool SupportsLocalAlias =
5118 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5120 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5121 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5122 A->render(Args, CmdArgs);
5123 else if (!SupportsLocalAlias)
5124 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5130 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5132 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5133 << A->getValue() << A->getAsString(Args);
5134 Model = A->getValue();
5137 if (Model !=
"posix") {
5138 CmdArgs.push_back(
"-mthread-model");
5139 CmdArgs.push_back(Args.MakeArgString(Model));
5143 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5144 StringRef Name = A->getValue();
5145 if (Name ==
"SVML") {
5146 if (Triple.getArch() != llvm::Triple::x86 &&
5147 Triple.getArch() != llvm::Triple::x86_64)
5148 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5149 << Name << Triple.getArchName();
5150 }
else if (Name ==
"LIBMVEC-X86") {
5151 if (Triple.getArch() != llvm::Triple::x86 &&
5152 Triple.getArch() != llvm::Triple::x86_64)
5153 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5154 << Name << Triple.getArchName();
5155 }
else if (Name ==
"SLEEF") {
5156 if (Triple.getArch() != llvm::Triple::aarch64 &&
5157 Triple.getArch() != llvm::Triple::aarch64_be)
5158 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5159 << Name << Triple.getArchName();
5161 A->render(Args, CmdArgs);
5164 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5165 options::OPT_fno_merge_all_constants,
false))
5166 CmdArgs.push_back(
"-fmerge-all-constants");
5168 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5169 options::OPT_fno_delete_null_pointer_checks);
5173 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file_EQ)) {
5174 StringRef Map = A->getValue();
5175 if (!llvm::sys::fs::exists(Map)) {
5176 D.
Diag(diag::err_drv_no_such_file) << Map;
5178 A->render(Args, CmdArgs);
5183 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_vec_extabi,
5184 options::OPT_mabi_EQ_vec_default)) {
5185 if (!Triple.isOSAIX())
5186 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5187 << A->getSpelling() << RawTriple.str();
5188 if (A->getOption().getID() == options::OPT_mabi_EQ_vec_extabi)
5189 CmdArgs.push_back(
"-mabi=vec-extabi");
5191 CmdArgs.push_back(
"-mabi=vec-default");
5194 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5195 if (!Triple.isOSAIX() || Triple.isPPC32())
5196 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5197 << A->getSpelling() << RawTriple.str();
5198 CmdArgs.push_back(
"-mabi=quadword-atomics");
5201 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5204 if (Triple.isOSAIX())
5205 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5206 << A->getSpelling() << RawTriple.str();
5209 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5210 StringRef
v = A->getValue();
5214 D.
Diag(diag::err_drv_missing_argument) << A->getSpelling() << 1;
5216 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
v));
5220 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5221 options::OPT_fno_jump_tables);
5222 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5223 options::OPT_fno_profile_sample_accurate);
5224 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5225 options::OPT_fno_preserve_as_comments);
5227 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5228 CmdArgs.push_back(
"-mregparm");
5229 CmdArgs.push_back(A->getValue());
5232 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5233 options::OPT_msvr4_struct_return)) {
5235 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5236 << A->getSpelling() << RawTriple.str();
5237 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5238 CmdArgs.push_back(
"-maix-struct-return");
5240 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5241 CmdArgs.push_back(
"-msvr4-struct-return");
5245 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5246 options::OPT_freg_struct_return)) {
5247 if (TC.
getArch() != llvm::Triple::x86) {
5248 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5249 << A->getSpelling() << RawTriple.str();
5250 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5251 CmdArgs.push_back(
"-fpcc-struct-return");
5253 assert(A->getOption().matches(options::OPT_freg_struct_return));
5254 CmdArgs.push_back(
"-freg-struct-return");
5258 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
5259 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5261 if (Args.hasArg(options::OPT_fenable_matrix)) {
5263 CmdArgs.push_back(
"-fenable-matrix");
5264 CmdArgs.push_back(
"-mllvm");
5265 CmdArgs.push_back(
"-enable-matrix");
5270 const char *FPKeepKindStr =
nullptr;
5271 switch (FPKeepKind) {
5273 FPKeepKindStr =
"-mframe-pointer=none";
5276 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5279 FPKeepKindStr =
"-mframe-pointer=all";
5282 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5283 CmdArgs.push_back(FPKeepKindStr);
5285 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5286 options::OPT_fno_zero_initialized_in_bss);
5291 OptSpecifier StrictAliasingAliasOption =
5292 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5295 bool TBAAOnByDefault = !D.
IsCLMode();
5296 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5297 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5298 CmdArgs.push_back(
"-relaxed-aliasing");
5299 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5300 options::OPT_fno_struct_path_tbaa,
true))
5301 CmdArgs.push_back(
"-no-struct-path-tbaa");
5302 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5303 options::OPT_fno_strict_enums);
5304 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5305 options::OPT_fno_strict_return);
5306 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5307 options::OPT_fno_allow_editor_placeholders);
5308 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5309 options::OPT_fno_strict_vtable_pointers);
5310 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5311 options::OPT_fno_force_emit_vtables);
5312 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5313 options::OPT_fno_optimize_sibling_calls);
5314 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5315 options::OPT_fno_escaping_block_tail_calls);
5317 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5318 options::OPT_fno_fine_grained_bitfield_accesses);
5320 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5321 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5324 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5325 options::OPT_fno_split_stack);
5328 if (Args.hasFlag(options::OPT_fprotect_parens,
5329 options::OPT_fno_protect_parens,
false))
5330 CmdArgs.push_back(
"-fprotect-parens");
5334 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5335 const llvm::Triple::ArchType Arch = TC.
getArch();
5336 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5337 StringRef
V = A->getValue();
5339 CmdArgs.push_back(
"-fextend-arguments=64");
5341 D.
Diag(diag::err_drv_invalid_argument_to_option)
5342 << A->getValue() << A->getOption().getName();
5344 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5345 << A->getOption().getName() << TripleStr;
5348 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5349 if (TC.
getArch() == llvm::Triple::avr)
5350 A->render(Args, CmdArgs);
5352 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5353 << A->getAsString(Args) << TripleStr;
5356 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5358 A->render(Args, CmdArgs);
5360 (A->getOption().getID() != options::OPT_mlong_double_80))
5361 A->render(Args, CmdArgs);
5363 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5364 << A->getAsString(Args) << TripleStr;
5370 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5371 IsIntegratedAssemblerDefault))
5372 CmdArgs.push_back(
"-fno-verbose-asm");
5376 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5377 StringRef
V = A->getValue();
5380 A->render(Args, CmdArgs);
5381 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5382 (
V.empty() || (
V.consume_front(
".") &&
5383 !
V.consumeInteger(10, Num) &&
V.empty())))
5384 A->render(Args, CmdArgs);
5386 D.
Diag(diag::err_drv_invalid_argument_to_option)
5387 << A->getValue() << A->getOption().getName();
5393 CmdArgs.push_back(
"-no-integrated-as");
5395 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5396 CmdArgs.push_back(
"-mdebug-pass");
5397 CmdArgs.push_back(
"Structure");
5399 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5400 CmdArgs.push_back(
"-mdebug-pass");
5401 CmdArgs.push_back(
"Arguments");
5407 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5408 CmdArgs.push_back(
"-mconstructor-aliases");
5412 if (KernelOrKext && RawTriple.isOSDarwin())
5413 CmdArgs.push_back(
"-fforbid-guard-variables");
5415 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5416 Triple.isWindowsGNUEnvironment())) {
5417 CmdArgs.push_back(
"-mms-bitfields");
5423 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5424 options::OPT_fno_direct_access_external_data))
5425 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5427 A->render(Args, CmdArgs);
5429 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5430 CmdArgs.push_back(
"-fno-plt");
5437 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5440 CmdArgs.push_back(
"-ffreestanding");
5442 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5449 bool IsAsyncUnwindTablesDefault =
5451 bool IsSyncUnwindTablesDefault =
5454 bool AsyncUnwindTables = Args.hasFlag(
5455 options::OPT_fasynchronous_unwind_tables,
5456 options::OPT_fno_asynchronous_unwind_tables,
5457 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5460 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5461 IsSyncUnwindTablesDefault && !Freestanding);
5462 if (AsyncUnwindTables)
5463 CmdArgs.push_back(
"-funwind-tables=2");
5464 else if (UnwindTables)
5465 CmdArgs.push_back(
"-funwind-tables=1");
5469 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5470 (IsCudaDevice || IsHIPDevice)) {
5471 const ArgList &HostArgs =
5475 if (!HostCPU.empty()) {
5476 CmdArgs.push_back(
"-aux-target-cpu");
5477 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5485 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5486 StringRef CM = A->getValue();
5487 if (CM ==
"small" || CM ==
"kernel" || CM ==
"medium" || CM ==
"large" ||
5489 if (Triple.isOSAIX() && CM ==
"medium")
5490 CmdArgs.push_back(
"-mcmodel=large");
5491 else if (Triple.isAArch64() && (CM ==
"kernel" || CM ==
"medium"))
5492 D.
Diag(diag::err_drv_invalid_argument_to_option)
5493 << CM << A->getOption().getName();
5495 A->render(Args, CmdArgs);
5497 D.
Diag(diag::err_drv_invalid_argument_to_option)
5498 << CM << A->getOption().getName();
5502 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5503 StringRef
Value = A->getValue();
5504 unsigned TLSSize = 0;
5505 Value.getAsInteger(10, TLSSize);
5506 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5507 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5508 << A->getOption().getName() << TripleStr;
5509 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5510 D.
Diag(diag::err_drv_invalid_int_value)
5511 << A->getOption().getName() <<
Value;
5512 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5518 CmdArgs.push_back(
"-target-cpu");
5519 CmdArgs.push_back(Args.MakeArgString(CPU));
5522 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5534 if (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5535 isa<BackendJobAction>(JA)) {
5536 CmdArgs.push_back(
"-mllvm");
5537 CmdArgs.push_back(
"-treat-scalable-fixed-error-as-warning");
5542 bool EmitCodeView =
false;
5547 AddClangCLArgs(Args, InputType, CmdArgs, &
DebugInfoKind, &EmitCodeView);
5555 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
5556 if (TC.
getTriple().isOSBinFormatELF()) {
5558 CmdArgs.push_back(
"-fjmc");
5560 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
5563 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
5572 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5573 isa<BackendJobAction>(JA));
5575 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
5576 CmdArgs.push_back(
"-split-dwarf-file");
5577 CmdArgs.push_back(SplitDWARFOut);
5579 CmdArgs.push_back(
"-split-dwarf-output");
5580 CmdArgs.push_back(SplitDWARFOut);
5585 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5586 CmdArgs.push_back(
"-target-linker-version");
5587 CmdArgs.push_back(A->getValue());
5592 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
5594 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
5595 TC.
getArch() == llvm::Triple::x86) {
5596 if ((
Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
5597 (
Unsupported = Args.getLastArg(options::OPT_mkernel)))
5598 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
5602 if ((
Unsupported = Args.getLastArg(options::OPT_faltivec)))
5603 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5605 <<
"please use -maltivec and include altivec.h explicitly";
5606 if ((
Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
5607 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5608 <<
Unsupported->getOption().getName() <<
"please use -mno-altivec";
5611 Args.AddAllArgs(CmdArgs, options::OPT_v);
5613 if (Args.getLastArg(options::OPT_H)) {
5614 CmdArgs.push_back(
"-H");
5615 CmdArgs.push_back(
"-sys-header-deps");
5617 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
5620 CmdArgs.push_back(
"-header-include-file");
5624 CmdArgs.push_back(
"-sys-header-deps");
5625 CmdArgs.push_back(Args.MakeArgString(
5626 "-header-include-format=" +
5629 Args.MakeArgString(
"-header-include-filtering=" +
5633 Args.AddLastArg(CmdArgs, options::OPT_P);
5634 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
5637 CmdArgs.push_back(
"-diagnostic-log-file");
5646 CmdArgs.push_back(
"-disable-pragma-debug-crash");
5650 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
5651 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
5652 CmdArgs.push_back(
"-mllvm");
5653 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
5658 if (Args.hasFlag(options::OPT_ffunction_sections,
5659 options::OPT_fno_function_sections, UseSeparateSections)) {
5660 CmdArgs.push_back(
"-ffunction-sections");
5663 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
5664 StringRef Val = A->getValue();
5665 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5666 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
5667 !Val.startswith(
"list="))
5668 D.
Diag(diag::err_drv_invalid_value)
5669 << A->getAsString(Args) << A->getValue();
5671 A->render(Args, CmdArgs);
5672 }
else if (Triple.isNVPTX()) {
5675 }
else if (Val !=
"none") {
5678 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5679 << A->getAsString(Args) << TripleStr;
5683 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
5684 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
5685 UseSeparateSections || HasDefaultDataSections)) {
5686 CmdArgs.push_back(
"-fdata-sections");
5689 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
5690 options::OPT_fno_unique_section_names);
5691 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
5692 options::OPT_fno_unique_internal_linkage_names);
5693 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
5694 options::OPT_fno_unique_basic_block_section_names);
5696 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
5697 options::OPT_fno_split_machine_functions)) {
5699 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5700 if (A->getOption().matches(options::OPT_fsplit_machine_functions))
5701 A->render(Args, CmdArgs);
5703 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5704 << A->getAsString(Args) << TripleStr;
5708 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
5709 options::OPT_finstrument_functions_after_inlining,
5710 options::OPT_finstrument_function_entry_bare);
5715 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
5718 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
5721 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
5722 CmdArgs.push_back(
"-mllvm");
5723 CmdArgs.push_back(
"-sample-profile-use-profi");
5727 if (RawTriple.isPS() &&
5728 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
5734 if (Args.hasArg(options::OPT_nostdinc)) {
5735 CmdArgs.push_back(
"-nostdsysteminc");
5736 CmdArgs.push_back(
"-nobuiltininc");
5738 if (Args.hasArg(options::OPT_nostdlibinc))
5739 CmdArgs.push_back(
"-nostdsysteminc");
5740 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
5741 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
5745 CmdArgs.push_back(
"-resource-dir");
5748 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
5757 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
5763 Args.ClaimAllArgs(options::OPT_D);
5766 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5767 if (A->getOption().matches(options::OPT_O4)) {
5768 CmdArgs.push_back(
"-O3");
5769 D.
Diag(diag::warn_O4_is_O3);
5771 A->render(Args, CmdArgs);
5777 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
5778 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
5783 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
5784 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
5790 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
5793 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
5795 if (A->getOption().getID() == options::OPT__SLASH_wd) {
5796 unsigned WarningNumber;
5797 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
5798 D.
Diag(diag::err_drv_invalid_int_value)
5799 << A->getAsString(Args) << A->getValue();
5804 CmdArgs.push_back(Args.MakeArgString(
5809 A->render(Args, CmdArgs);
5812 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
5813 CmdArgs.push_back(
"-pedantic");
5814 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
5815 Args.AddLastArg(CmdArgs, options::OPT_w);
5817 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
5818 options::OPT_fno_fixed_point);
5820 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
5821 A->render(Args, CmdArgs);
5823 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5824 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5826 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
5827 A->render(Args, CmdArgs);
5834 bool ImplyVCPPCVer =
false;
5835 bool ImplyVCPPCXXVer =
false;
5836 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
5838 if (
Std->getOption().matches(options::OPT_ansi))
5840 CmdArgs.push_back(
"-std=c++98");
5842 CmdArgs.push_back(
"-std=c89");
5844 Std->render(Args, CmdArgs);
5847 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
5848 options::OPT_ftrigraphs,
5849 options::OPT_fno_trigraphs))
5851 A->render(Args, CmdArgs);
5860 if (!Args.hasArg(options::OPT__SLASH_std)) {
5861 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
5864 ImplyVCPPCVer =
true;
5866 else if (IsWindowsMSVC)
5867 ImplyVCPPCXXVer =
true;
5869 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
5870 options::OPT_fno_trigraphs);
5886 Args.getLastArg(options::OPT_Wwrite_strings,
5887 options::OPT_Wno_write_strings, options::OPT_w);
5889 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
5890 CmdArgs.push_back(
"-fconst-strings");
5897 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
5899 CmdArgs.push_back(
"-fdeprecated-macro");
5903 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
5904 if (
Asm->getOption().matches(options::OPT_fasm))
5905 CmdArgs.push_back(
"-fgnu-keywords");
5907 CmdArgs.push_back(
"-fno-gnu-keywords");
5911 CmdArgs.push_back(
"-fno-autolink");
5914 const char *DebugCompilationDir =
5919 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
5920 options::OPT_ftemplate_depth_EQ)) {
5921 CmdArgs.push_back(
"-ftemplate-depth");
5922 CmdArgs.push_back(A->getValue());
5925 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
5926 CmdArgs.push_back(
"-foperator-arrow-depth");
5927 CmdArgs.push_back(A->getValue());
5930 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
5931 CmdArgs.push_back(
"-fconstexpr-depth");
5932 CmdArgs.push_back(A->getValue());
5935 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
5936 CmdArgs.push_back(
"-fconstexpr-steps");
5937 CmdArgs.push_back(A->getValue());
5940 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
5942 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
5943 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
5945 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
5946 CmdArgs.push_back(
"-fbracket-depth");
5947 CmdArgs.push_back(A->getValue());
5950 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
5951 options::OPT_Wlarge_by_value_copy_def)) {
5952 if (A->getNumValues()) {
5953 StringRef
bytes = A->getValue();
5954 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
5956 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
5959 if (Args.hasArg(options::OPT_relocatable_pch))
5960 CmdArgs.push_back(
"-relocatable-pch");
5962 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
5963 static const char *kCFABIs[] = {
5964 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
5967 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
5968 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
5970 A->render(Args, CmdArgs);
5973 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
5974 CmdArgs.push_back(
"-fconstant-string-class");
5975 CmdArgs.push_back(A->getValue());
5978 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
5979 CmdArgs.push_back(
"-ftabstop");
5980 CmdArgs.push_back(A->getValue());
5983 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
5984 options::OPT_fno_stack_size_section);
5986 if (Args.hasArg(options::OPT_fstack_usage)) {
5987 CmdArgs.push_back(
"-stack-usage-file");
5989 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
5991 llvm::sys::path::replace_extension(OutputFilename,
"su");
5992 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
5995 Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) +
".su"));
5998 CmdArgs.push_back(
"-ferror-limit");
5999 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6000 CmdArgs.push_back(A->getValue());
6002 CmdArgs.push_back(
"19");
6004 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
6005 CmdArgs.push_back(
"-fmacro-backtrace-limit");
6006 CmdArgs.push_back(A->getValue());
6009 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
6010 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
6011 CmdArgs.push_back(A->getValue());
6014 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
6015 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
6016 CmdArgs.push_back(A->getValue());
6019 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
6020 CmdArgs.push_back(
"-fspell-checking-limit");
6021 CmdArgs.push_back(A->getValue());
6025 unsigned MessageLength = 0;
6026 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6027 StringRef
V(A->getValue());
6028 if (
V.getAsInteger(0, MessageLength))
6029 D.
Diag(diag::err_drv_invalid_argument_to_option)
6030 <<
V << A->getOption().getName();
6034 MessageLength = llvm::sys::Process::StandardErrColumns();
6036 if (MessageLength != 0)
6038 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6040 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6042 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6044 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6045 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6046 Twine(A->getValue(0))));
6049 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6050 options::OPT_fvisibility_ms_compat)) {
6051 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6052 A->render(Args, CmdArgs);
6054 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6055 CmdArgs.push_back(
"-fvisibility=hidden");
6056 CmdArgs.push_back(
"-ftype-visibility=default");
6058 }
else if (IsOpenMPDevice) {
6062 CmdArgs.push_back(
"-fvisibility=protected");
6066 if (!RawTriple.isPS()) {
6068 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6069 options::OPT_fno_visibility_from_dllstorageclass)) {
6070 if (A->getOption().matches(
6071 options::OPT_fvisibility_from_dllstorageclass)) {
6072 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6073 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6074 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6075 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6076 Args.AddLastArg(CmdArgs,
6077 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6082 if (
const Arg *A = Args.getLastArg(options::OPT_mignore_xcoff_visibility)) {
6083 if (Triple.isOSAIX())
6084 CmdArgs.push_back(
"-mignore-xcoff-visibility");
6086 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6087 << A->getAsString(Args) << TripleStr;
6091 Args.getLastArg(options::OPT_mdefault_visibility_export_mapping_EQ)) {
6092 if (Triple.isOSAIX())
6093 A->render(Args, CmdArgs);
6095 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6096 << A->getAsString(Args) << TripleStr;
6099 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6100 options::OPT_fno_visibility_inlines_hidden,
false))
6101 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6103 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6104 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6105 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
6106 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6108 if (Args.hasFlag(options::OPT_fnew_infallible,
6109 options::OPT_fno_new_infallible,
false))
6110 CmdArgs.push_back(
"-fnew-infallible");
6112 if (Args.hasFlag(options::OPT_fno_operator_names,
6113 options::OPT_foperator_names,
false))
6114 CmdArgs.push_back(
"-fno-operator-names");
6117 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6118 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6119 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6120 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls,
6121 options::OPT_fno_emulated_tls);
6122 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6124 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6128 if (!Triple.isX86() && !Triple.isAArch64())
6129 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6130 << A->getAsString(Args) << TripleStr;
6134 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
6135 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6137 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6138 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6142 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6143 options::OPT_fno_openmp,
false) &&
6150 CmdArgs.push_back(
"-fopenmp");
6155 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6156 options::OPT_fnoopenmp_use_tls,
true))
6157 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6158 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6159 options::OPT_fno_openmp_simd);
6160 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6161 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6162 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6163 options::OPT_fno_openmp_extensions,
true))
6164 CmdArgs.push_back(
"-fno-openmp-extensions");
6165 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6166 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6167 Args.AddAllArgs(CmdArgs,
6168 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6169 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6170 options::OPT_fno_openmp_optimistic_collapse,
6172 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6176 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6177 options::OPT_fno_openmp_cuda_mode,
false))
6178 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6181 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6182 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6183 options::OPT_fno_openmp_target_debug,
false))
6184 CmdArgs.push_back(
"-fopenmp-target-debug");
6188 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6189 options::OPT_fno_openmp_assume_teams_oversubscription,
6191 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6192 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6193 options::OPT_fno_openmp_assume_threads_oversubscription,
6195 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6196 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6197 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6198 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6199 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6200 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6201 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6213 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6214 options::OPT_fno_openmp_simd);
6215 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6216 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6217 options::OPT_fno_openmp_extensions);
6221 if (Args.hasFlag(options::OPT_offload_new_driver,
6222 options::OPT_no_offload_new_driver,
false))
6223 CmdArgs.push_back(
"--offload-new-driver");
6225 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
6228 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6231 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6233 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" +
Filename));
6238 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6239 StringRef S0 = A->getValue(), S = S0;
6240 unsigned Size,
Offset = 0;
6241 if (!Triple.isAArch64() && !Triple.isRISCV() && !Triple.isX86())
6242 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6243 << A->getAsString(Args) << TripleStr;
6244 else if (S.consumeInteger(10, Size) ||
6245 (!S.empty() && (!S.consume_front(
",") ||
6246 S.consumeInteger(10,
Offset) || !S.empty())))
6247 D.
Diag(diag::err_drv_invalid_argument_to_option)
6248 << S0 << A->getOption().getName();
6250 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6252 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6253 CmdArgs.push_back(Args.MakeArgString(
6254 "-fpatchable-function-entry-offset=" + Twine(
Offset)));
6258 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6261 Args.AddLastArg(CmdArgs, options::OPT_pg);
6263 llvm::Triple::ArchType Arch = TC.
getArch();
6264 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6265 if (Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6266 A->render(Args, CmdArgs);<