35#include "clang/Config/config.h"
44#include "llvm/ADT/SmallSet.h"
45#include "llvm/ADT/StringExtras.h"
46#include "llvm/BinaryFormat/Magic.h"
47#include "llvm/Config/llvm-config.h"
48#include "llvm/Object/ObjectFile.h"
49#include "llvm/Option/ArgList.h"
50#include "llvm/Support/CodeGen.h"
51#include "llvm/Support/Compiler.h"
52#include "llvm/Support/Compression.h"
53#include "llvm/Support/Error.h"
54#include "llvm/Support/FileSystem.h"
55#include "llvm/Support/Path.h"
56#include "llvm/Support/Process.h"
57#include "llvm/Support/YAMLParser.h"
58#include "llvm/TargetParser/ARMTargetParserCommon.h"
59#include "llvm/TargetParser/Host.h"
60#include "llvm/TargetParser/LoongArchTargetParser.h"
61#include "llvm/TargetParser/RISCVISAInfo.h"
62#include "llvm/TargetParser/RISCVTargetParser.h"
71 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
72 options::OPT_fminimize_whitespace,
73 options::OPT_fno_minimize_whitespace,
74 options::OPT_fkeep_system_includes,
75 options::OPT_fno_keep_system_includes)) {
76 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
77 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
78 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
79 << A->getBaseArg().getAsString(Args)
80 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
87 if (Args.hasArg(options::OPT_static))
89 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
90 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
117 llvm::function_ref<
void(
const ToolChain &)> Work) {
119 Work(RegularToolChain);
134 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
149 const Arg &A,
size_t &Position) {
150 const char RefinementStepToken =
':';
151 Position = In.find(RefinementStepToken);
152 if (Position != StringRef::npos) {
153 StringRef Option = A.getOption().getName();
154 StringRef RefStep = In.substr(Position + 1);
162 if (RefStep.size() != 1) {
163 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
166 char RefStepChar = RefStep[0];
167 if (RefStepChar <
'0' || RefStepChar >
'9') {
168 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
177 ArgStringList &OutStrings) {
178 StringRef DisabledPrefixIn =
"!";
179 StringRef DisabledPrefixOut =
"!";
180 StringRef EnabledPrefixOut =
"";
181 StringRef Out =
"-mrecip=";
183 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
187 unsigned NumOptions = A->getNumValues();
188 if (NumOptions == 0) {
190 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
195 if (NumOptions == 1) {
196 StringRef Val = A->getValue(0);
200 StringRef ValBase = Val.slice(0, RefStepLoc);
201 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
202 OutStrings.push_back(Args.MakeArgString(Out + Val));
211 llvm::StringMap<bool> OptionStrings;
212 OptionStrings.insert(std::make_pair(
"divd",
false));
213 OptionStrings.insert(std::make_pair(
"divf",
false));
214 OptionStrings.insert(std::make_pair(
"divh",
false));
215 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
216 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
217 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
218 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
219 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
220 OptionStrings.insert(std::make_pair(
"sqrth",
false));
221 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
222 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
223 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
225 for (
unsigned i = 0; i != NumOptions; ++i) {
226 StringRef Val = A->getValue(i);
228 bool IsDisabled = Val.starts_with(DisabledPrefixIn);
237 StringRef ValBase = Val.slice(0, RefStep);
238 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
239 if (OptionIter == OptionStrings.end()) {
241 OptionIter = OptionStrings.find(ValBase.str() +
'f');
242 if (OptionIter == OptionStrings.end()) {
244 D.
Diag(diag::err_drv_unknown_argument) << Val;
250 if (OptionStrings[ValBase.str() +
'd'] ||
251 OptionStrings[ValBase.str() +
'h']) {
252 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
257 if (OptionIter->second ==
true) {
259 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
264 OptionIter->second =
true;
268 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
269 OptionStrings[ValBase.str() +
'd'] =
true;
270 OptionStrings[ValBase.str() +
'h'] =
true;
274 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
275 Out = Args.MakeArgString(Out + Prefix + Val);
276 if (i != NumOptions - 1)
277 Out = Args.MakeArgString(Out +
",");
280 OutStrings.push_back(Args.MakeArgString(Out));
286 ArgStringList &CmdArgs) {
287 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
291 StringRef
Value = A->getValue();
292 if (
Value ==
"none") {
293 CmdArgs.push_back(
"-mprefer-vector-width=none");
296 if (
Value.getAsInteger(10, Width)) {
297 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
300 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
306 const llvm::Triple &Triple) {
313 if (!Triple.isMacOSX())
316 return (!Triple.isMacOSXVersionLT(10, 5) &&
317 (Triple.getArch() == llvm::Triple::x86_64 ||
318 Triple.getArch() == llvm::Triple::arm));
328 ArgStringList &CmdArgs) {
329 const llvm::Triple &Triple = TC.
getTriple();
334 Args.ClaimAllArgs(options::OPT_fexceptions);
335 Args.ClaimAllArgs(options::OPT_fno_exceptions);
336 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
337 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
338 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
339 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
340 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
341 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
346 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
350 if (Triple.isWindowsMSVCEnvironment()) {
351 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
352 options::OPT_fno_async_exceptions,
false);
354 CmdArgs.push_back(
"-fasync-exceptions");
362 Args.hasFlag(options::OPT_fobjc_exceptions,
363 options::OPT_fno_objc_exceptions,
true)) {
364 CmdArgs.push_back(
"-fobjc-exceptions");
371 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
372 !Triple.isPS() && !Triple.isDriverKit();
373 Arg *ExceptionArg = Args.getLastArg(
374 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
375 options::OPT_fexceptions, options::OPT_fno_exceptions);
377 CXXExceptionsEnabled =
378 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
379 ExceptionArg->getOption().matches(options::OPT_fexceptions);
381 if (CXXExceptionsEnabled) {
382 CmdArgs.push_back(
"-fcxx-exceptions");
391 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
393 Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,
394 options::OPT_fno_assume_nothrow_exception_dtor);
397 CmdArgs.push_back(
"-fexceptions");
413 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
419 ArgStringList &CmdArgs,
420 const llvm::vfs::FileSystem &VFS) {
421 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
422 options::OPT_fdebug_compilation_dir_EQ)) {
423 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
424 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
427 A->render(Args, CmdArgs);
428 }
else if (llvm::ErrorOr<std::string> CWD =
429 VFS.getCurrentWorkingDirectory()) {
430 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
432 StringRef Path(CmdArgs.back());
433 return Path.substr(Path.find(
'=') + 1).data();
437 const char *DebugCompilationDir,
438 const char *OutputFileName) {
440 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
441 if (StringRef(Arg->getValue()).starts_with(
"-object-file-name"))
444 if (Args.hasArg(options::OPT_object_file_name_EQ))
448 if (ObjFileNameForDebug !=
"-" &&
449 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
450 (!DebugCompilationDir ||
451 llvm::sys::path::is_absolute(DebugCompilationDir))) {
453 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
459 llvm::sys::path::Style Style =
460 llvm::sys::path::is_absolute(ObjFileNameForDebug)
461 ? llvm::sys::path::Style::native
462 : llvm::sys::path::Style::windows_backslash;
463 llvm::sys::path::remove_dots(ObjFileNameForDebug,
true,
466 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
471 const ArgList &Args, ArgStringList &CmdArgs) {
472 auto AddOneArg = [&](StringRef Map, StringRef Name) {
473 if (!Map.contains(
'='))
474 D.
Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
476 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
479 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
480 options::OPT_fdebug_prefix_map_EQ)) {
481 AddOneArg(A->getValue(), A->getOption().getName());
485 if (GlobalRemapEntry.empty())
487 AddOneArg(GlobalRemapEntry,
"environment");
492 ArgStringList &CmdArgs) {
493 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
494 options::OPT_fmacro_prefix_map_EQ)) {
495 StringRef Map = A->getValue();
496 if (!Map.contains(
'='))
497 D.
Diag(diag::err_drv_invalid_argument_to_option)
498 << Map << A->getOption().getName();
500 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
507 ArgStringList &CmdArgs) {
508 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
509 options::OPT_fcoverage_prefix_map_EQ)) {
510 StringRef Map = A->getValue();
511 if (!Map.contains(
'='))
512 D.
Diag(diag::err_drv_invalid_argument_to_option)
513 << Map << A->getOption().getName();
515 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
524 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
525 if (A->getOption().matches(options::OPT_O4) ||
526 A->getOption().matches(options::OPT_Ofast))
529 if (A->getOption().matches(options::OPT_O0))
532 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
535 StringRef S(A->getValue());
543 unsigned OptLevel = 0;
544 if (S.getAsInteger(10, OptLevel))
555 ArgStringList &CmdArgs) {
558 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
561 CmdArgs.push_back(
"-x");
562 if (Args.hasArg(options::OPT_rewrite_objc))
568 const char *ClangType;
570 case types::TY_CXXModule:
573 case types::TY_PP_CXXModule:
574 ClangType =
"c++-cpp-output";
580 CmdArgs.push_back(ClangType);
587 ArgStringList &CmdArgs) {
589 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
590 options::OPT_fprofile_generate_EQ,
591 options::OPT_fno_profile_generate);
592 if (PGOGenerateArg &&
593 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
594 PGOGenerateArg =
nullptr;
598 auto *ProfileGenerateArg = Args.getLastArg(
599 options::OPT_fprofile_instr_generate,
600 options::OPT_fprofile_instr_generate_EQ,
601 options::OPT_fno_profile_instr_generate);
602 if (ProfileGenerateArg &&
603 ProfileGenerateArg->getOption().matches(
604 options::OPT_fno_profile_instr_generate))
605 ProfileGenerateArg =
nullptr;
607 if (PGOGenerateArg && ProfileGenerateArg)
608 D.
Diag(diag::err_drv_argument_not_allowed_with)
609 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
613 if (PGOGenerateArg && ProfileUseArg)
614 D.
Diag(diag::err_drv_argument_not_allowed_with)
615 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
617 if (ProfileGenerateArg && ProfileUseArg)
618 D.
Diag(diag::err_drv_argument_not_allowed_with)
619 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
621 if (CSPGOGenerateArg && PGOGenerateArg) {
622 D.
Diag(diag::err_drv_argument_not_allowed_with)
623 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
624 PGOGenerateArg =
nullptr;
629 D.
Diag(diag::err_drv_unsupported_opt_for_target)
630 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
633 if (ProfileGenerateArg) {
634 if (ProfileGenerateArg->getOption().matches(
635 options::OPT_fprofile_instr_generate_EQ))
636 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
637 ProfileGenerateArg->getValue()));
639 CmdArgs.push_back(
"-fprofile-instrument=clang");
640 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
641 Args.hasFlag(options::OPT_frtlib_defaultlib,
642 options::OPT_fno_rtlib_defaultlib,
true)) {
644 CmdArgs.push_back(Args.MakeArgString(
649 Arg *PGOGenArg =
nullptr;
650 if (PGOGenerateArg) {
651 assert(!CSPGOGenerateArg);
652 PGOGenArg = PGOGenerateArg;
653 CmdArgs.push_back(
"-fprofile-instrument=llvm");
655 if (CSPGOGenerateArg) {
656 assert(!PGOGenerateArg);
657 PGOGenArg = CSPGOGenerateArg;
658 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
661 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
662 Args.hasFlag(options::OPT_frtlib_defaultlib,
663 options::OPT_fno_rtlib_defaultlib,
true)) {
665 CmdArgs.push_back(Args.MakeArgString(
668 if (PGOGenArg->getOption().matches(
669 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
670 : options::OPT_fcs_profile_generate_EQ)) {
672 llvm::sys::path::append(Path,
"default_%m.profraw");
674 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
679 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
680 CmdArgs.push_back(Args.MakeArgString(
681 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
682 else if ((ProfileUseArg->getOption().matches(
683 options::OPT_fprofile_use_EQ) ||
684 ProfileUseArg->getOption().matches(
685 options::OPT_fprofile_instr_use))) {
687 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
688 if (Path.empty() || llvm::sys::fs::is_directory(Path))
689 llvm::sys::path::append(Path,
"default.profdata");
691 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
695 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
696 options::OPT_fno_test_coverage,
false) ||
697 Args.hasArg(options::OPT_coverage);
700 if (Args.hasFlag(options::OPT_fcoverage_mapping,
701 options::OPT_fno_coverage_mapping,
false)) {
702 if (!ProfileGenerateArg)
703 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
704 <<
"-fcoverage-mapping"
705 <<
"-fprofile-instr-generate";
707 CmdArgs.push_back(
"-fcoverage-mapping");
710 if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
712 if (!Args.hasFlag(options::OPT_fcoverage_mapping,
713 options::OPT_fno_coverage_mapping,
false))
714 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
716 <<
"-fcoverage-mapping";
718 CmdArgs.push_back(
"-fcoverage-mcdc");
721 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
722 options::OPT_fcoverage_compilation_dir_EQ)) {
723 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
724 CmdArgs.push_back(Args.MakeArgString(
725 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
727 A->render(Args, CmdArgs);
728 }
else if (llvm::ErrorOr<std::string> CWD =
729 D.
getVFS().getCurrentWorkingDirectory()) {
730 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
733 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
734 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
735 if (!Args.hasArg(options::OPT_coverage))
736 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
737 <<
"-fprofile-exclude-files="
740 StringRef
v = Arg->getValue();
742 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
745 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
746 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
747 if (!Args.hasArg(options::OPT_coverage))
748 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
749 <<
"-fprofile-filter-files="
752 StringRef
v = Arg->getValue();
753 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
756 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
757 StringRef Val = A->getValue();
758 if (Val ==
"atomic" || Val ==
"prefer-atomic")
759 CmdArgs.push_back(
"-fprofile-update=atomic");
760 else if (Val !=
"single")
761 D.
Diag(diag::err_drv_unsupported_option_argument)
762 << A->getSpelling() << Val;
765 int FunctionGroups = 1;
766 int SelectedFunctionGroup = 0;
767 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
768 StringRef Val = A->getValue();
769 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
770 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
773 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
774 StringRef Val = A->getValue();
775 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
776 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
777 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
779 if (FunctionGroups != 1)
780 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
781 Twine(FunctionGroups)));
782 if (SelectedFunctionGroup != 0)
783 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
784 Twine(SelectedFunctionGroup)));
790 Arg *FProfileDir =
nullptr;
791 if (Args.hasArg(options::OPT_fprofile_arcs) ||
792 Args.hasArg(options::OPT_coverage))
793 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
797 (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
802 if (EmitCovNotes || EmitCovData) {
804 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
807 CoverageFilename = DumpDir->getValue();
808 CoverageFilename += llvm::sys::path::filename(Output.
getBaseInput());
809 }
else if (Arg *FinalOutput =
810 C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
811 CoverageFilename = FinalOutput->getValue();
812 }
else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o)) {
813 CoverageFilename = FinalOutput->getValue();
815 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
817 if (llvm::sys::path::is_relative(CoverageFilename))
818 (void)D.
getVFS().makeAbsolute(CoverageFilename);
819 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
822 Args.MakeArgString(
"-coverage-notes-file=" + CoverageFilename));
828 CoverageFilename = FProfileDir->getValue();
829 llvm::sys::path::append(CoverageFilename, Gcno);
831 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
833 Args.MakeArgString(
"-coverage-data-file=" + CoverageFilename));
840 llvm::codegenoptions::DebugInfoKind DebugInfoKind,
841 unsigned DwarfVersion,
842 llvm::DebuggerKind DebuggerTuning) {
844 if (DwarfVersion > 0)
846 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
847 switch (DebuggerTuning) {
848 case llvm::DebuggerKind::GDB:
849 CmdArgs.push_back(
"-debugger-tuning=gdb");
851 case llvm::DebuggerKind::LLDB:
852 CmdArgs.push_back(
"-debugger-tuning=lldb");
854 case llvm::DebuggerKind::SCE:
855 CmdArgs.push_back(
"-debugger-tuning=sce");
857 case llvm::DebuggerKind::DBX:
858 CmdArgs.push_back(
"-debugger-tuning=dbx");
867 assert(A &&
"Expected non-nullptr argument.");
870 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
876 ArgStringList &CmdArgs,
879 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
883 StringRef
Value = A->getValue();
884 if (
Value ==
"none") {
885 CmdArgs.push_back(
"--compress-debug-sections=none");
886 }
else if (
Value ==
"zlib") {
887 if (llvm::compression::zlib::isAvailable()) {
889 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
891 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
893 }
else if (
Value ==
"zstd") {
894 if (llvm::compression::zstd::isAvailable()) {
896 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
898 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
901 D.
Diag(diag::err_drv_unsupported_option_argument)
902 << A->getSpelling() <<
Value;
909 ArgStringList &CmdArgs,
910 bool IsCC1As =
false) {
918 CmdArgs.insert(CmdArgs.begin() + 1,
919 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
921 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
924 CmdArgs.insert(CmdArgs.begin() + 1,
925 Args.MakeArgString(Twine(
"-mcode-object-version=") +
931 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MemBuf =
932 D.
getVFS().getBufferForFile(Path);
935 llvm::file_magic Magic = llvm::identify_magic((*MemBuf)->getBuffer());
936 if (Magic == llvm::file_magic::unknown)
940 if (Magic == llvm::file_magic::clang_ast)
943 llvm::object::ObjectFile::createObjectFile(**MemBuf, Magic);
944 return !Obj.takeError();
948 llvm::ErrorOr<llvm::vfs::Status> Status = D.
getVFS().status(Path);
952 if (Status->isDirectory()) {
954 for (llvm::vfs::directory_iterator DI = D.
getVFS().dir_begin(Path, EC), DE;
955 !EC && DI != DE; DI = DI.increment(EC)) {
959 D.
Diag(diag::warn_drv_pch_ignoring_gch_dir) << Path;
965 D.
Diag(diag::warn_drv_pch_ignoring_gch_file) << Path;
970 const Driver &D,
const ArgList &Args,
971 ArgStringList &CmdArgs,
978 Args.AddLastArg(CmdArgs, options::OPT_C);
979 Args.AddLastArg(CmdArgs, options::OPT_CC);
982 Arg *ArgM = Args.getLastArg(options::OPT_MM);
984 ArgM = Args.getLastArg(options::OPT_M);
985 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
987 ArgMD = Args.getLastArg(options::OPT_MD);
991 CmdArgs.push_back(
"-w");
998 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
999 DepFile = MF->getValue();
1000 C.addFailureResultFile(DepFile, &JA);
1001 }
else if (Output.
getType() == types::TY_Dependencies) {
1003 }
else if (!ArgMD) {
1007 C.addFailureResultFile(DepFile, &JA);
1009 CmdArgs.push_back(
"-dependency-file");
1010 CmdArgs.push_back(DepFile);
1012 bool HasTarget =
false;
1013 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1016 if (A->getOption().matches(options::OPT_MT)) {
1017 A->render(Args, CmdArgs);
1019 CmdArgs.push_back(
"-MT");
1022 CmdArgs.push_back(Args.MakeArgString(Quoted));
1028 const char *DepTarget;
1032 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1033 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1034 DepTarget = OutputOpt->getValue();
1040 llvm::sys::path::replace_extension(
P,
"o");
1041 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1044 CmdArgs.push_back(
"-MT");
1047 CmdArgs.push_back(Args.MakeArgString(Quoted));
1050 if (ArgM->getOption().matches(options::OPT_M) ||
1051 ArgM->getOption().matches(options::OPT_MD))
1052 CmdArgs.push_back(
"-sys-header-deps");
1053 if ((isa<PrecompileJobAction>(JA) &&
1054 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1055 Args.hasArg(options::OPT_fmodule_file_deps))
1056 CmdArgs.push_back(
"-module-file-deps");
1059 if (Args.hasArg(options::OPT_MG)) {
1060 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1061 ArgM->getOption().matches(options::OPT_MMD))
1062 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1063 CmdArgs.push_back(
"-MG");
1066 Args.AddLastArg(CmdArgs, options::OPT_MP);
1067 Args.AddLastArg(CmdArgs, options::OPT_MV);
1080 if (!Args.hasArg(options::OPT_nostdinc) &&
1081 !Args.hasArg(options::OPT_nogpuinc) &&
1082 !Args.hasArg(options::OPT_nobuiltininc)) {
1090 llvm::sys::path::append(
P,
"include");
1091 llvm::sys::path::append(
P,
getToolChain().getTripleString());
1092 CmdArgs.push_back(
"-internal-isystem");
1093 CmdArgs.push_back(Args.MakeArgString(
P));
1098 llvm::sys::path::append(
P,
"include");
1099 llvm::sys::path::append(
P,
"llvm_libc_wrappers");
1100 CmdArgs.push_back(
"-internal-isystem");
1101 CmdArgs.push_back(Args.MakeArgString(
P));
1108 !Args.hasArg(options::OPT_nostdinc) &&
1109 !Args.hasArg(options::OPT_nogpuinc) &&
1112 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1116 llvm::sys::path::append(
P,
"include");
1117 llvm::sys::path::append(
P,
"openmp_wrappers");
1118 CmdArgs.push_back(
"-internal-isystem");
1119 CmdArgs.push_back(Args.MakeArgString(
P));
1122 CmdArgs.push_back(
"-include");
1123 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1133 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1134 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1137 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1140 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1141 options::OPT_fno_pch_instantiate_templates,
true))
1142 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1144 if (YcArg || YuArg) {
1145 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1146 if (!isa<PrecompileJobAction>(JA)) {
1147 CmdArgs.push_back(
"-include-pch");
1149 C, !ThroughHeader.empty()
1151 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1154 if (ThroughHeader.empty()) {
1155 CmdArgs.push_back(Args.MakeArgString(
1156 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1159 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1164 bool RenderedImplicitInclude =
false;
1165 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1166 if (A->getOption().matches(options::OPT_include) &&
1169 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1170 RenderedImplicitInclude =
true;
1172 bool FoundPCH =
false;
1177 llvm::sys::path::replace_extension(
P,
"pch");
1183 llvm::sys::path::replace_extension(
P,
"gch");
1188 if (IsFirstImplicitInclude) {
1190 CmdArgs.push_back(
"-include-pch");
1191 CmdArgs.push_back(Args.MakeArgString(
P));
1195 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1196 << A->getAsString(Args);
1199 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1206 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1209 }
else if (A->getOption().matches(options::OPT_ibuiltininc)) {
1216 A->render(Args, CmdArgs);
1219 Args.addAllArgs(CmdArgs,
1220 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1221 options::OPT_F, options::OPT_index_header_map});
1229 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1230 options::OPT_Xpreprocessor);
1233 if (Arg *A = Args.getLastArg(options::OPT_I_))
1234 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1238 StringRef sysroot =
C.getSysRoot();
1239 if (sysroot !=
"") {
1240 if (!Args.hasArg(options::OPT_isysroot)) {
1241 CmdArgs.push_back(
"-isysroot");
1242 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1259 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1267 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1270 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1279 [&Args, &CmdArgs](
const ToolChain &TC) {
1290 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1291 options::OPT_fno_file_reproducible);
1293 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1294 CmdArgs.push_back(
"-source-date-epoch");
1295 CmdArgs.push_back(Args.MakeArgString(Epoch));
1298 Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,
1299 options::OPT_fno_define_target_os_macros);
1304 switch (Triple.getArch()) {
1308 case llvm::Triple::aarch64:
1309 case llvm::Triple::aarch64_32:
1310 case llvm::Triple::aarch64_be:
1311 case llvm::Triple::arm:
1312 case llvm::Triple::armeb:
1313 case llvm::Triple::thumb:
1314 case llvm::Triple::thumbeb:
1315 if (Triple.isOSDarwin() || Triple.isOSWindows())
1319 case llvm::Triple::ppc:
1320 case llvm::Triple::ppc64:
1321 if (Triple.isOSDarwin())
1325 case llvm::Triple::hexagon:
1326 case llvm::Triple::ppcle:
1327 case llvm::Triple::ppc64le:
1328 case llvm::Triple::riscv32:
1329 case llvm::Triple::riscv64:
1330 case llvm::Triple::systemz:
1331 case llvm::Triple::xcore:
1337 const ArgList &Args) {
1340 if (!Triple.isOSDarwin())
1344 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1348 const llvm::Triple &Triple) {
1353 bool hasExplicitOutputFile =
1354 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1356 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1357 <<
"-foptimization-record-file";
1364 const llvm::Triple &Triple,
1367 StringRef Format =
"yaml";
1368 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1369 Format = A->getValue();
1371 CmdArgs.push_back(
"-opt-record-file");
1373 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1375 CmdArgs.push_back(A->getValue());
1377 bool hasMultipleArchs =
1378 Triple.isOSDarwin() &&
1379 Args.getAllArgValues(options::OPT_arch).size() > 1;
1383 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1384 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1385 F = FinalOutput->getValue();
1387 if (Format !=
"yaml" &&
1388 Triple.isOSDarwin() &&
1402 llvm::sys::path::replace_extension(F,
"");
1404 Triple.normalize());
1414 if (hasMultipleArchs) {
1418 llvm::sys::path::replace_extension(F,
"");
1421 F += Triple.getArchName();
1423 llvm::sys::path::replace_extension(F, OldExtension);
1427 Extension +=
"opt.";
1428 Extension += Format;
1430 llvm::sys::path::replace_extension(F, Extension);
1431 CmdArgs.push_back(Args.MakeArgString(F));
1435 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1436 CmdArgs.push_back(
"-opt-record-passes");
1437 CmdArgs.push_back(A->getValue());
1440 if (!Format.empty()) {
1441 CmdArgs.push_back(
"-opt-record-format");
1442 CmdArgs.push_back(Format.data());
1447 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1448 options::OPT_fno_aapcs_bitfield_width,
true))
1449 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1451 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1452 CmdArgs.push_back(
"-faapcs-bitfield-load");
1456void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1457 const ArgList &Args, ArgStringList &CmdArgs) {
1461 const char *ABIName =
nullptr;
1462 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1463 ABIName = A->getValue();
1465 std::string CPU =
getCPUName(D, Args, Triple,
false);
1466 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1469 CmdArgs.push_back(
"-target-abi");
1470 CmdArgs.push_back(ABIName);
1473void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1474 auto StrictAlignIter =
1475 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1476 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1478 if (StrictAlignIter != CmdArgs.rend() &&
1479 StringRef(*StrictAlignIter) ==
"+strict-align")
1480 CmdArgs.push_back(
"-Wunaligned-access");
1485 ArgStringList &CmdArgs,
bool isAArch64) {
1486 const Arg *A = isAArch64
1487 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1488 options::OPT_mbranch_protection_EQ)
1489 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1495 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1496 D.
Diag(diag::warn_incompatible_branch_protection_option)
1497 << Triple.getArchName();
1499 StringRef
Scope, Key;
1500 bool IndirectBranches, BranchProtectionPAuthLR, GuardedControlStack;
1502 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1503 Scope = A->getValue();
1505 D.
Diag(diag::err_drv_unsupported_option_argument)
1506 << A->getSpelling() <<
Scope;
1508 IndirectBranches =
false;
1509 BranchProtectionPAuthLR =
false;
1510 GuardedControlStack =
false;
1513 llvm::ARM::ParsedBranchProtection PBP;
1514 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg))
1515 D.
Diag(diag::err_drv_unsupported_option_argument)
1516 << A->getSpelling() << DiagMsg;
1517 if (!isAArch64 && PBP.Key ==
"b_key")
1518 D.
Diag(diag::warn_unsupported_branch_protection)
1519 <<
"b-key" << A->getAsString(Args);
1522 BranchProtectionPAuthLR = PBP.BranchProtectionPAuthLR;
1523 IndirectBranches = PBP.BranchTargetEnforcement;
1524 GuardedControlStack = PBP.GuardedControlStack;
1528 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1529 if (!
Scope.equals(
"none"))
1531 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1532 if (BranchProtectionPAuthLR)
1534 Args.MakeArgString(Twine(
"-mbranch-protection-pauth-lr")));
1535 if (IndirectBranches)
1536 CmdArgs.push_back(
"-mbranch-target-enforce");
1537 if (GuardedControlStack)
1538 CmdArgs.push_back(
"-mguarded-control-stack");
1541void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1542 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1543 RenderARMABI(
getToolChain().getDriver(), Triple, Args, CmdArgs);
1550 CmdArgs.push_back(
"-msoft-float");
1551 CmdArgs.push_back(
"-mfloat-abi");
1552 CmdArgs.push_back(
"soft");
1555 CmdArgs.push_back(
"-mfloat-abi");
1556 CmdArgs.push_back(
"soft");
1560 CmdArgs.push_back(
"-mfloat-abi");
1561 CmdArgs.push_back(
"hard");
1565 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1566 options::OPT_mno_global_merge)) {
1567 CmdArgs.push_back(
"-mllvm");
1568 if (A->getOption().matches(options::OPT_mno_global_merge))
1569 CmdArgs.push_back(
"-arm-global-merge=false");
1571 CmdArgs.push_back(
"-arm-global-merge=true");
1574 if (!Args.hasFlag(options::OPT_mimplicit_float,
1575 options::OPT_mno_implicit_float,
true))
1576 CmdArgs.push_back(
"-no-implicit-float");
1578 if (Args.getLastArg(options::OPT_mcmse))
1579 CmdArgs.push_back(
"-mcmse");
1586 AddUnalignedAccessWarning(CmdArgs);
1589void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1590 const ArgList &Args,
bool KernelOrKext,
1591 ArgStringList &CmdArgs)
const {
1602 case llvm::Triple::arm:
1603 case llvm::Triple::armeb:
1604 case llvm::Triple::thumb:
1605 case llvm::Triple::thumbeb:
1607 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1610 case llvm::Triple::aarch64:
1611 case llvm::Triple::aarch64_32:
1612 case llvm::Triple::aarch64_be:
1613 AddAArch64TargetArgs(Args, CmdArgs);
1616 case llvm::Triple::loongarch32:
1617 case llvm::Triple::loongarch64:
1618 AddLoongArchTargetArgs(Args, CmdArgs);
1621 case llvm::Triple::mips:
1622 case llvm::Triple::mipsel:
1623 case llvm::Triple::mips64:
1624 case llvm::Triple::mips64el:
1625 AddMIPSTargetArgs(Args, CmdArgs);
1628 case llvm::Triple::ppc:
1629 case llvm::Triple::ppcle:
1630 case llvm::Triple::ppc64:
1631 case llvm::Triple::ppc64le:
1632 AddPPCTargetArgs(Args, CmdArgs);
1635 case llvm::Triple::riscv32:
1636 case llvm::Triple::riscv64:
1637 AddRISCVTargetArgs(Args, CmdArgs);
1640 case llvm::Triple::sparc:
1641 case llvm::Triple::sparcel:
1642 case llvm::Triple::sparcv9:
1643 AddSparcTargetArgs(Args, CmdArgs);
1646 case llvm::Triple::systemz:
1647 AddSystemZTargetArgs(Args, CmdArgs);
1650 case llvm::Triple::x86:
1651 case llvm::Triple::x86_64:
1652 AddX86TargetArgs(Args, CmdArgs);
1655 case llvm::Triple::lanai:
1656 AddLanaiTargetArgs(Args, CmdArgs);
1659 case llvm::Triple::hexagon:
1660 AddHexagonTargetArgs(Args, CmdArgs);
1663 case llvm::Triple::wasm32:
1664 case llvm::Triple::wasm64:
1665 AddWebAssemblyTargetArgs(Args, CmdArgs);
1668 case llvm::Triple::ve:
1669 AddVETargetArgs(Args, CmdArgs);
1675void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1676 ArgStringList &CmdArgs) {
1677 const char *ABIName =
nullptr;
1678 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1679 ABIName = A->getValue();
1680 else if (Triple.isOSDarwin())
1681 ABIName =
"darwinpcs";
1685 CmdArgs.push_back(
"-target-abi");
1686 CmdArgs.push_back(ABIName);
1690void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1691 ArgStringList &CmdArgs)
const {
1694 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1695 Args.hasArg(options::OPT_mkernel) ||
1696 Args.hasArg(options::OPT_fapple_kext))
1697 CmdArgs.push_back(
"-disable-red-zone");
1699 if (!Args.hasFlag(options::OPT_mimplicit_float,
1700 options::OPT_mno_implicit_float,
true))
1701 CmdArgs.push_back(
"-no-implicit-float");
1703 RenderAArch64ABI(Triple, Args, CmdArgs);
1706 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1707 options::OPT_mno_global_merge)) {
1708 CmdArgs.push_back(
"-mllvm");
1709 if (A->getOption().matches(options::OPT_mno_global_merge))
1710 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1712 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1719 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1720 StringRef Val = A->getValue();
1722 if (Val.equals(
"128") || Val.equals(
"256") || Val.equals(
"512") ||
1723 Val.equals(
"1024") || Val.equals(
"2048") || Val.equals(
"128+") ||
1724 Val.equals(
"256+") || Val.equals(
"512+") || Val.equals(
"1024+") ||
1725 Val.equals(
"2048+")) {
1727 if (!Val.consume_back(
"+")) {
1729 assert(!
Invalid &&
"Failed to parse value");
1731 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1735 assert(!
Invalid &&
"Failed to parse value");
1737 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1739 }
else if (!Val.equals(
"scalable"))
1741 D.
Diag(diag::err_drv_unsupported_option_argument)
1742 << A->getSpelling() << Val;
1747 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1748 CmdArgs.push_back(
"-tune-cpu");
1749 if (strcmp(A->getValue(),
"native") == 0)
1750 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1752 CmdArgs.push_back(A->getValue());
1755 AddUnalignedAccessWarning(CmdArgs);
1757 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
1758 options::OPT_fno_ptrauth_intrinsics);
1761void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1762 ArgStringList &CmdArgs)
const {
1765 CmdArgs.push_back(
"-target-abi");
1771 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1772 std::string TuneCPU = A->getValue();
1774 CmdArgs.push_back(
"-tune-cpu");
1775 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1779void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1780 ArgStringList &CmdArgs)
const {
1787 CmdArgs.push_back(
"-target-abi");
1788 CmdArgs.push_back(ABIName.data());
1793 CmdArgs.push_back(
"-msoft-float");
1794 CmdArgs.push_back(
"-mfloat-abi");
1795 CmdArgs.push_back(
"soft");
1799 CmdArgs.push_back(
"-mfloat-abi");
1800 CmdArgs.push_back(
"hard");
1803 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1804 options::OPT_mno_ldc1_sdc1)) {
1805 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1806 CmdArgs.push_back(
"-mllvm");
1807 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1811 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1812 options::OPT_mno_check_zero_division)) {
1813 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1814 CmdArgs.push_back(
"-mllvm");
1815 CmdArgs.push_back(
"-mno-check-zero-division");
1819 if (Args.getLastArg(options::OPT_mfix4300)) {
1820 CmdArgs.push_back(
"-mllvm");
1821 CmdArgs.push_back(
"-mfix4300");
1824 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1825 StringRef
v = A->getValue();
1826 CmdArgs.push_back(
"-mllvm");
1827 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1831 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1833 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1846 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1848 llvm::Reloc::Model RelocationModel;
1851 std::tie(RelocationModel, PICLevel, IsPIE) =
1854 NoABICalls = NoABICalls ||
1855 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1857 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1859 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1860 CmdArgs.push_back(
"-mllvm");
1861 CmdArgs.push_back(
"-mgpopt");
1863 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1864 options::OPT_mno_local_sdata);
1865 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1866 options::OPT_mno_extern_sdata);
1867 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1868 options::OPT_mno_embedded_data);
1870 CmdArgs.push_back(
"-mllvm");
1871 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1872 CmdArgs.push_back(
"-mlocal-sdata=1");
1874 CmdArgs.push_back(
"-mlocal-sdata=0");
1876 LocalSData->claim();
1880 CmdArgs.push_back(
"-mllvm");
1881 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1882 CmdArgs.push_back(
"-mextern-sdata=1");
1884 CmdArgs.push_back(
"-mextern-sdata=0");
1886 ExternSData->claim();
1890 CmdArgs.push_back(
"-mllvm");
1891 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1892 CmdArgs.push_back(
"-membedded-data=1");
1894 CmdArgs.push_back(
"-membedded-data=0");
1896 EmbeddedData->claim();
1899 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1900 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1905 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1906 StringRef Val = StringRef(A->getValue());
1908 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1909 CmdArgs.push_back(
"-mllvm");
1910 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1912 D.
Diag(diag::err_drv_unsupported_option_argument)
1913 << A->getSpelling() << Val;
1915 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1918 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1919 options::OPT_mno_relax_pic_calls)) {
1920 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1921 CmdArgs.push_back(
"-mllvm");
1922 CmdArgs.push_back(
"-mips-jalr-reloc=0");
1927void Clang::AddPPCTargetArgs(
const ArgList &Args,
1928 ArgStringList &CmdArgs)
const {
1931 if (Args.getLastArg(options::OPT_mtune_EQ)) {
1932 CmdArgs.push_back(
"-tune-cpu");
1934 CmdArgs.push_back(Args.MakeArgString(CPU));
1938 const char *ABIName =
nullptr;
1939 if (
T.isOSBinFormatELF()) {
1941 case llvm::Triple::ppc64: {
1942 if (
T.isPPC64ELFv2ABI())
1948 case llvm::Triple::ppc64le:
1957 bool VecExtabi =
false;
1958 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
1959 StringRef
V = A->getValue();
1960 if (
V ==
"ieeelongdouble") {
1961 IEEELongDouble =
true;
1963 }
else if (
V ==
"ibmlongdouble") {
1964 IEEELongDouble =
false;
1966 }
else if (
V ==
"vec-default") {
1969 }
else if (
V ==
"vec-extabi") {
1972 }
else if (
V ==
"elfv1") {
1975 }
else if (
V ==
"elfv2") {
1978 }
else if (
V !=
"altivec")
1982 ABIName = A->getValue();
1985 CmdArgs.push_back(
"-mabi=ieeelongdouble");
1988 D.
Diag(diag::err_drv_unsupported_opt_for_target)
1989 <<
"-mabi=vec-extabi" <<
T.str();
1990 CmdArgs.push_back(
"-mabi=vec-extabi");
1996 CmdArgs.push_back(
"-msoft-float");
1997 CmdArgs.push_back(
"-mfloat-abi");
1998 CmdArgs.push_back(
"soft");
2002 CmdArgs.push_back(
"-mfloat-abi");
2003 CmdArgs.push_back(
"hard");
2007 CmdArgs.push_back(
"-target-abi");
2008 CmdArgs.push_back(ABIName);
2013 ArgStringList &CmdArgs) {
2015 const llvm::Triple &Triple = TC.
getTriple();
2017 const char *SmallDataLimit =
"8";
2019 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2020 options::OPT_fPIC)) {
2022 SmallDataLimit =
"0";
2023 if (Args.hasArg(options::OPT_G)) {
2024 D.
Diag(diag::warn_drv_unsupported_sdata);
2026 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2027 .equals_insensitive(
"large") &&
2028 (Triple.getArch() == llvm::Triple::riscv64)) {
2030 SmallDataLimit =
"0";
2031 if (Args.hasArg(options::OPT_G)) {
2032 D.
Diag(diag::warn_drv_unsupported_sdata);
2034 }
else if (Triple.isAndroid()) {
2036 SmallDataLimit =
"0";
2037 if (Args.hasArg(options::OPT_G)) {
2038 D.
Diag(diag::warn_drv_unsupported_sdata);
2040 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2041 SmallDataLimit = A->getValue();
2044 CmdArgs.push_back(
"-msmall-data-limit");
2045 CmdArgs.push_back(SmallDataLimit);
2048void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2049 ArgStringList &CmdArgs)
const {
2053 CmdArgs.push_back(
"-target-abi");
2054 CmdArgs.push_back(ABIName.data());
2058 if (!Args.hasFlag(options::OPT_mimplicit_float,
2059 options::OPT_mno_implicit_float,
true))
2060 CmdArgs.push_back(
"-no-implicit-float");
2062 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2063 CmdArgs.push_back(
"-tune-cpu");
2064 if (strcmp(A->getValue(),
"native") == 0)
2065 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2067 CmdArgs.push_back(A->getValue());
2071 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2072 StringRef Val = A->getValue();
2076 unsigned MinVLen = 0;
2078 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
2081 if (!errorToBool(ISAInfo.takeError()))
2082 MinVLen = (*ISAInfo)->getMinVLen();
2087 if (Val.equals(
"zvl") && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
2089 }
else if (!Val.getAsInteger(10, Bits)) {
2092 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
2093 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
2099 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
2101 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
2103 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
2104 }
else if (!Val.equals(
"scalable")) {
2106 D.
Diag(diag::err_drv_unsupported_option_argument)
2107 << A->getSpelling() << Val;
2112void Clang::AddSparcTargetArgs(
const ArgList &Args,
2113 ArgStringList &CmdArgs)
const {
2119 CmdArgs.push_back(
"-msoft-float");
2120 CmdArgs.push_back(
"-mfloat-abi");
2121 CmdArgs.push_back(
"soft");
2125 CmdArgs.push_back(
"-mfloat-abi");
2126 CmdArgs.push_back(
"hard");
2129 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2130 StringRef Name = A->getValue();
2131 std::string TuneCPU;
2132 if (Name ==
"native")
2133 TuneCPU = std::string(llvm::sys::getHostCPUName());
2135 TuneCPU = std::string(Name);
2137 CmdArgs.push_back(
"-tune-cpu");
2138 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2142void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2143 ArgStringList &CmdArgs)
const {
2144 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2145 CmdArgs.push_back(
"-tune-cpu");
2146 if (strcmp(A->getValue(),
"native") == 0)
2147 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2149 CmdArgs.push_back(A->getValue());
2153 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2154 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2155 options::OPT_mno_packed_stack,
false);
2159 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2161 D.
Diag(diag::err_drv_unsupported_opt)
2162 <<
"-mpacked-stack -mbackchain -mhard-float";
2165 CmdArgs.push_back(
"-mbackchain");
2167 CmdArgs.push_back(
"-mpacked-stack");
2170 CmdArgs.push_back(
"-msoft-float");
2171 CmdArgs.push_back(
"-mfloat-abi");
2172 CmdArgs.push_back(
"soft");
2176void Clang::AddX86TargetArgs(
const ArgList &Args,
2177 ArgStringList &CmdArgs)
const {
2181 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2182 Args.hasArg(options::OPT_mkernel) ||
2183 Args.hasArg(options::OPT_fapple_kext))
2184 CmdArgs.push_back(
"-disable-red-zone");
2186 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2187 options::OPT_mno_tls_direct_seg_refs,
true))
2188 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2192 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2193 Args.hasArg(options::OPT_fapple_kext));
2194 if (Arg *A = Args.getLastArg(
2195 options::OPT_msoft_float, options::OPT_mno_soft_float,
2196 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2197 const Option &O = A->getOption();
2198 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2199 O.matches(options::OPT_msoft_float));
2201 if (NoImplicitFloat)
2202 CmdArgs.push_back(
"-no-implicit-float");
2204 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2205 StringRef
Value = A->getValue();
2207 CmdArgs.push_back(
"-mllvm");
2208 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2209 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2211 D.
Diag(diag::err_drv_unsupported_option_argument)
2212 << A->getSpelling() <<
Value;
2215 CmdArgs.push_back(
"-mllvm");
2216 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2219 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2220 options::OPT_mno_skip_rax_setup))
2221 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2222 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2225 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2226 CmdArgs.push_back(
"-mfloat-abi");
2227 CmdArgs.push_back(
"soft");
2228 CmdArgs.push_back(
"-mstack-alignment=4");
2234 std::string TuneCPU;
2235 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2237 TuneCPU =
"generic";
2240 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2241 StringRef Name = A->getValue();
2243 if (Name ==
"native") {
2244 Name = llvm::sys::getHostCPUName();
2246 TuneCPU = std::string(Name);
2248 TuneCPU = std::string(Name);
2251 if (!TuneCPU.empty()) {
2252 CmdArgs.push_back(
"-tune-cpu");
2253 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2257void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2258 ArgStringList &CmdArgs)
const {
2259 CmdArgs.push_back(
"-mqdsp6-compat");
2260 CmdArgs.push_back(
"-Wreturn-type");
2263 CmdArgs.push_back(
"-mllvm");
2265 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2268 if (!Args.hasArg(options::OPT_fno_short_enums))
2269 CmdArgs.push_back(
"-fshort-enums");
2270 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2271 CmdArgs.push_back(
"-mllvm");
2272 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2274 CmdArgs.push_back(
"-mllvm");
2275 CmdArgs.push_back(
"-machine-sink-split=0");
2278void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2279 ArgStringList &CmdArgs)
const {
2280 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2281 StringRef CPUName = A->getValue();
2283 CmdArgs.push_back(
"-target-cpu");
2284 CmdArgs.push_back(Args.MakeArgString(CPUName));
2286 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2287 StringRef
Value = A->getValue();
2291 if (
Value.getAsInteger(10, Mregparm)) {
2292 if (Mregparm != 4) {
2294 diag::err_drv_unsupported_option_argument)
2295 << A->getSpelling() <<
Value;
2301void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2302 ArgStringList &CmdArgs)
const {
2304 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2305 options::OPT_fvisibility_ms_compat))
2306 CmdArgs.push_back(
"-fvisibility=hidden");
2309void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2311 CmdArgs.push_back(
"-mfloat-abi");
2312 CmdArgs.push_back(
"hard");
2317 const InputInfo &Input,
const ArgList &Args)
const {
2319 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2322 using llvm::yaml::escape;
2325 if (!CompilationDatabase) {
2327 auto File = std::make_unique<llvm::raw_fd_ostream>(
2329 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2331 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2335 CompilationDatabase = std::move(
File);
2337 auto &CDB = *CompilationDatabase;
2338 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2341 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2342 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2344 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2349 CDB <<
", \"" << escape(Buf) <<
"\"";
2350 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2353 CDB <<
", \"" << escape(Buf) <<
"\"";
2355 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2357 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2358 for (
auto &A: Args) {
2359 auto &O = A->getOption();
2361 if (O.getID() == options::OPT_x)
2364 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2366 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2369 if (O.getKind() == Option::InputClass)
2372 if (O.getID() == options::OPT_o)
2376 A->render(Args, ASL);
2378 CDB <<
", \"" << escape(it) <<
"\"";
2382 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2385void Clang::DumpCompilationDatabaseFragmentToDir(
2387 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2389 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2392 if (CompilationDatabase)
2393 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2396 const auto &
Driver =
C.getDriver();
2398 auto Err = llvm::sys::fs::create_directory(Path,
true);
2400 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2404 llvm::sys::path::append(
2406 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2409 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2410 llvm::sys::fs::OF_Text);
2412 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2415 CompilationDatabase =
2416 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2417 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2427 CmdArgs.push_back(
"-mllvm");
2428 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2432 const ArgList &Args,
2433 ArgStringList &CmdArgs,
2443 Args.addOptInFlag(CmdArgs, options::OPT_mrelax_all,
2444 options::OPT_mno_relax_all);
2448 bool DefaultIncrementalLinkerCompatible =
2449 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2450 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2451 options::OPT_mno_incremental_linker_compatible,
2452 DefaultIncrementalLinkerCompatible))
2453 CmdArgs.push_back(
"-mincremental-linker-compatible");
2455 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2457 Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2458 options::OPT_fno_emit_compact_unwind_non_canonical);
2468 bool TakeNextArg =
false;
2470 bool UseRelaxRelocations =
C.getDefaultToolChain().useRelaxRelocations();
2471 bool UseNoExecStack =
false;
2472 const char *MipsTargetFeature =
nullptr;
2473 StringRef ImplicitIt;
2475 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2476 options::OPT_mimplicit_it_EQ)) {
2479 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2480 switch (
C.getDefaultToolChain().getArch()) {
2481 case llvm::Triple::arm:
2482 case llvm::Triple::armeb:
2483 case llvm::Triple::thumb:
2484 case llvm::Triple::thumbeb:
2486 ImplicitIt = A->getValue();
2488 D.
Diag(diag::err_drv_unsupported_option_argument)
2489 << A->getSpelling() << ImplicitIt;
2496 for (StringRef
Value : A->getValues()) {
2498 CmdArgs.push_back(
Value.data());
2499 TakeNextArg =
false;
2503 if (
C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2504 Value ==
"-mbig-obj")
2507 switch (
C.getDefaultToolChain().getArch()) {
2510 case llvm::Triple::wasm32:
2511 case llvm::Triple::wasm64:
2512 if (
Value ==
"--no-type-check") {
2513 CmdArgs.push_back(
"-mno-type-check");
2517 case llvm::Triple::thumb:
2518 case llvm::Triple::thumbeb:
2519 case llvm::Triple::arm:
2520 case llvm::Triple::armeb:
2521 if (
Value.starts_with(
"-mimplicit-it=")) {
2523 ImplicitIt =
Value.split(
"=").second;
2527 if (
Value ==
"-mthumb")
2532 case llvm::Triple::mips:
2533 case llvm::Triple::mipsel:
2534 case llvm::Triple::mips64:
2535 case llvm::Triple::mips64el:
2536 if (
Value ==
"--trap") {
2537 CmdArgs.push_back(
"-target-feature");
2538 CmdArgs.push_back(
"+use-tcc-in-div");
2541 if (
Value ==
"--break") {
2542 CmdArgs.push_back(
"-target-feature");
2543 CmdArgs.push_back(
"-use-tcc-in-div");
2546 if (
Value.starts_with(
"-msoft-float")) {
2547 CmdArgs.push_back(
"-target-feature");
2548 CmdArgs.push_back(
"+soft-float");
2551 if (
Value.starts_with(
"-mhard-float")) {
2552 CmdArgs.push_back(
"-target-feature");
2553 CmdArgs.push_back(
"-soft-float");
2557 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2558 .Case(
"-mips1",
"+mips1")
2559 .Case(
"-mips2",
"+mips2")
2560 .Case(
"-mips3",
"+mips3")
2561 .Case(
"-mips4",
"+mips4")
2562 .Case(
"-mips5",
"+mips5")
2563 .Case(
"-mips32",
"+mips32")
2564 .Case(
"-mips32r2",
"+mips32r2")
2565 .Case(
"-mips32r3",
"+mips32r3")
2566 .Case(
"-mips32r5",
"+mips32r5")
2567 .Case(
"-mips32r6",
"+mips32r6")
2568 .Case(
"-mips64",
"+mips64")
2569 .Case(
"-mips64r2",
"+mips64r2")
2570 .Case(
"-mips64r3",
"+mips64r3")
2571 .Case(
"-mips64r5",
"+mips64r5")
2572 .Case(
"-mips64r6",
"+mips64r6")
2574 if (MipsTargetFeature)
2578 if (
Value ==
"-force_cpusubtype_ALL") {
2580 }
else if (
Value ==
"-L") {
2581 CmdArgs.push_back(
"-msave-temp-labels");
2582 }
else if (
Value ==
"--fatal-warnings") {
2583 CmdArgs.push_back(
"-massembler-fatal-warnings");
2584 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2585 CmdArgs.push_back(
"-massembler-no-warn");
2586 }
else if (
Value ==
"--noexecstack") {
2587 UseNoExecStack =
true;
2588 }
else if (
Value.starts_with(
"-compress-debug-sections") ||
2589 Value.starts_with(
"--compress-debug-sections") ||
2590 Value ==
"-nocompress-debug-sections" ||
2591 Value ==
"--nocompress-debug-sections") {
2592 CmdArgs.push_back(
Value.data());
2593 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2594 Value ==
"--mrelax-relocations=yes") {
2595 UseRelaxRelocations =
true;
2596 }
else if (
Value ==
"-mrelax-relocations=no" ||
2597 Value ==
"--mrelax-relocations=no") {
2598 UseRelaxRelocations =
false;
2599 }
else if (
Value.starts_with(
"-I")) {
2600 CmdArgs.push_back(
Value.data());
2605 }
else if (
Value.starts_with(
"-gdwarf-")) {
2608 if (DwarfVersion == 0) {
2609 CmdArgs.push_back(
Value.data());
2612 llvm::codegenoptions::DebugInfoConstructor,
2613 DwarfVersion, llvm::DebuggerKind::Default);
2615 }
else if (
Value.starts_with(
"-mcpu") ||
Value.starts_with(
"-mfpu") ||
2616 Value.starts_with(
"-mhwdiv") ||
Value.starts_with(
"-march")) {
2618 }
else if (
Value ==
"-defsym") {
2619 if (A->getNumValues() != 2) {
2620 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2623 const char *S = A->getValue(1);
2624 auto Pair = StringRef(S).split(
'=');
2625 auto Sym = Pair.first;
2626 auto SVal = Pair.second;
2628 if (Sym.empty() || SVal.empty()) {
2629 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2633 if (SVal.getAsInteger(0, IVal)) {
2634 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2637 CmdArgs.push_back(
Value.data());
2639 }
else if (
Value ==
"-fdebug-compilation-dir") {
2640 CmdArgs.push_back(
"-fdebug-compilation-dir");
2642 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2646 CmdArgs.push_back(
"-fdebug-compilation-dir");
2647 CmdArgs.push_back(
Value.data());
2648 }
else if (
Value ==
"--version") {
2651 D.
Diag(diag::err_drv_unsupported_option_argument)
2652 << A->getSpelling() <<
Value;
2656 if (ImplicitIt.size())
2658 if (!UseRelaxRelocations)
2659 CmdArgs.push_back(
"-mrelax-relocations=no");
2661 CmdArgs.push_back(
"-mnoexecstack");
2662 if (MipsTargetFeature !=
nullptr) {
2663 CmdArgs.push_back(
"-target-feature");
2664 CmdArgs.push_back(MipsTargetFeature);
2668 if (
C.getDriver().embedBitcodeEnabled() ||
2669 C.getDriver().embedBitcodeMarkerOnly())
2670 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2672 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2673 CmdArgs.push_back(
"-as-secure-log-file");
2674 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2705 if ((str1.compare(str2) != 0) && !str2.empty() && !str1.empty()) {
2706 D.
Diag(clang::diag::warn_drv_overriding_option) << str1 << str2;
2713 if (!ComplexRangeStr.empty())
2714 return "-complex-range=" + ComplexRangeStr;
2715 return ComplexRangeStr;
2719 bool OFastEnabled,
const ArgList &Args,
2720 ArgStringList &CmdArgs,
2727 bool HonorINFs =
true;
2728 bool HonorNaNs =
true;
2729 bool ApproxFunc =
false;
2732 bool AssociativeMath =
false;
2733 bool ReciprocalMath =
false;
2734 bool SignedZeros =
true;
2735 bool TrappingMath =
false;
2736 bool TrappingMathPresent =
false;
2738 bool RoundingFPMath =
false;
2739 bool RoundingMathPresent =
false;
2741 StringRef FPModel =
"";
2743 StringRef FPExceptionBehavior =
"";
2745 StringRef FPEvalMethod =
"";
2746 const llvm::DenormalMode DefaultDenormalFPMath =
2748 const llvm::DenormalMode DefaultDenormalFP32Math =
2751 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
2752 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
2755 StringRef FPContract;
2756 StringRef LastSeenFfpContractOption;
2757 bool SeenUnsafeMathModeOption =
false;
2761 bool StrictFPModel =
false;
2762 StringRef Float16ExcessPrecision =
"";
2763 StringRef BFloat16ExcessPrecision =
"";
2765 std::string ComplexRangeStr =
"";
2766 std::string GccRangeComplexOption =
"";
2769 auto applyFastMath = [&]() {
2773 AssociativeMath =
true;
2774 ReciprocalMath =
true;
2776 SignedZeros =
false;
2777 TrappingMath =
false;
2778 RoundingFPMath =
false;
2779 FPExceptionBehavior =
"";
2781 FPContract =
"fast";
2791 !GccRangeComplexOption.empty()
2792 ? GccRangeComplexOption
2795 SeenUnsafeMathModeOption =
true;
2798 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2799 CmdArgs.push_back(
"-mlimit-float-precision");
2800 CmdArgs.push_back(A->getValue());
2803 for (
const Arg *A : Args) {
2804 auto optID = A->getOption().getID();
2805 bool PreciseFPModel =
false;
2809 case options::OPT_fcx_limited_range:
2810 if (GccRangeComplexOption.empty()) {
2813 "-fcx-limited-range");
2815 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
2818 GccRangeComplexOption =
"-fcx-limited-range";
2821 case options::OPT_fno_cx_limited_range:
2822 if (GccRangeComplexOption.empty()) {
2824 "-fno-cx-limited-range");
2826 if (GccRangeComplexOption.compare(
"-fcx-limited-range") != 0 &&
2827 GccRangeComplexOption.compare(
"-fno-cx-fortran-rules") != 0)
2829 "-fno-cx-limited-range");
2831 GccRangeComplexOption =
"-fno-cx-limited-range";
2834 case options::OPT_fcx_fortran_rules:
2835 if (GccRangeComplexOption.empty())
2837 "-fcx-fortran-rules");
2840 GccRangeComplexOption =
"-fcx-fortran-rules";
2843 case options::OPT_fno_cx_fortran_rules:
2844 if (GccRangeComplexOption.empty()) {
2846 "-fno-cx-fortran-rules");
2848 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
2850 "-fno-cx-fortran-rules");
2852 GccRangeComplexOption =
"-fno-cx-fortran-rules";
2855 case options::OPT_fcomplex_arithmetic_EQ: {
2857 StringRef Val = A->getValue();
2858 if (Val.equals(
"full"))
2860 else if (Val.equals(
"improved"))
2862 else if (Val.equals(
"promoted"))
2864 else if (Val.equals(
"basic"))
2867 D.
Diag(diag::err_drv_unsupported_option_argument)
2868 << A->getSpelling() << Val;
2871 if (!GccRangeComplexOption.empty()) {
2872 if (GccRangeComplexOption.compare(
"-fcx-limited-range") != 0) {
2873 if (GccRangeComplexOption.compare(
"-fcx-fortran-rules") != 0) {
2890 case options::OPT_ffp_model_EQ: {
2897 AssociativeMath =
false;
2898 ReciprocalMath =
false;
2902 DenormalFPMath = llvm::DenormalMode::getIEEE();
2906 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2908 StringRef Val = A->getValue();
2909 if (OFastEnabled && !Val.equals(
"fast")) {
2911 D.
Diag(clang::diag::warn_drv_overriding_option)
2912 << Args.MakeArgString(
"-ffp-model=" + Val) <<
"-Ofast";
2915 StrictFPModel =
false;
2916 PreciseFPModel =
true;
2920 if (!FPModel.empty() && !FPModel.equals(Val))
2921 D.
Diag(clang::diag::warn_drv_overriding_option)
2922 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2923 << Args.MakeArgString(
"-ffp-model=" + Val);
2924 if (Val.equals(
"fast")) {
2927 }
else if (Val.equals(
"precise")) {
2928 optID = options::OPT_ffp_contract;
2931 PreciseFPModel =
true;
2932 }
else if (Val.equals(
"strict")) {
2933 StrictFPModel =
true;
2934 optID = options::OPT_frounding_math;
2935 FPExceptionBehavior =
"strict";
2938 TrappingMath =
true;
2940 D.
Diag(diag::err_drv_unsupported_option_argument)
2941 << A->getSpelling() << Val;
2951 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2952 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2953 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2954 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2955 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2956 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2957 case options::OPT_fmath_errno: MathErrno =
true;
break;
2958 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2959 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2960 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2961 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2962 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2963 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2964 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2965 case options::OPT_ftrapping_math:
2966 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2967 !FPExceptionBehavior.equals(
"strict"))
2969 D.
Diag(clang::diag::warn_drv_overriding_option)
2970 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2971 FPExceptionBehavior)
2972 <<
"-ftrapping-math";
2973 TrappingMath =
true;
2974 TrappingMathPresent =
true;
2975 FPExceptionBehavior =
"strict";
2977 case options::OPT_fno_trapping_math:
2978 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2979 !FPExceptionBehavior.equals(
"ignore"))
2981 D.
Diag(clang::diag::warn_drv_overriding_option)
2982 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2983 FPExceptionBehavior)
2984 <<
"-fno-trapping-math";
2985 TrappingMath =
false;
2986 TrappingMathPresent =
true;
2987 FPExceptionBehavior =
"ignore";
2990 case options::OPT_frounding_math:
2991 RoundingFPMath =
true;
2992 RoundingMathPresent =
true;
2995 case options::OPT_fno_rounding_math:
2996 RoundingFPMath =
false;
2997 RoundingMathPresent =
false;
3000 case options::OPT_fdenormal_fp_math_EQ:
3001 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
3002 DenormalFP32Math = DenormalFPMath;
3003 if (!DenormalFPMath.isValid()) {
3004 D.
Diag(diag::err_drv_invalid_value)
3005 << A->getAsString(Args) << A->getValue();
3009 case options::OPT_fdenormal_fp_math_f32_EQ:
3010 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
3011 if (!DenormalFP32Math.isValid()) {
3012 D.
Diag(diag::err_drv_invalid_value)
3013 << A->getAsString(Args) << A->getValue();
3018 case options::OPT_ffp_contract: {
3019 StringRef Val = A->getValue();
3020 if (PreciseFPModel) {
3025 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off") ||
3026 Val.equals(
"fast-honor-pragmas")) {
3028 LastSeenFfpContractOption = Val;
3030 D.
Diag(diag::err_drv_unsupported_option_argument)
3031 << A->getSpelling() << Val;
3036 case options::OPT_ffp_model_EQ:
3043 case options::OPT_ffp_exception_behavior_EQ: {
3044 StringRef Val = A->getValue();
3045 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
3046 !FPExceptionBehavior.equals(Val))
3048 D.
Diag(clang::diag::warn_drv_overriding_option)
3049 << Args.MakeArgString(
"-ffp-exception-behavior=" +
3050 FPExceptionBehavior)
3051 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
3052 TrappingMath = TrappingMathPresent =
false;
3053 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
3054 FPExceptionBehavior = Val;
3055 else if (Val.equals(
"strict")) {
3056 FPExceptionBehavior = Val;
3057 TrappingMath = TrappingMathPresent =
true;
3059 D.
Diag(diag::err_drv_unsupported_option_argument)
3060 << A->getSpelling() << Val;
3065 case options::OPT_ffp_eval_method_EQ: {
3066 StringRef Val = A->getValue();
3067 if (Val.equals(
"double") || Val.equals(
"extended") ||
3068 Val.equals(
"source"))
3071 D.
Diag(diag::err_drv_unsupported_option_argument)
3072 << A->getSpelling() << Val;
3076 case options::OPT_fexcess_precision_EQ: {
3077 StringRef Val = A->getValue();
3078 const llvm::Triple::ArchType Arch = TC.
getArch();
3079 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
3080 if (Val.equals(
"standard") || Val.equals(
"fast"))
3081 Float16ExcessPrecision = Val;
3085 else if (Val.equals(
"16"))
3086 Float16ExcessPrecision =
"none";
3088 D.
Diag(diag::err_drv_unsupported_option_argument)
3089 << A->getSpelling() << Val;
3091 if (!(Val.equals(
"standard") || Val.equals(
"fast")))
3092 D.
Diag(diag::err_drv_unsupported_option_argument)
3093 << A->getSpelling() << Val;
3095 BFloat16ExcessPrecision = Float16ExcessPrecision;
3098 case options::OPT_ffinite_math_only:
3102 case options::OPT_fno_finite_math_only:
3107 case options::OPT_funsafe_math_optimizations:
3108 AssociativeMath =
true;
3109 ReciprocalMath =
true;
3110 SignedZeros =
false;
3112 TrappingMath =
false;
3113 FPExceptionBehavior =
"";
3114 FPContract =
"fast";
3115 SeenUnsafeMathModeOption =
true;
3117 case options::OPT_fno_unsafe_math_optimizations:
3118 AssociativeMath =
false;
3119 ReciprocalMath =
false;
3122 TrappingMath =
true;
3123 FPExceptionBehavior =
"strict";
3126 DenormalFPMath = llvm::DenormalMode::getIEEE();
3127 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3130 if (LastSeenFfpContractOption !=
"") {
3131 FPContract = LastSeenFfpContractOption;
3132 }
else if (SeenUnsafeMathModeOption)
3137 case options::OPT_Ofast:
3142 case options::OPT_ffast_math: {
3146 case options::OPT_fno_fast_math:
3153 AssociativeMath =
false;
3154 ReciprocalMath =
false;
3158 DenormalFPMath = DefaultDenormalFPMath;
3159 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3162 if (LastSeenFfpContractOption !=
"") {
3163 FPContract = LastSeenFfpContractOption;
3164 }
else if (SeenUnsafeMathModeOption)
3169 if (StrictFPModel) {
3172 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3173 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3174 DenormalFPMath == llvm::DenormalMode::getIEEE() &&
3175 DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
3176 FPContract.equals(
"off"))
3180 StrictFPModel =
false;
3182 auto RHS = (A->getNumValues() == 0)
3184 : Args.MakeArgString(A->getSpelling() + A->getValue());
3185 if (RHS !=
"-ffp-model=strict")
3186 D.
Diag(clang::diag::warn_drv_overriding_option)
3187 <<
"-ffp-model=strict" << RHS;
3196 CmdArgs.push_back(
"-menable-no-infs");
3199 CmdArgs.push_back(
"-menable-no-nans");
3202 CmdArgs.push_back(
"-fapprox-func");
3205 CmdArgs.push_back(
"-fmath-errno");
3207 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3209 CmdArgs.push_back(
"-funsafe-math-optimizations");
3212 CmdArgs.push_back(
"-fno-signed-zeros");
3214 if (AssociativeMath && !SignedZeros && !TrappingMath)
3215 CmdArgs.push_back(
"-mreassociate");
3218 CmdArgs.push_back(
"-freciprocal-math");
3222 assert(FPExceptionBehavior.equals(
"strict"));
3226 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3228 llvm::raw_svector_ostream ArgStr(DenormFlag);
3229 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3230 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3234 if (DenormalFP32Math != DenormalFPMath) {
3236 llvm::raw_svector_ostream ArgStr(DenormFlag);
3237 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3238 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3241 if (!FPContract.empty())
3242 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3244 if (!RoundingFPMath)
3245 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3247 if (RoundingFPMath && RoundingMathPresent)
3248 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3250 if (!FPExceptionBehavior.empty())
3251 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3252 FPExceptionBehavior));
3254 if (!FPEvalMethod.empty())
3255 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3257 if (!Float16ExcessPrecision.empty())
3258 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3259 Float16ExcessPrecision));
3260 if (!BFloat16ExcessPrecision.empty())
3261 CmdArgs.push_back(Args.MakeArgString(
"-fbfloat16-excess-precision=" +
3262 BFloat16ExcessPrecision));
3269 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3270 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3271 CmdArgs.push_back(
"-ffast-math");
3272 if (FPModel.equals(
"fast")) {
3273 if (FPContract.equals(
"fast"))
3276 else if (FPContract.empty())
3278 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3280 D.
Diag(clang::diag::warn_drv_overriding_option)
3281 <<
"-ffp-model=fast"
3282 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3287 if (!HonorINFs && !HonorNaNs)
3288 CmdArgs.push_back(
"-ffinite-math-only");
3290 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3291 CmdArgs.push_back(
"-mfpmath");
3292 CmdArgs.push_back(A->getValue());
3296 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3297 options::OPT_fstrict_float_cast_overflow,
false))
3298 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3302 if (!ComplexRangeStr.empty()) {
3303 CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
3304 if (Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))
3305 CmdArgs.push_back(Args.MakeArgString(
"-fcomplex-arithmetic=" +
3308 if (Args.hasArg(options::OPT_fcx_limited_range))
3309 CmdArgs.push_back(
"-fcx-limited-range");
3310 if (Args.hasArg(options::OPT_fcx_fortran_rules))
3311 CmdArgs.push_back(
"-fcx-fortran-rules");
3312 if (Args.hasArg(options::OPT_fno_cx_limited_range))
3313 CmdArgs.push_back(
"-fno-cx-limited-range");
3314 if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
3315 CmdArgs.push_back(
"-fno-cx-fortran-rules");
3319 const llvm::Triple &Triple,
3322 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3323 CmdArgs.push_back(
"-analyzer-checker=core");
3324 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3326 if (!Triple.isWindowsMSVCEnvironment()) {
3327 CmdArgs.push_back(
"-analyzer-checker=unix");
3330 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3331 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3332 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3333 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3334 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3335 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3339 if (Triple.isPS()) {
3340 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3341 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3344 if (Triple.isOSDarwin()) {
3345 CmdArgs.push_back(
"-analyzer-checker=osx");
3347 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3349 else if (Triple.isOSFuchsia())
3350 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3352 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3355 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3357 if (!Triple.isPS()) {
3358 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3359 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3360 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3361 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3362 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3363 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3367 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3368 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3372 CmdArgs.push_back(
"-analyzer-output");
3373 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3374 CmdArgs.push_back(A->getValue());
3376 CmdArgs.push_back(
"plist");
3381 CmdArgs.push_back(
"-w");
3384 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3391 if (std::isdigit(S[0]))
3394 return llvm::all_of(S, [](
char C) {
return std::isalnum(
C) ||
C ==
'_'; });
3398 const ArgList &Args, ArgStringList &CmdArgs,
3399 bool KernelOrKext) {
3404 if (EffectiveTriple.isNVPTX())
3412 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3413 options::OPT_fstack_protector_all,
3414 options::OPT_fstack_protector_strong,
3415 options::OPT_fstack_protector)) {
3416 if (A->getOption().matches(options::OPT_fstack_protector))
3417 StackProtectorLevel =
3419 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3421 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3425 D.
Diag(diag::warn_drv_unsupported_option_for_target)
3426 << A->getSpelling() << EffectiveTriple.getTriple();
3427 StackProtectorLevel = DefaultStackProtectorLevel;
3430 StackProtectorLevel = DefaultStackProtectorLevel;
3433 if (StackProtectorLevel) {
3434 CmdArgs.push_back(
"-stack-protector");
3435 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3439 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3440 StringRef Str(A->getValue());
3441 if (Str.starts_with(
"ssp-buffer-size=")) {
3442 if (StackProtectorLevel) {
3443 CmdArgs.push_back(
"-stack-protector-buffer-size");
3445 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3451 const std::string &TripleStr = EffectiveTriple.getTriple();
3452 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3453 StringRef
Value = A->getValue();
3454 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3455 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3456 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3457 << A->getAsString(Args) << TripleStr;
3458 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3459 EffectiveTriple.isThumb()) &&
3461 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3462 << A->getOption().getName() <<
Value <<
"tls global";
3465 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3467 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3468 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3469 << A->getAsString(Args);
3474 D.
Diag(diag::err_target_unsupported_tp_hard)
3475 << EffectiveTriple.getArchName();
3479 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3480 StringRef
Value = A->getValue();
3481 if (
Value !=
"cp15") {
3482 D.
Diag(diag::err_drv_argument_not_allowed_with)
3483 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3487 CmdArgs.push_back(
"-target-feature");
3488 CmdArgs.push_back(
"+read-tp-tpidruro");
3490 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3491 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3492 << A->getOption().getName() <<
Value <<
"sysreg global";
3495 A->render(Args, CmdArgs);
3498 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3499 StringRef
Value = A->getValue();
3500 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3501 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3502 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3503 << A->getAsString(Args) << TripleStr;
3505 if (
Value.getAsInteger(10, Offset)) {
3506 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3509 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3510 (Offset < 0 || Offset > 0xfffff)) {
3511 D.
Diag(diag::err_drv_invalid_int_value)
3512 << A->getOption().getName() <<
Value;
3515 A->render(Args, CmdArgs);
3518 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3519 StringRef
Value = A->getValue();
3520 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3521 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3522 << A->getAsString(Args) << TripleStr;
3523 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3524 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3525 << A->getOption().getName() <<
Value <<
"fs gs";
3528 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3529 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3532 A->render(Args, CmdArgs);
3535 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3536 StringRef
Value = A->getValue();
3538 D.
Diag(diag::err_drv_argument_only_allowed_with)
3539 << A->getOption().getName() <<
"legal symbol name";
3542 A->render(Args, CmdArgs);
3547 ArgStringList &CmdArgs) {
3550 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3553 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3554 !EffectiveTriple.isPPC64() && !EffectiveTriple.isAArch64())
3557 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3558 options::OPT_fno_stack_clash_protection);
3563 const ArgList &Args,
3564 ArgStringList &CmdArgs) {
3566 StringRef TrivialAutoVarInit =
"";
3568 for (
const Arg *A : Args) {
3569 switch (A->getOption().getID()) {
3572 case options::OPT_ftrivial_auto_var_init: {
3574 StringRef Val = A->getValue();
3575 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3576 TrivialAutoVarInit = Val;
3578 D.
Diag(diag::err_drv_unsupported_option_argument)
3579 << A->getSpelling() << Val;
3585 if (TrivialAutoVarInit.empty())
3586 switch (DefaultTrivialAutoVarInit) {
3590 TrivialAutoVarInit =
"pattern";
3593 TrivialAutoVarInit =
"zero";
3597 if (!TrivialAutoVarInit.empty()) {
3599 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3603 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3604 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3606 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3608 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3610 StringRef Val = A->getValue();
3611 if (std::stoi(Val.str()) <= 0)
3612 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3614 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3617 if (Arg *A = Args.getLastArg(options::OPT_ftrivial_auto_var_init_max_size)) {
3618 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3620 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3622 D.
Diag(diag::err_drv_trivial_auto_var_init_max_size_missing_dependency);
3624 StringRef Val = A->getValue();
3625 if (std::stoi(Val.str()) <= 0)
3626 D.
Diag(diag::err_drv_trivial_auto_var_init_max_size_invalid_value);
3628 Args.MakeArgString(
"-ftrivial-auto-var-init-max-size=" + Val));
3636 const unsigned ForwardedArguments[] = {
3637 options::OPT_cl_opt_disable,
3638 options::OPT_cl_strict_aliasing,
3639 options::OPT_cl_single_precision_constant,
3640 options::OPT_cl_finite_math_only,
3641 options::OPT_cl_kernel_arg_info,
3642 options::OPT_cl_unsafe_math_optimizations,
3643 options::OPT_cl_fast_relaxed_math,
3644 options::OPT_cl_mad_enable,
3645 options::OPT_cl_no_signed_zeros,
3646 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3647 options::OPT_cl_uniform_work_group_size
3650 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3651 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3652 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3653 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3654 std::string CLExtStr = std::string(
"-cl-ext=") + A->getValue();
3655 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3658 for (
const auto &Arg : ForwardedArguments)
3659 if (
const auto *A = Args.getLastArg(Arg))
3660 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3665 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3666 CmdArgs.push_back(
"-finclude-default-header");
3667 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3673 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3678 options::OPT_emit_llvm,
3679 options::OPT_emit_obj,
3680 options::OPT_disable_llvm_passes,
3681 options::OPT_fnative_half_type,
3682 options::OPT_hlsl_entrypoint};
3685 for (
const auto &Arg : ForwardedArguments)
3686 if (
const auto *A = Args.getLastArg(Arg))
3687 A->renderAsInput(Args, CmdArgs);
3689 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3690 !Args.hasArg(options::OPT_nostdinc))
3691 CmdArgs.push_back(
"-finclude-default-header");
3695 ArgStringList &CmdArgs,
types::ID InputType) {
3696 if (!Args.hasArg(options::OPT_fopenacc))
3699 CmdArgs.push_back(
"-fopenacc");
3701 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override)) {
3702 StringRef
Value = A->getValue();
3704 if (!
Value.getAsInteger(10, Version))
3705 A->renderAsInput(Args, CmdArgs);
3707 D.
Diag(diag::err_drv_clang_unsupported) <<
Value;
3712 ArgStringList &CmdArgs) {
3713 bool ARCMTEnabled =
false;
3714 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3715 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3716 options::OPT_ccc_arcmt_modify,
3717 options::OPT_ccc_arcmt_migrate)) {
3718 ARCMTEnabled =
true;
3719 switch (A->getOption().getID()) {
3720 default: llvm_unreachable(
"missed a case");
3721 case options::OPT_ccc_arcmt_check:
3722 CmdArgs.push_back(
"-arcmt-action=check");
3724 case options::OPT_ccc_arcmt_modify:
3725 CmdArgs.push_back(
"-arcmt-action=modify");
3727 case options::OPT_ccc_arcmt_migrate:
3728 CmdArgs.push_back(
"-arcmt-action=migrate");
3729 CmdArgs.push_back(
"-mt-migrate-directory");
3730 CmdArgs.push_back(A->getValue());
3732 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3733 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3738 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3739 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3740 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3743 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3745 D.
Diag(diag::err_drv_argument_not_allowed_with)
3746 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3748 CmdArgs.push_back(
"-mt-migrate-directory");
3749 CmdArgs.push_back(A->getValue());
3751 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3752 options::OPT_objcmt_migrate_subscripting,
3753 options::OPT_objcmt_migrate_property)) {
3755 CmdArgs.push_back(
"-objcmt-migrate-literals");
3756 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3757 CmdArgs.push_back(
"-objcmt-migrate-property");
3759 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3760 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3761 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3764 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3765 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3766 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3767 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3768 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3769 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3770 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3771 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3772 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3773 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3774 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3775 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3776 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3777 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3778 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3779 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3784 const ArgList &Args, ArgStringList &CmdArgs) {
3787 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3788 !Args.hasArg(options::OPT_mkernel));
3790 CmdArgs.push_back(
"-fno-builtin");
3793 if (Args.hasArg(options::OPT_ffreestanding))
3794 UseBuiltins =
false;
3797 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3803 A->render(Args, CmdArgs);
3809 if (TC.
getArch() == llvm::Triple::le32)
3810 CmdArgs.push_back(
"-fno-math-builtin");
3814 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
3817 return Path.getSingleStringRef() !=
"";
3819 if (llvm::sys::path::cache_directory(
Result)) {
3820 llvm::sys::path::append(
Result,
"clang");
3821 llvm::sys::path::append(
Result,
"ModuleCache");
3829 const char *BaseInput) {
3830 if (Arg *ModuleOutputEQ = Args.getLastArg(options::OPT_fmodule_output_EQ))
3831 return StringRef(ModuleOutputEQ->getValue());
3834 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o);
3835 FinalOutput && Args.hasArg(options::OPT_c))
3836 OutputPath = FinalOutput->getValue();
3838 OutputPath = BaseInput;
3841 llvm::sys::path::replace_extension(OutputPath, Extension);
3846 const ArgList &Args,
const InputInfo &Input,
3847 const InputInfo &Output,
bool HaveStd20,
3848 ArgStringList &CmdArgs) {
3850 bool HaveStdCXXModules = IsCXX && HaveStd20;
3851 bool HaveModules = HaveStdCXXModules;
3856 bool HaveClangModules =
false;
3857 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3858 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3859 options::OPT_fno_cxx_modules,
true);
3860 if (AllowedInCXX || !IsCXX) {
3861 CmdArgs.push_back(
"-fmodules");
3862 HaveClangModules =
true;
3866 HaveModules |= HaveClangModules;
3870 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3871 options::OPT_fno_implicit_module_maps, HaveClangModules))
3872 CmdArgs.push_back(
"-fimplicit-module-maps");
3875 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3876 options::OPT_fno_modules_decluse);
3880 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3881 options::OPT_fno_modules_strict_decluse,
false))
3882 CmdArgs.push_back(
"-fmodules-strict-decluse");
3885 bool ImplicitModules =
false;
3886 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3887 options::OPT_fno_implicit_modules, HaveClangModules)) {
3889 CmdArgs.push_back(
"-fno-implicit-modules");
3890 }
else if (HaveModules) {
3891 ImplicitModules =
true;
3895 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3896 Path = A->getValue();
3898 bool HasPath =
true;
3899 if (
C.isForDiagnostics()) {
3903 llvm::sys::path::replace_extension(Path,
".cache");
3904 llvm::sys::path::append(Path,
"modules");
3905 }
else if (Path.empty()) {
3913 const char Arg[] =
"-fmodules-cache-path=";
3914 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3915 CmdArgs.push_back(Args.MakeArgString(Path));
3920 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3921 options::OPT_fno_prebuilt_implicit_modules,
false))
3922 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3923 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3924 options::OPT_fno_modules_validate_input_files_content,
3926 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3931 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3935 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3939 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3941 llvm::sys::path::append(BuiltinModuleMap,
"include");
3942 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3943 if (llvm::sys::fs::exists(BuiltinModuleMap))
3945 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3952 if (HaveModules || Input.
getType() == clang::driver::types::TY_ModuleFile) {
3953 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3956 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3957 CmdArgs.push_back(Args.MakeArgString(
3958 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3962 Args.ClaimAllArgs(options::OPT_fmodule_file);
3966 if (HaveClangModules &&
C.isForDiagnostics()) {
3968 llvm::sys::path::replace_extension(VFSDir,
".cache");
3970 C.addTempFile(Args.MakeArgString(VFSDir));
3972 llvm::sys::path::append(VFSDir,
"vfs");
3973 CmdArgs.push_back(
"-module-dependency-dir");
3974 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3977 if (HaveClangModules)
3978 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3981 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3982 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3983 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3985 if (HaveClangModules) {
3986 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3988 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3989 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3990 D.
Diag(diag::err_drv_argument_not_allowed_with)
3991 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3993 llvm::sys::fs::file_status Status;
3994 if (llvm::sys::fs::status(A->getValue(), Status))
3995 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3996 CmdArgs.push_back(Args.MakeArgString(
3997 "-fbuild-session-timestamp=" +
3998 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3999 Status.getLastModificationTime().time_since_epoch())
4003 if (Args.getLastArg(
4004 options::OPT_fmodules_validate_once_per_build_session)) {
4005 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4006 options::OPT_fbuild_session_file))
4007 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4009 Args.AddLastArg(CmdArgs,
4010 options::OPT_fmodules_validate_once_per_build_session);
4013 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
4014 options::OPT_fno_modules_validate_system_headers,
4016 CmdArgs.push_back(
"-fmodules-validate-system-headers");
4018 Args.AddLastArg(CmdArgs,
4019 options::OPT_fmodules_disable_diagnostic_validation);
4021 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
4022 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
4023 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
4024 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
4025 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
4026 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
4031 CmdArgs.push_back(
"-fskip-odr-check-in-gmf");
4033 if (Args.hasArg(options::OPT_modules_reduced_bmi) &&
4034 (Input.
getType() == driver::types::TY_CXXModule ||
4035 Input.
getType() == driver::types::TY_PP_CXXModule)) {
4036 CmdArgs.push_back(
"-fexperimental-modules-reduced-bmi");
4038 if (Args.hasArg(options::OPT_fmodule_output_EQ))
4039 Args.AddLastArg(CmdArgs, options::OPT_fmodule_output_EQ);
4041 CmdArgs.push_back(Args.MakeArgString(
4042 "-fmodule-output=" +
4049 Args.ClaimAllArgs(options::OPT_modules_reduced_bmi);
4057 if (Input.
getType() == driver::types::TY_CXXModule ||
4058 Input.
getType() == driver::types::TY_PP_CXXModule ||
4059 Input.
getType() == driver::types::TY_ModuleFile) {
4060 Args.ClaimAllArgs(options::OPT_fmodule_output);
4061 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
4068 ArgStringList &CmdArgs) {
4070 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
4071 options::OPT_fno_signed_char,
4072 options::OPT_funsigned_char,
4073 options::OPT_fno_unsigned_char)) {
4074 if (A->getOption().matches(options::OPT_funsigned_char) ||
4075 A->getOption().matches(options::OPT_fno_signed_char)) {
4076 CmdArgs.push_back(
"-fno-signed-char");
4079 CmdArgs.push_back(
"-fno-signed-char");
4083 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
4085 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4086 options::OPT_fno_short_wchar)) {
4087 if (A->getOption().matches(options::OPT_fshort_wchar)) {
4088 CmdArgs.push_back(
"-fwchar-type=short");
4089 CmdArgs.push_back(
"-fno-signed-wchar");
4091 bool IsARM =
T.isARM() ||
T.isThumb() ||
T.isAArch64();
4092 CmdArgs.push_back(
"-fwchar-type=int");
4094 (IsARM && !(
T.isOSWindows() ||
T.isOSNetBSD() ||
T.isOSOpenBSD())))
4095 CmdArgs.push_back(
"-fno-signed-wchar");
4097 CmdArgs.push_back(
"-fsigned-wchar");
4099 }
else if (
T.isOSzOS())
4100 CmdArgs.push_back(
"-fno-signed-wchar");
4104 const llvm::Triple &
T,
const ArgList &Args,
4106 const InputInfo &Input, ArgStringList &CmdArgs) {
4107 const llvm::Triple::ArchType Arch = TC.
getArch();
4113 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4114 options::OPT_fno_objc_legacy_dispatch,
4117 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
4119 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
4125 if (Arch == llvm::Triple::x86 &&
T.isMacOSX() &&
4127 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
4134 CmdArgs.push_back(
"-fobjc-arc");
4141 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
4143 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
4148 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4149 options::OPT_fno_objc_arc_exceptions,
4151 CmdArgs.push_back(
"-fobjc-arc-exceptions");
4156 if (Args.hasArg(options::OPT_fno_objc_arc)) {
4157 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4158 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4164 auto *Arg = Args.getLastArg(
4165 options::OPT_fobjc_convert_messages_to_runtime_calls,
4166 options::OPT_fno_objc_convert_messages_to_runtime_calls);
4168 Arg->getOption().matches(
4169 options::OPT_fno_objc_convert_messages_to_runtime_calls))
4170 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
4175 if (InferCovariantReturns)
4176 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4181 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4185 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4186 D.
Diag(diag::err_objc_weak_unsupported);
4188 WeakArg->render(Args, CmdArgs);
4192 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4193 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
4197 ArgStringList &CmdArgs) {
4198 bool CaretDefault =
true;
4199 bool ColumnDefault =
true;
4201 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4202 options::OPT__SLASH_diagnostics_column,
4203 options::OPT__SLASH_diagnostics_caret)) {
4204 switch (A->getOption().getID()) {
4205 case options::OPT__SLASH_diagnostics_caret:
4206 CaretDefault =
true;
4207 ColumnDefault =
true;
4209 case options::OPT__SLASH_diagnostics_column:
4210 CaretDefault =
false;
4211 ColumnDefault =
true;
4213 case options::OPT__SLASH_diagnostics_classic:
4214 CaretDefault =
false;
4215 ColumnDefault =
false;
4221 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4222 options::OPT_fno_caret_diagnostics, CaretDefault))
4223 CmdArgs.push_back(
"-fno-caret-diagnostics");
4225 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4226 options::OPT_fno_diagnostics_fixit_info);
4227 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4228 options::OPT_fno_diagnostics_show_option);
4231 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4232 CmdArgs.push_back(
"-fdiagnostics-show-category");
4233 CmdArgs.push_back(A->getValue());
4236 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4237 options::OPT_fno_diagnostics_show_hotness);
4240 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4242 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4243 CmdArgs.push_back(Args.MakeArgString(Opt));
4247 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4249 std::string(
"-fdiagnostics-misexpect-tolerance=") + A->getValue();
4250 CmdArgs.push_back(Args.MakeArgString(Opt));
4253 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4254 CmdArgs.push_back(
"-fdiagnostics-format");
4255 CmdArgs.push_back(A->getValue());
4256 if (StringRef(A->getValue()) ==
"sarif" ||
4257 StringRef(A->getValue()) ==
"SARIF")
4258 D.
Diag(diag::warn_drv_sarif_format_unstable);
4261 if (
const Arg *A = Args.getLastArg(
4262 options::OPT_fdiagnostics_show_note_include_stack,
4263 options::OPT_fno_diagnostics_show_note_include_stack)) {
4264 const Option &O = A->getOption();
4265 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4266 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4268 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4275 Args.getLastArg(options::OPT_fcolor_diagnostics,
4276 options::OPT_fno_color_diagnostics);
4277 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4278 StringRef
Value(A->getValue());
4280 D.
Diag(diag::err_drv_invalid_argument_to_option)
4281 <<
Value << A->getOption().getName();
4285 CmdArgs.push_back(
"-fcolor-diagnostics");
4287 if (Args.hasArg(options::OPT_fansi_escape_codes))
4288 CmdArgs.push_back(
"-fansi-escape-codes");
4290 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4291 options::OPT_fno_show_source_location);
4293 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4294 options::OPT_fno_diagnostics_show_line_numbers);
4296 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4297 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4299 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4301 CmdArgs.push_back(
"-fno-show-column");
4303 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4304 options::OPT_fno_spell_checking);
4308 const ArgList &Args, Arg *&Arg) {
4309 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4310 options::OPT_gno_split_dwarf);
4311 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4314 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4317 StringRef
Value = Arg->getValue();
4318 if (
Value ==
"split")
4320 if (
Value ==
"single")
4323 D.
Diag(diag::err_drv_unsupported_option_argument)
4324 << Arg->getSpelling() << Arg->getValue();
4329 const ArgList &Args, ArgStringList &CmdArgs,
4330 unsigned DwarfVersion) {
4331 auto *DwarfFormatArg =
4332 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4333 if (!DwarfFormatArg)
4336 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4337 if (DwarfVersion < 3)
4338 D.
Diag(diag::err_drv_argument_only_allowed_with)
4339 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4340 else if (!
T.isArch64Bit())
4341 D.
Diag(diag::err_drv_argument_only_allowed_with)
4342 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4343 else if (!
T.isOSBinFormatELF())
4344 D.
Diag(diag::err_drv_argument_only_allowed_with)
4345 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4348 DwarfFormatArg->render(Args, CmdArgs);
4353 const ArgList &Args,
bool IRInput, ArgStringList &CmdArgs,
4355 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
4357 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4358 options::OPT_fno_debug_info_for_profiling,
false) &&
4360 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4361 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4374 bool SplitDWARFInlining =
4375 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4376 options::OPT_fno_split_dwarf_inlining,
false);
4381 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4387 SplitDWARFInlining =
false;
4390 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4391 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4395 A->getOption().matches(options::OPT_gN_Group)) {
4401 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
4402 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
4403 (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
4404 SplitDWARFInlining))
4410 bool HasDebuggerTuning =
false;
4412 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4413 HasDebuggerTuning =
true;
4415 if (A->getOption().matches(options::OPT_glldb))
4416 DebuggerTuning = llvm::DebuggerKind::LLDB;
4417 else if (A->getOption().matches(options::OPT_gsce))
4418 DebuggerTuning = llvm::DebuggerKind::SCE;
4419 else if (A->getOption().matches(options::OPT_gdbx))
4420 DebuggerTuning = llvm::DebuggerKind::DBX;
4422 DebuggerTuning = llvm::DebuggerKind::GDB;
4427 bool EmitDwarf =
false;
4431 bool EmitCodeView =
false;
4432 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4437 if (!EmitCodeView && !EmitDwarf &&
4438 DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
4440 case llvm::codegenoptions::DIF_CodeView:
4441 EmitCodeView =
true;
4443 case llvm::codegenoptions::DIF_DWARF:
4449 unsigned RequestedDWARFVersion = 0;
4450 unsigned EffectiveDWARFVersion = 0;
4455 EffectiveDWARFVersion =
4458 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4462 if (RequestedDWARFVersion == 0 &&
4463 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
4464 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
4468 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4470 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4471 DebuggerTuning == llvm::DebuggerKind::DBX))
4472 CmdArgs.push_back(
"-gstrict-dwarf");
4475 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4483 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4485 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4487 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4488 DebuggerTuning != llvm::DebuggerKind::DBX)))
4489 CmdArgs.push_back(
"-gno-column-info");
4492 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4497 if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
4498 DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
4499 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4500 CmdArgs.push_back(
"-dwarf-ext-refs");
4501 CmdArgs.push_back(
"-fmodule-format=obj");
4506 if (
T.isOSBinFormatELF() && SplitDWARFInlining)
4507 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4514 bool NeedFullDebug = Args.hasFlag(
4515 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4516 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4518 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4521 if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
4522 DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
4523 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4524 options::OPT_feliminate_unused_debug_types,
false))
4525 DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
4526 else if (NeedFullDebug)
4527 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
4530 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4536 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4537 if (RequestedDWARFVersion < 5)
4538 D.
Diag(diag::err_drv_argument_only_allowed_with)
4539 << A->getAsString(Args) <<
"-gdwarf-5";
4540 else if (EffectiveDWARFVersion < 5)
4543 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4545 << EffectiveDWARFVersion;
4547 CmdArgs.push_back(
"-gembed-source");
4551 CmdArgs.push_back(
"-gcodeview");
4553 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4554 options::OPT_gno_codeview_ghash);
4556 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4557 options::OPT_gno_codeview_command_line);
4560 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4561 options::OPT_gno_inline_line_tables);
4565 DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
4566 DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
4574 T.isOSAIX() && !HasDebuggerTuning
4575 ? llvm::DebuggerKind::Default
4579 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4583 CmdArgs.push_back(
"-debug-info-macro");
4586 const auto *PubnamesArg =
4587 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4588 options::OPT_gpubnames, options::OPT_gno_pubnames);
4591 const bool OptionSet =
4593 (PubnamesArg->getOption().matches(options::OPT_gpubnames) ||
4594 PubnamesArg->getOption().matches(options::OPT_ggnu_pubnames)));
4595 if ((DebuggerTuning != llvm::DebuggerKind::LLDB || OptionSet) &&
4597 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4598 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames))))
4599 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4600 options::OPT_gpubnames)
4602 :
"-ggnu-pubnames");
4604 const auto *SimpleTemplateNamesArg =
4605 Args.getLastArg(options::OPT_gsimple_template_names,
4606 options::OPT_gno_simple_template_names);
4607 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4608 if (SimpleTemplateNamesArg &&
4610 const auto &Opt = SimpleTemplateNamesArg->getOption();
4611 if (Opt.matches(options::OPT_gsimple_template_names)) {
4612 ForwardTemplateParams =
true;
4613 CmdArgs.push_back(
"-gsimple-template-names=simple");
4618 bool UseDebugTemplateAlias =
4619 DebuggerTuning == llvm::DebuggerKind::SCE && RequestedDWARFVersion >= 4;
4620 if (
const auto *DebugTemplateAlias = Args.getLastArg(
4621 options::OPT_gtemplate_alias, options::OPT_gno_template_alias)) {
4625 const auto &Opt = DebugTemplateAlias->getOption();
4626 UseDebugTemplateAlias = Opt.matches(options::OPT_gtemplate_alias);
4629 if (UseDebugTemplateAlias)
4630 CmdArgs.push_back(
"-gtemplate-alias");
4632 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4633 StringRef
v = A->getValue();
4634 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4637 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4638 options::OPT_fno_debug_ranges_base_address);
4643 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4644 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4647 CmdArgs.push_back(
"-mllvm");
4648 CmdArgs.push_back(
"-generate-arange-section");
4651 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4652 options::OPT_fno_force_dwarf_frame);
4654 if (Args.hasFlag(options::OPT_fdebug_types_section,
4655 options::OPT_fno_debug_types_section,
false)) {
4656 if (!(
T.isOSBinFormatELF() ||
T.isOSBinFormatWasm())) {
4657 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4658 << Args.getLastArg(options::OPT_fdebug_types_section)
4662 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4664 CmdArgs.push_back(
"-mllvm");
4665 CmdArgs.push_back(
"-generate-type-units");
4672 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4673 options::OPT_fno_dwarf_directory_asm,
4675 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4679 if (ForwardTemplateParams)
4680 CmdArgs.push_back(
"-debug-forward-template-params");
4684 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4685 CmdArgs.push_back(
"-dwarf-explicit-import");
4691 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
4693 if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
4694 CmdArgs.push_back(
"-fjmc");
4696 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"/JMC"
4699 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
4702 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
4707 const char *DebugCompilationDir =
4719 ArgStringList &CmdArgs) {
4720 unsigned RTOptionID = options::OPT__SLASH_MT;
4722 if (Args.hasArg(options::OPT__SLASH_LDd))
4725 RTOptionID = options::OPT__SLASH_MTd;
4727 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4728 RTOptionID = A->getOption().getID();
4730 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4731 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4732 .Case(
"static", options::OPT__SLASH_MT)
4733 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4734 .Case(
"dll", options::OPT__SLASH_MD)
4735 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4736 .Default(options::OPT__SLASH_MT);
4739 StringRef FlagForCRT;
4740 switch (RTOptionID) {
4741 case options::OPT__SLASH_MD:
4742 if (Args.hasArg(options::OPT__SLASH_LDd))
4743 CmdArgs.push_back(
"-D_DEBUG");
4744 CmdArgs.push_back(
"-D_MT");
4745 CmdArgs.push_back(
"-D_DLL");
4746 FlagForCRT =
"--dependent-lib=msvcrt";
4748 case options::OPT__SLASH_MDd:
4749 CmdArgs.push_back(
"-D_DEBUG");
4750 CmdArgs.push_back(
"-D_MT");
4751 CmdArgs.push_back(
"-D_DLL");
4752 FlagForCRT =
"--dependent-lib=msvcrtd";
4754 case options::OPT__SLASH_MT:
4755 if (Args.hasArg(options::OPT__SLASH_LDd))
4756 CmdArgs.push_back(
"-D_DEBUG");
4757 CmdArgs.push_back(
"-D_MT");
4758 CmdArgs.push_back(
"-flto-visibility-public-std");
4759 FlagForCRT =
"--dependent-lib=libcmt";
4761 case options::OPT__SLASH_MTd:
4762 CmdArgs.push_back(
"-D_DEBUG");
4763 CmdArgs.push_back(
"-D_MT");
4764 CmdArgs.push_back(
"-flto-visibility-public-std");
4765 FlagForCRT =
"--dependent-lib=libcmtd";
4768 llvm_unreachable(
"Unexpected option ID.");
4771 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4772 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4774 CmdArgs.push_back(FlagForCRT.data());
4779 CmdArgs.push_back(
"--dependent-lib=oldnames");
4786 CmdArgs.push_back(
"--dependent-lib=softintrin");
4791 const ArgList &Args,
const char *LinkingOutput)
const {
4793 const llvm::Triple &RawTriple = TC.
getTriple();
4795 const std::string &TripleStr = Triple.getTriple();
4798 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4800 ArgStringList CmdArgs;
4802 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4814 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4817 bool IsHostOffloadingAction =
4820 Args.hasFlag(options::OPT_offload_new_driver,
4821 options::OPT_no_offload_new_driver,
false));
4824 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4825 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4826 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4830 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4834 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4838 const InputInfo *CudaDeviceInput =
nullptr;
4839 const InputInfo *OpenMPDeviceInput =
nullptr;
4841 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4843 }
else if (IsExtractAPI) {
4844 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4845 if (I.getType() != ExpectedInputType) {
4846 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4850 ExtractAPIInputs.push_back(I);
4851 }
else if (IsHostOffloadingAction) {
4852 HostOffloadingInputs.push_back(I);
4853 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4854 CudaDeviceInput = &I;
4855 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4856 OpenMPDeviceInput = &I;
4858 llvm_unreachable(
"unexpectedly given multiple inputs");
4862 const llvm::Triple *AuxTriple =
4864 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4865 bool IsIAMCU = RawTriple.isOSIAMCU();
4870 if (IsCuda || IsHIP)
4871 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4875 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4880 CmdArgs.push_back(
"-cc1");
4883 CmdArgs.push_back(
"-triple");
4884 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4886 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4887 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4888 Args.ClaimAllArgs(options::OPT_MJ);
4889 }
else if (
const Arg *GenCDBFragment =
4890 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4891 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4892 TripleStr, Output, Input, Args);
4893 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4896 if (IsCuda || IsHIP) {
4899 std::string NormalizedTriple;
4917 assert(CTC &&
"Expected valid CUDA Toolchain.");
4919 CmdArgs.push_back(Args.MakeArgString(
4920 Twine(
"-target-sdk-version=") +
4928 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4931 CmdArgs.push_back(
"-aux-triple");
4932 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4937 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4938 CmdArgs.push_back(Args.MakeArgString(
4940 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4943 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4949 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
4952 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4953 CmdArgs.push_back(
"-fsycl-is-device");
4955 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4956 A->render(Args, CmdArgs);
4959 CmdArgs.push_back(
"-sycl-std=2020");
4963 if (IsOpenMPDevice) {
4965 std::string NormalizedTriple =
4969 CmdArgs.push_back(
"-aux-triple");
4970 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4973 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4974 Triple.getArch() == llvm::Triple::thumb)) {
4975 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4976 unsigned Version = 0;
4978 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
4979 if (Failure || Version < 7)
4980 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4990 if (Triple.isSPIR() || Triple.isSPIRV())
4991 CmdArgs.push_back(
"-Wspir-compat");
4994 RewriteKind rewriteKind = RK_None;
4996 bool UnifiedLTO =
false;
4998 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
4999 options::OPT_fno_unified_lto, Triple.isPS());
5001 CmdArgs.push_back(
"-funified-lto");
5011 if (!isa<AssembleJobAction>(JA)) {
5015 Args.ClaimAllArgs(options::OPT_mrelax_all);
5016 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5017 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5018 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5019 switch (
C.getDefaultToolChain().getArch()) {
5020 case llvm::Triple::arm:
5021 case llvm::Triple::armeb:
5022 case llvm::Triple::thumb:
5023 case llvm::Triple::thumbeb:
5024 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5030 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5031 Args.ClaimAllArgs(options::OPT_Xassembler);
5032 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5035 if (isa<AnalyzeJobAction>(JA)) {
5036 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5037 CmdArgs.push_back(
"-analyze");
5038 }
else if (isa<MigrateJobAction>(JA)) {
5039 CmdArgs.push_back(
"-migrate");
5040 }
else if (isa<PreprocessJobAction>(JA)) {
5041 if (Output.
getType() == types::TY_Dependencies)
5042 CmdArgs.push_back(
"-Eonly");
5044 CmdArgs.push_back(
"-E");
5045 if (Args.hasArg(options::OPT_rewrite_objc) &&
5046 !Args.hasArg(options::OPT_g_Group))
5047 CmdArgs.push_back(
"-P");
5048 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5049 CmdArgs.push_back(
"-fdirectives-only");
5051 }
else if (isa<AssembleJobAction>(JA)) {
5052 CmdArgs.push_back(
"-emit-obj");
5057 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5058 }
else if (isa<PrecompileJobAction>(JA)) {
5059 if (JA.
getType() == types::TY_Nothing)
5060 CmdArgs.push_back(
"-fsyntax-only");
5061 else if (JA.
getType() == types::TY_ModuleFile)
5062 CmdArgs.push_back(
"-emit-module-interface");
5063 else if (JA.
getType() == types::TY_HeaderUnit)
5064 CmdArgs.push_back(
"-emit-header-unit");
5066 CmdArgs.push_back(
"-emit-pch");
5067 }
else if (isa<VerifyPCHJobAction>(JA)) {
5068 CmdArgs.push_back(
"-verify-pch");
5069 }
else if (isa<ExtractAPIJobAction>(JA)) {
5070 assert(JA.
getType() == types::TY_API_INFO &&
5071 "Extract API actions must generate a API information.");
5072 CmdArgs.push_back(
"-extract-api");
5074 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5075 PrettySGFArg->render(Args, CmdArgs);
5077 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5079 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5080 ProductNameArg->render(Args, CmdArgs);
5081 if (Arg *ExtractAPIIgnoresFileArg =
5082 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5083 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5084 if (Arg *EmitExtensionSymbolGraphs =
5085 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5086 if (!SymbolGraphDirArg)
5087 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5089 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5091 if (SymbolGraphDirArg)
5092 SymbolGraphDirArg->render(Args, CmdArgs);
5094 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
5095 "Invalid action for clang tool.");
5096 if (JA.
getType() == types::TY_Nothing) {
5097 CmdArgs.push_back(
"-fsyntax-only");
5098 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5099 JA.
getType() == types::TY_LTO_IR) {
5100 CmdArgs.push_back(
"-emit-llvm");
5101 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5102 JA.
getType() == types::TY_LTO_BC) {
5104 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5105 Args.hasArg(options::OPT_emit_llvm)) {
5106 CmdArgs.push_back(
"-emit-llvm");
5108 CmdArgs.push_back(
"-emit-llvm-bc");
5110 }
else if (JA.
getType() == types::TY_IFS ||
5111 JA.
getType() == types::TY_IFS_CPP) {
5113 Args.hasArg(options::OPT_interface_stub_version_EQ)
5114 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5116 CmdArgs.push_back(
"-emit-interface-stubs");
5118 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5119 }
else if (JA.
getType() == types::TY_PP_Asm) {
5120 CmdArgs.push_back(
"-S");
5121 }
else if (JA.
getType() == types::TY_AST) {
5122 CmdArgs.push_back(
"-emit-pch");
5123 }
else if (JA.
getType() == types::TY_ModuleFile) {
5124 CmdArgs.push_back(
"-module-file-info");
5125 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5126 CmdArgs.push_back(
"-rewrite-objc");
5127 rewriteKind = RK_NonFragile;
5128 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5129 CmdArgs.push_back(
"-rewrite-objc");
5130 rewriteKind = RK_Fragile;
5132 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5139 if (JA.
getType() == types::TY_LLVM_BC)
5140 CmdArgs.push_back(
"-emit-llvm-uselists");
5144 !Args.hasFlag(options::OPT_offload_new_driver,
5145 options::OPT_no_offload_new_driver,
false) &&
5146 !Triple.isAMDGPU()) {
5147 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5148 << Args.getLastArg(options::OPT_foffload_lto,
5149 options::OPT_foffload_lto_EQ)
5151 << Triple.getTriple();
5152 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5154 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5155 << Args.getLastArg(options::OPT_foffload_lto,
5156 options::OPT_foffload_lto_EQ)
5161 CmdArgs.push_back(Args.MakeArgString(
5162 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5165 if (!RawTriple.isPS4() ||
5167 CmdArgs.push_back(
"-flto-unit");
5172 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5174 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5176 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5177 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5181 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5182 options::OPT_mno_regnames);
5184 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5185 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5187 if (Args.getLastArg(options::OPT_save_temps_EQ))
5188 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5190 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5191 options::OPT_fmemory_profile_EQ,
5192 options::OPT_fno_memory_profile);
5194 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5195 MemProfArg->render(Args, CmdArgs);
5197 if (
auto *MemProfUseArg =
5198 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5200 D.
Diag(diag::err_drv_argument_not_allowed_with)
5201 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5202 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5203 options::OPT_fprofile_generate_EQ))
5204 D.
Diag(diag::err_drv_argument_not_allowed_with)
5205 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5206 MemProfUseArg->render(Args, CmdArgs);
5211 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5212 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
5214 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5216 CmdArgs.push_back(
"-disable-llvm-passes");
5223 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5224 options::OPT_mkernel,
5225 options::OPT_fapple_kext,
5226 options::OPT_ffunction_sections,
5227 options::OPT_fno_function_sections,
5228 options::OPT_fdata_sections,
5229 options::OPT_fno_data_sections,
5230 options::OPT_fbasic_block_sections_EQ,
5231 options::OPT_funique_internal_linkage_names,
5232 options::OPT_fno_unique_internal_linkage_names,
5233 options::OPT_funique_section_names,
5234 options::OPT_fno_unique_section_names,
5235 options::OPT_funique_basic_block_section_names,
5236 options::OPT_fno_unique_basic_block_section_names,
5237 options::OPT_mrestrict_it,
5238 options::OPT_mno_restrict_it,
5239 options::OPT_mstackrealign,
5240 options::OPT_mno_stackrealign,
5241 options::OPT_mstack_alignment,
5242 options::OPT_mcmodel_EQ,
5243 options::OPT_mlong_calls,
5244 options::OPT_mno_long_calls,
5245 options::OPT_ggnu_pubnames,
5246 options::OPT_gdwarf_aranges,
5247 options::OPT_fdebug_types_section,
5248 options::OPT_fno_debug_types_section,
5249 options::OPT_fdwarf_directory_asm,
5250 options::OPT_fno_dwarf_directory_asm,
5251 options::OPT_mrelax_all,
5252 options::OPT_mno_relax_all,
5253 options::OPT_ftrap_function_EQ,
5254 options::OPT_ffixed_r9,
5255 options::OPT_mfix_cortex_a53_835769,
5256 options::OPT_mno_fix_cortex_a53_835769,
5257 options::OPT_ffixed_x18,
5258 options::OPT_mglobal_merge,
5259 options::OPT_mno_global_merge,
5260 options::OPT_mred_zone,
5261 options::OPT_mno_red_zone,
5262 options::OPT_Wa_COMMA,
5263 options::OPT_Xassembler,
5266 for (
const auto &A : Args)
5267 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5268 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5271 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5272 options::OPT_fno_optimize_sibling_calls);
5280 case llvm::Triple::arm:
5281 case llvm::Triple::armeb:
5282 case llvm::Triple::thumbeb:
5283 RenderARMABI(D, Triple, Args, CmdArgs);
5285 case llvm::Triple::aarch64:
5286 case llvm::Triple::aarch64_32:
5287 case llvm::Triple::aarch64_be:
5288 RenderAArch64ABI(Triple, Args, CmdArgs);
5293 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5294 if (A->getOption().matches(options::OPT_O4)) {
5295 CmdArgs.push_back(
"-O3");
5296 D.
Diag(diag::warn_O4_is_O3);
5298 A->render(Args, CmdArgs);
5303 if (Output.
getType() == types::TY_Dependencies) {
5306 CmdArgs.push_back(
"-o");
5309 assert(Output.
isNothing() &&
"Input output.");
5312 for (
const auto &II : Inputs) {
5314 if (II.isFilename())
5315 CmdArgs.push_back(II.getFilename());
5317 II.getInputArg().renderAsInput(Args, CmdArgs);
5320 C.addCommand(std::make_unique<Command>(
5326 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5327 CmdArgs.push_back(
"-fembed-bitcode=marker");
5332 if (!
C.isForDiagnostics())
5333 CmdArgs.push_back(
"-disable-free");
5334 CmdArgs.push_back(
"-clear-ast-before-backend");
5337 const bool IsAssertBuild =
false;
5339 const bool IsAssertBuild =
true;
5343 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5344 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5345 CmdArgs.push_back(
"-disable-llvm-verifier");
5349 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5350 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5351 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5353 return types::isLLVMIR(II.getType());
5355 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5357 CmdArgs.push_back(
"-discard-value-names");
5362 CmdArgs.push_back(
"-main-file-name");
5367 if (Args.hasArg(options::OPT_static))
5368 CmdArgs.push_back(
"-static-define");
5370 if (Args.hasArg(options::OPT_municode))
5371 CmdArgs.push_back(
"-DUNICODE");
5373 if (isa<AnalyzeJobAction>(JA))
5376 if (isa<AnalyzeJobAction>(JA) ||
5377 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5378 CmdArgs.push_back(
"-setup-static-analyzer");
5383 bool FoundAnalyzerConfig =
false;
5384 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5385 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5386 FoundAnalyzerConfig =
true;
5389 if (!FoundAnalyzerConfig)
5390 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5391 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5392 FoundAnalyzerConfig =
true;
5395 if (FoundAnalyzerConfig)
5396 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5401 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5402 if (FunctionAlignment) {
5403 CmdArgs.push_back(
"-function-alignment");
5404 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5409 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5411 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5413 << A->getAsString(Args) << A->getValue();
5415 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5416 << A->getAsString(Args) << A->getValue();
5419 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5420 Twine(std::min(
Value, 65536u))));
5423 if (Triple.isOSzOS()) {
5432 auto findMacroDefinition = [&](
const std::string &Macro) {
5433 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5434 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5435 return M == Macro || M.find(Macro +
'=') != std::string::npos;
5440 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5441 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5443 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5444 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5447 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5448 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5452 llvm::Reloc::Model RelocationModel;
5455 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5456 Arg *LastPICDataRelArg =
5457 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5458 options::OPT_mpic_data_is_text_relative);
5459 bool NoPICDataIsTextRelative =
false;
5460 if (LastPICDataRelArg) {
5461 if (LastPICDataRelArg->getOption().matches(
5462 options::OPT_mno_pic_data_is_text_relative)) {
5463 NoPICDataIsTextRelative =
true;
5465 D.
Diag(diag::err_drv_argument_only_allowed_with)
5466 <<
"-mno-pic-data-is-text-relative"
5469 if (!Triple.isSystemZ())
5470 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5471 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5472 :
"-mpic-data-is-text-relative")
5476 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5477 RelocationModel == llvm::Reloc::ROPI_RWPI;
5478 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5479 RelocationModel == llvm::Reloc::ROPI_RWPI;
5481 if (Args.hasArg(options::OPT_mcmse) &&
5482 !Args.hasArg(options::OPT_fallow_unsupported)) {
5484 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5486 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5490 !Args.hasArg(options::OPT_fallow_unsupported))
5491 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5495 CmdArgs.push_back(
"-mrelocation-model");
5496 CmdArgs.push_back(RMName);
5499 CmdArgs.push_back(
"-pic-level");
5500 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5502 CmdArgs.push_back(
"-pic-is-pie");
5503 if (NoPICDataIsTextRelative)
5504 CmdArgs.push_back(
"-mcmodel=medium");
5507 if (RelocationModel == llvm::Reloc::ROPI ||
5508 RelocationModel == llvm::Reloc::ROPI_RWPI)
5509 CmdArgs.push_back(
"-fropi");
5510 if (RelocationModel == llvm::Reloc::RWPI ||
5511 RelocationModel == llvm::Reloc::ROPI_RWPI)
5512 CmdArgs.push_back(
"-frwpi");
5514 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5515 CmdArgs.push_back(
"-meabi");
5516 CmdArgs.push_back(A->getValue());
5530 if (Triple.isOSBinFormatELF()) {
5531 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5532 options::OPT_fno_semantic_interposition);
5533 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5535 bool SupportsLocalAlias =
5536 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5538 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5539 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5540 A->render(Args, CmdArgs);
5541 else if (!SupportsLocalAlias)
5542 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5548 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5550 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5551 << A->getValue() << A->getAsString(Args);
5552 Model = A->getValue();
5555 if (Model !=
"posix") {
5556 CmdArgs.push_back(
"-mthread-model");
5557 CmdArgs.push_back(Args.MakeArgString(Model));
5561 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5562 StringRef Name = A->getValue();
5563 if (Name ==
"SVML") {
5564 if (Triple.getArch() != llvm::Triple::x86 &&
5565 Triple.getArch() != llvm::Triple::x86_64)
5566 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5567 << Name << Triple.getArchName();
5568 }
else if (Name ==
"LIBMVEC-X86") {
5569 if (Triple.getArch() != llvm::Triple::x86 &&
5570 Triple.getArch() != llvm::Triple::x86_64)
5571 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5572 << Name << Triple.getArchName();
5573 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5574 if (Triple.getArch() != llvm::Triple::aarch64 &&
5575 Triple.getArch() != llvm::Triple::aarch64_be)
5576 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5577 << Name << Triple.getArchName();
5579 A->render(Args, CmdArgs);
5582 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5583 options::OPT_fno_merge_all_constants,
false))
5584 CmdArgs.push_back(
"-fmerge-all-constants");
5586 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5587 options::OPT_fno_delete_null_pointer_checks);
5591 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5592 if (!Triple.isOSAIX() || Triple.isPPC32())
5593 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5594 << A->getSpelling() << RawTriple.str();
5595 CmdArgs.push_back(
"-mabi=quadword-atomics");
5598 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5601 if (Triple.isOSAIX())
5602 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5603 << A->getSpelling() << RawTriple.str();
5606 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5607 StringRef
V = A->getValue(), V1 =
V;
5609 if (V1.consumeInteger(10, Size) || !V1.empty())
5610 D.
Diag(diag::err_drv_invalid_argument_to_option)
5611 <<
V << A->getOption().getName();
5613 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5616 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5617 options::OPT_fno_jump_tables);
5618 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5619 options::OPT_fno_profile_sample_accurate);
5620 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5621 options::OPT_fno_preserve_as_comments);
5623 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5624 CmdArgs.push_back(
"-mregparm");
5625 CmdArgs.push_back(A->getValue());
5628 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5629 options::OPT_msvr4_struct_return)) {
5631 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5632 << A->getSpelling() << RawTriple.str();
5633 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5634 CmdArgs.push_back(
"-maix-struct-return");
5636 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5637 CmdArgs.push_back(
"-msvr4-struct-return");
5641 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5642 options::OPT_freg_struct_return)) {
5643 if (TC.
getArch() != llvm::Triple::x86) {
5644 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5645 << A->getSpelling() << RawTriple.str();
5646 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5647 CmdArgs.push_back(
"-fpcc-struct-return");
5649 assert(A->getOption().matches(options::OPT_freg_struct_return));
5650 CmdArgs.push_back(
"-freg-struct-return");
5654 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5655 if (Triple.getArch() == llvm::Triple::m68k)
5656 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5658 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5661 if (Args.hasArg(options::OPT_fenable_matrix)) {
5663 CmdArgs.push_back(
"-fenable-matrix");
5664 CmdArgs.push_back(
"-mllvm");
5665 CmdArgs.push_back(
"-enable-matrix");
5670 const char *FPKeepKindStr =
nullptr;
5671 switch (FPKeepKind) {
5673 FPKeepKindStr =
"-mframe-pointer=none";
5676 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5679 FPKeepKindStr =
"-mframe-pointer=all";
5682 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5683 CmdArgs.push_back(FPKeepKindStr);
5685 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5686 options::OPT_fno_zero_initialized_in_bss);
5691 OptSpecifier StrictAliasingAliasOption =
5692 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5695 bool TBAAOnByDefault = !D.
IsCLMode();
5696 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5697 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5698 CmdArgs.push_back(
"-relaxed-aliasing");
5699 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5700 options::OPT_fno_struct_path_tbaa,
true))
5701 CmdArgs.push_back(
"-no-struct-path-tbaa");
5702 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5703 options::OPT_fno_strict_enums);
5704 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5705 options::OPT_fno_strict_return);
5706 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5707 options::OPT_fno_allow_editor_placeholders);
5708 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5709 options::OPT_fno_strict_vtable_pointers);
5710 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5711 options::OPT_fno_force_emit_vtables);
5712 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5713 options::OPT_fno_optimize_sibling_calls);
5714 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5715 options::OPT_fno_escaping_block_tail_calls);
5717 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5718 options::OPT_fno_fine_grained_bitfield_accesses);
5720 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5721 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5723 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5724 options::OPT_fno_experimental_omit_vtable_rtti);
5727 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5728 options::OPT_fno_split_stack);
5731 if (Args.hasFlag(options::OPT_fprotect_parens,
5732 options::OPT_fno_protect_parens,
false))
5733 CmdArgs.push_back(
"-fprotect-parens");
5737 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5738 const llvm::Triple::ArchType Arch = TC.
getArch();
5739 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5740 StringRef
V = A->getValue();
5742 CmdArgs.push_back(
"-fextend-arguments=64");
5744 D.
Diag(diag::err_drv_invalid_argument_to_option)
5745 << A->getValue() << A->getOption().getName();
5747 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5748 << A->getOption().getName() << TripleStr;
5751 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5752 if (TC.
getArch() == llvm::Triple::avr)
5753 A->render(Args, CmdArgs);
5755 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5756 << A->getAsString(Args) << TripleStr;
5759 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5761 A->render(Args, CmdArgs);
5763 (A->getOption().getID() != options::OPT_mlong_double_80))
5764 A->render(Args, CmdArgs);
5766 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5767 << A->getAsString(Args) << TripleStr;
5773 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5774 IsIntegratedAssemblerDefault))
5775 CmdArgs.push_back(
"-fno-verbose-asm");
5779 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5780 StringRef
V = A->getValue();
5783 A->render(Args, CmdArgs);
5784 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5785 (
V.empty() || (
V.consume_front(
".") &&
5786 !
V.consumeInteger(10, Num) &&
V.empty())))
5787 A->render(Args, CmdArgs);
5789 D.
Diag(diag::err_drv_invalid_argument_to_option)
5790 << A->getValue() << A->getOption().getName();
5796 CmdArgs.push_back(
"-no-integrated-as");
5798 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5799 CmdArgs.push_back(
"-mdebug-pass");
5800 CmdArgs.push_back(
"Structure");
5802 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5803 CmdArgs.push_back(
"-mdebug-pass");
5804 CmdArgs.push_back(
"Arguments");
5810 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5811 CmdArgs.push_back(
"-mconstructor-aliases");
5815 if (KernelOrKext && RawTriple.isOSDarwin())
5816 CmdArgs.push_back(
"-fforbid-guard-variables");
5818 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5819 Triple.isWindowsGNUEnvironment())) {
5820 CmdArgs.push_back(
"-mms-bitfields");
5823 if (Triple.isWindowsGNUEnvironment()) {
5824 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5825 options::OPT_fno_auto_import);
5828 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5830 CmdArgs.push_back(
"-fms-volatile");
5835 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5836 options::OPT_fno_direct_access_external_data)) {
5837 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5839 A->render(Args, CmdArgs);
5840 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
5843 CmdArgs.push_back(
"-fno-direct-access-external-data");
5846 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5847 CmdArgs.push_back(
"-fno-plt");
5854 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5857 CmdArgs.push_back(
"-ffreestanding");
5859 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5866 bool IsAsyncUnwindTablesDefault =
5868 bool IsSyncUnwindTablesDefault =
5871 bool AsyncUnwindTables = Args.hasFlag(
5872 options::OPT_fasynchronous_unwind_tables,
5873 options::OPT_fno_asynchronous_unwind_tables,
5874 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5877 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5878 IsSyncUnwindTablesDefault && !Freestanding);
5879 if (AsyncUnwindTables)
5880 CmdArgs.push_back(
"-funwind-tables=2");
5881 else if (UnwindTables)
5882 CmdArgs.push_back(
"-funwind-tables=1");
5886 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5887 (IsCudaDevice || IsHIPDevice)) {
5888 const ArgList &HostArgs =
5890 std::string HostCPU =
5892 if (!HostCPU.empty()) {
5893 CmdArgs.push_back(
"-aux-target-cpu");
5894 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5902 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5903 StringRef CM = A->getValue();
5905 if (Triple.isOSAIX() && CM ==
"medium")
5907 if (Triple.isAArch64(64)) {
5908 Ok = CM ==
"tiny" || CM ==
"small" || CM ==
"large";
5909 if (CM ==
"large" && !Triple.isOSBinFormatMachO() &&
5910 RelocationModel != llvm::Reloc::Static)
5911 D.
Diag(diag::err_drv_argument_only_allowed_with)
5912 << A->getAsString(Args) <<
"-fno-pic";
5913 }
else if (Triple.isLoongArch()) {
5914 if (CM ==
"extreme" &&
5915 Args.hasFlagNoClaim(options::OPT_fplt, options::OPT_fno_plt,
false))
5916 D.
Diag(diag::err_drv_argument_not_allowed_with)
5917 << A->getAsString(Args) <<
"-fplt";
5918 Ok = CM ==
"normal" || CM ==
"medium" || CM ==
"extreme";
5921 CM = llvm::StringSwitch<StringRef>(CM)
5922 .Case(
"normal",
"small")
5923 .Case(
"extreme",
"large")
5925 }
else if (Triple.isPPC64() || Triple.isOSAIX()) {
5926 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
5927 }
else if (Triple.isRISCV()) {
5930 else if (CM ==
"medany")
5932 Ok = CM ==
"small" || CM ==
"medium";
5933 }
else if (Triple.getArch() == llvm::Triple::x86_64) {
5934 Ok = llvm::is_contained({
"small",
"kernel",
"medium",
"large",
"tiny"},
5936 }
else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {
5940 }
else if (Triple.isSPARC64()) {
5943 else if (CM ==
"medmid")
5945 else if (CM ==
"medany")
5947 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
5950 CmdArgs.push_back(Args.MakeArgString(
"-mcmodel=" + CM));
5952 D.
Diag(diag::err_drv_unsupported_option_argument_for_target)
5953 << A->getSpelling() << CM << TripleStr;
5957 if (Triple.getArch() == llvm::Triple::x86_64) {
5958 bool IsMediumCM =
false;
5959 bool IsLargeCM =
false;
5960 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5961 IsMediumCM = StringRef(A->getValue()) ==
"medium";
5962 IsLargeCM = StringRef(A->getValue()) ==
"large";
5964 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {
5965 if (!IsMediumCM && !IsLargeCM) {
5966 D.
Diag(diag::warn_drv_large_data_threshold_invalid_code_model)
5967 << A->getOption().getRenderName();
5969 A->render(Args, CmdArgs);
5971 }
else if (IsMediumCM) {
5972 CmdArgs.push_back(
"-mlarge-data-threshold=65536");
5973 }
else if (IsLargeCM) {
5974 CmdArgs.push_back(
"-mlarge-data-threshold=0");
5978 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5979 StringRef
Value = A->getValue();
5980 unsigned TLSSize = 0;
5981 Value.getAsInteger(10, TLSSize);
5982 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5983 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5984 << A->getOption().getName() << TripleStr;
5985 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5986 D.
Diag(diag::err_drv_invalid_int_value)
5987 << A->getOption().getName() <<
Value;
5988 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5992 CmdArgs.push_back(
"-enable-tlsdesc");
5995 std::string CPU =
getCPUName(D, Args, Triple,
false);
5997 CmdArgs.push_back(
"-target-cpu");
5998 CmdArgs.push_back(Args.MakeArgString(CPU));
6001 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6006 AddClangCLArgs(Args, InputType, CmdArgs);
6008 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6009 llvm::codegenoptions::NoDebugInfo;
6012 CmdArgs, Output, DebugInfoKind, DwarfFission);
6020 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
6021 isa<BackendJobAction>(JA));
6023 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6024 CmdArgs.push_back(
"-split-dwarf-file");
6025 CmdArgs.push_back(SplitDWARFOut);
6027 CmdArgs.push_back(
"-split-dwarf-output");
6028 CmdArgs.push_back(SplitDWARFOut);
6033 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6034 CmdArgs.push_back(
"-target-linker-version");
6035 CmdArgs.push_back(A->getValue());
6040 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6042 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6043 TC.
getArch() == llvm::Triple::x86) {
6044 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6045 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6046 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6047 << Unsupported->getOption().getName();
6050 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6051 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6052 << Unsupported->getOption().getName()
6053 <<
"please use -maltivec and include altivec.h explicitly";
6054 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6055 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6056 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6059 Args.AddAllArgs(CmdArgs, options::OPT_v);
6061 if (Args.getLastArg(options::OPT_H)) {
6062 CmdArgs.push_back(
"-H");
6063 CmdArgs.push_back(
"-sys-header-deps");
6065 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6068 CmdArgs.push_back(
"-header-include-file");
6072 CmdArgs.push_back(
"-sys-header-deps");
6073 CmdArgs.push_back(Args.MakeArgString(
6074 "-header-include-format=" +
6077 Args.MakeArgString(
"-header-include-filtering=" +
6081 Args.AddLastArg(CmdArgs, options::OPT_P);
6082 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6085 CmdArgs.push_back(
"-diagnostic-log-file");
6094 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6098 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6099 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6100 CmdArgs.push_back(
"-mllvm");
6101 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6106 if (Args.hasFlag(options::OPT_ffunction_sections,
6107 options::OPT_fno_function_sections, UseSeparateSections)) {
6108 CmdArgs.push_back(
"-ffunction-sections");
6111 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6112 options::OPT_fno_basic_block_address_map)) {
6113 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6114 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6115 A->render(Args, CmdArgs);
6117 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6118 << A->getAsString(Args) << TripleStr;
6122 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6123 StringRef Val = A->getValue();
6124 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6125 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
6126 !Val.starts_with(
"list="))
6127 D.
Diag(diag::err_drv_invalid_value)
6128 << A->getAsString(Args) << A->getValue();
6130 A->render(Args, CmdArgs);
6131 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6134 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6135 D.
Diag(diag::err_drv_invalid_value)
6136 << A->getAsString(Args) << A->getValue();
6138 A->render(Args, CmdArgs);
6139 }
else if (Triple.isNVPTX()) {
6142 }
else if (Val !=
"none") {
6145 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6146 << A->getAsString(Args) << TripleStr;
6150 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6151 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6152 UseSeparateSections || HasDefaultDataSections)) {
6153 CmdArgs.push_back(
"-fdata-sections");
6156 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6157 options::OPT_fno_unique_section_names);
6158 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6159 options::OPT_fno_unique_internal_linkage_names);
6160 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6161 options::OPT_fno_unique_basic_block_section_names);
6162 Args.addOptInFlag(CmdArgs, options::OPT_fconvergent_functions,
6163 options::OPT_fno_convergent_functions);
6165 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6166 options::OPT_fno_split_machine_functions)) {
6167 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6169 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6170 A->render(Args, CmdArgs);
6172 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6173 << A->getAsString(Args) << TripleStr;
6177 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6178 options::OPT_finstrument_functions_after_inlining,
6179 options::OPT_finstrument_function_entry_bare);
6184 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
6187 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6190 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
6191 CmdArgs.push_back(
"-mllvm");
6192 CmdArgs.push_back(
"-sample-profile-use-profi");
6196 if (RawTriple.isPS() &&
6197 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6203 if (Args.hasArg(options::OPT_nostdinc)) {
6204 CmdArgs.push_back(
"-nostdsysteminc");
6205 CmdArgs.push_back(
"-nobuiltininc");
6207 if (Args.hasArg(options::OPT_nostdlibinc))
6208 CmdArgs.push_back(
"-nostdsysteminc");
6209 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6210 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6214 CmdArgs.push_back(
"-resource-dir");
6217 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6226 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6232 Args.ClaimAllArgs(options::OPT_D);
6235 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
6236 if (A->getOption().matches(options::OPT_O4)) {
6237 CmdArgs.push_back(
"-O3");
6238 D.
Diag(diag::warn_O4_is_O3);
6240 A->render(Args, CmdArgs);
6246 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6247 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6252 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6253 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6259 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6262 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6264 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6265 unsigned WarningNumber;
6266 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6267 D.
Diag(diag::err_drv_invalid_int_value)
6268 << A->getAsString(Args) << A->getValue();
6273 CmdArgs.push_back(Args.MakeArgString(
6278 A->render(Args, CmdArgs);
6281 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6283 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6284 CmdArgs.push_back(
"-pedantic");
6285 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6286 Args.AddLastArg(CmdArgs, options::OPT_w);
6288 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6289 options::OPT_fno_fixed_point);
6291 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6292 A->render(Args, CmdArgs);
6294 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6295 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6297 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6298 options::OPT_fno_experimental_omit_vtable_rtti);
6300 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6301 A->render(Args, CmdArgs);
6308 bool ImplyVCPPCVer =
false;
6309 bool ImplyVCPPCXXVer =
false;
6310 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6312 if (
Std->getOption().matches(options::OPT_ansi))
6314 CmdArgs.push_back(
"-std=c++98");
6316 CmdArgs.push_back(
"-std=c89");
6318 Std->render(Args, CmdArgs);
6321 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6322 options::OPT_ftrigraphs,
6323 options::OPT_fno_trigraphs))
6325 A->render(Args, CmdArgs);
6334 if (!Args.hasArg(options::OPT__SLASH_std)) {
6335 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6338 ImplyVCPPCVer =
true;
6340 else if (IsWindowsMSVC)
6341 ImplyVCPPCXXVer =
true;
6343 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6344 options::OPT_fno_trigraphs);
6360 Args.getLastArg(options::OPT_Wwrite_strings,
6361 options::OPT_Wno_write_strings, options::OPT_w);
6363 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6364 CmdArgs.push_back(
"-fconst-strings");
6371 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6373 CmdArgs.push_back(
"-fdeprecated-macro");
6377 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6378 if (
Asm->getOption().matches(options::OPT_fasm))
6379 CmdArgs.push_back(
"-fgnu-keywords");
6381 CmdArgs.push_back(
"-fno-gnu-keywords");
6385 CmdArgs.push_back(
"-fno-autolink");
6387 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6388 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6389 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6390 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6392 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6394 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6395 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6397 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6398 CmdArgs.push_back(
"-fbracket-depth");
6399 CmdArgs.push_back(A->getValue());
6402 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6403 options::OPT_Wlarge_by_value_copy_def)) {
6404 if (A->getNumValues()) {
6405 StringRef
bytes = A->getValue();
6406 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6408 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6411 if (Args.hasArg(options::OPT_relocatable_pch))
6412 CmdArgs.push_back(
"-relocatable-pch");
6414 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6415 static const char *kCFABIs[] = {
6416 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6419 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6420 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6422 A->render(Args, CmdArgs);
6425 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6426 CmdArgs.push_back(
"-fconstant-string-class");
6427 CmdArgs.push_back(A->getValue());
6430 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6431 CmdArgs.push_back(
"-ftabstop");
6432 CmdArgs.push_back(A->getValue());
6435 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6436 options::OPT_fno_stack_size_section);
6438 if (Args.hasArg(options::OPT_fstack_usage)) {
6439 CmdArgs.push_back(
"-stack-usage-file");
6441 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6443 llvm::sys::path::replace_extension(OutputFilename,
"su");
6444 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6450 CmdArgs.push_back(
"-ferror-limit");
6451 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6452 CmdArgs.push_back(A->getValue());
6454 CmdArgs.push_back(
"19");
6456 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6457 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6458 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6459 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6460 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6463 unsigned MessageLength = 0;
6464 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6465 StringRef
V(A->getValue());
6466 if (
V.getAsInteger(0, MessageLength))
6467 D.
Diag(diag::err_drv_invalid_argument_to_option)
6468 <<
V << A->getOption().getName();
6472 MessageLength = llvm::sys::Process::StandardErrColumns();
6474 if (MessageLength != 0)
6476 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6478 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6480 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6482 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6483 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6484 Twine(A->getValue(0))));
6487 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6488 options::OPT_fvisibility_ms_compat)) {
6489 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6490 A->render(Args, CmdArgs);
6492 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6493 CmdArgs.push_back(
"-fvisibility=hidden");
6494 CmdArgs.push_back(
"-ftype-visibility=default");
6496 }
else if (IsOpenMPDevice) {
6500 CmdArgs.push_back(
"-fvisibility=protected");
6504 if (!RawTriple.isPS()) {
6506 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6507 options::OPT_fno_visibility_from_dllstorageclass)) {
6508 if (A->getOption().matches(
6509 options::OPT_fvisibility_from_dllstorageclass)) {
6510 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6511 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6512 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6513 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6514 Args.AddLastArg(CmdArgs,
6515 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6520 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6521 options::OPT_fno_visibility_inlines_hidden,
false))
6522 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6524 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6525 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6530 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6531 D.
Diag(diag::warn_drv_deprecated_arg)
6532 << A->getAsString(Args)
6533 <<
"-fvisibility-global-new-delete=force-hidden";
6537 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6538 options::OPT_fvisibility_global_new_delete_hidden)) {
6539 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6540 A->render(Args, CmdArgs);
6542 assert(A->getOption().matches(
6543 options::OPT_fvisibility_global_new_delete_hidden));
6544 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6548 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6550 if (Args.hasFlag(options::OPT_fnew_infallible,
6551 options::OPT_fno_new_infallible,
false))
6552 CmdArgs.push_back(
"-fnew-infallible");
6554 if (Args.hasFlag(options::OPT_fno_operator_names,
6555 options::OPT_foperator_names,
false))
6556 CmdArgs.push_back(
"-fno-operator-names");
6559 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6560 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6561 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6562 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6564 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6565 Triple.hasDefaultEmulatedTLS()))
6566 CmdArgs.push_back(
"-femulated-tls");
6568 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6569 options::OPT_fno_check_new);
6571 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6575 if (!Triple.isX86() && !Triple.isAArch64())
6576 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6577 << A->getAsString(Args) << TripleStr;
6581 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
6582 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6584 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6585 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6589 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6590 options::OPT_fno_openmp,
false) &&
6597 CmdArgs.push_back(
"-fopenmp");
6602 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6603 options::OPT_fnoopenmp_use_tls,
true))
6604 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6605 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6606 options::OPT_fno_openmp_simd);
6607 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6608 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6609 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6610 options::OPT_fno_openmp_extensions,
true))
6611 CmdArgs.push_back(
"-fno-openmp-extensions");
6612 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6613 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6614 Args.AddAllArgs(CmdArgs,
6615 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6616 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6617 options::OPT_fno_openmp_optimistic_collapse,
6619 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6623 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6624 options::OPT_fno_openmp_cuda_mode,
false))
6625 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6628 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6629 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6630 options::OPT_fno_openmp_target_debug,
false))
6631 CmdArgs.push_back(
"-fopenmp-target-debug");
6635 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6636 options::OPT_fno_openmp_assume_teams_oversubscription,
6638 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6639 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6640 options::OPT_fno_openmp_assume_threads_oversubscription,
6642 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6643 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6644 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6645 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6646 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6647 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6648 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6649 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6650 CmdArgs.push_back(
"-fopenmp-force-usm");
6662 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6663 options::OPT_fno_openmp_simd);
6664 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6665 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6666 options::OPT_fno_openmp_extensions);
6670 if (Args.hasFlag(options::OPT_offload_new_driver,
6671 options::OPT_no_offload_new_driver,
false))
6672 CmdArgs.push_back(
"--offload-new-driver");
6674 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
6677 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6680 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6682 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" +
Filename));
6687 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6688 StringRef S0 = A->getValue(), S = S0;
6689 unsigned Size, Offset = 0;
6690 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6692 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6693 << A->getAsString(Args) << TripleStr;
6694 else if (S.consumeInteger(10, Size) ||
6695 (!S.empty() && (!S.consume_front(
",") ||
6696 S.consumeInteger(10, Offset) || !S.empty())))
6697 D.
Diag(diag::err_drv_invalid_argument_to_option)
6698 << S0 << A->getOption().getName();
6699 else if (Size < Offset)
6700 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6702 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6703 CmdArgs.push_back(Args.MakeArgString(
6704 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6708 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6711 Args.AddLastArg(CmdArgs, options::OPT_pg);
6713 llvm::Triple::ArchType Arch = TC.
getArch();
6714 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6715 if (Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6716 A->render(Args, CmdArgs);
6718 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6719 << A->getAsString(Args) << TripleStr;
6721 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6722 if (Arch == llvm::Triple::systemz)
6723 A->render(Args, CmdArgs);
6725 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6726 << A->getAsString(Args) << TripleStr;
6728 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6729 if (Arch == llvm::Triple::systemz)
6730 A->render(Args, CmdArgs);
6732 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6733 << A->getAsString(Args) << TripleStr;
6737 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6739 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6740 << A->getAsString(Args) << TripleStr;
6743 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6745 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6746 << A->getAsString(Args) << TripleStr;
6749 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6750 if (A->getOption().matches(options::OPT_p)) {
6752 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6753 CmdArgs.push_back(
"-pg");
6759 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6760 options::OPT_mxcoff_build_id_EQ)) {
6761 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6762 << A->getSpelling() << TripleStr;
6766 if (Args.getLastArg(options::OPT_fapple_kext) ||
6767 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6768 CmdArgs.push_back(
"-fapple-kext");
6770 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6771 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6772 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6773 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6774 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6775 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6776 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6777 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6778 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6779 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6781 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
6782 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
6783 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6786 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6787 CmdArgs.push_back(
"-ftrapv-handler");
6788 CmdArgs.push_back(A->getValue());
6791 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6795 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
6796 if (A->getOption().matches(options::OPT_fwrapv))
6797 CmdArgs.push_back(
"-fwrapv");
6798 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
6799 options::OPT_fno_strict_overflow)) {
6800 if (A->getOption().matches(options::OPT_fno_strict_overflow))
6801 CmdArgs.push_back(
"-fwrapv");
6804 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6805 options::OPT_fno_finite_loops);
6807 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6808 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6809 options::OPT_fno_unroll_loops);
6811 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6813 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6815 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6816 options::OPT_mno_speculative_load_hardening);
6822 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6824 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6825 options::OPT_mno_stackrealign);
6827 if (Args.hasArg(options::OPT_mstack_alignment)) {
6828 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
6829 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
6832 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6833 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6836 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6838 CmdArgs.push_back(
"-mstack-probe-size=0");
6841 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6842 options::OPT_mno_stack_arg_probe);
6844 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6845 options::OPT_mno_restrict_it)) {
6846 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6847 CmdArgs.push_back(
"-mllvm");
6848 CmdArgs.push_back(
"-arm-restrict-it");
6850 CmdArgs.push_back(
"-mllvm");
6851 CmdArgs.push_back(
"-arm-default-it");
6865 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6866 options::OPT_fno_hip_new_launch_api,
true))
6867 CmdArgs.push_back(
"-fhip-new-launch-api");
6868 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6869 options::OPT_fno_gpu_allow_device_init);
6870 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6871 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6872 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6873 options::OPT_fno_hip_kernel_arg_name);
6876 if (IsCuda || IsHIP) {
6878 CmdArgs.push_back(
"-fgpu-rdc");
6879 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6880 options::OPT_fno_gpu_defer_diag);
6881 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6882 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6884 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6885 CmdArgs.push_back(
"-fgpu-defer-diag");
6890 if (Args.hasArg(options::OPT_nogpulib))
6891 CmdArgs.push_back(
"-nogpulib");
6893 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6895 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
6898 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6900 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
6902 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6907 if (!(IsCudaDevice || IsHIPDevice)) {
6909 auto *PGOArg = Args.getLastArg(
6910 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
6911 options::OPT_fcs_profile_generate,
6912 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
6913 options::OPT_fprofile_use_EQ);
6915 D.
Diag(diag::err_drv_argument_not_allowed_with)
6916 <<
"SampleUse with PGO options";
6918 StringRef fname = A->getValue();
6919 if (!llvm::sys::fs::exists(fname))
6920 D.
Diag(diag::err_drv_no_such_file) << fname;
6922 A->render(Args, CmdArgs);
6924 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6926 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6927 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
6928 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
6931 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6932 options::OPT_fno_unique_internal_linkage_names,
true))
6933 CmdArgs.push_back(
"-funique-internal-linkage-names");
6938 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6939 options::OPT_fno_assume_sane_operator_new);
6941 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
6942 CmdArgs.push_back(
"-fapinotes");
6943 if (Args.hasFlag(options::OPT_fapinotes_modules,
6944 options::OPT_fno_apinotes_modules,
false))
6945 CmdArgs.push_back(
"-fapinotes-modules");
6946 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
6949 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
6951 (Args.hasArg(options::OPT_fgnu_runtime) &&
6952 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
6953 !Args.hasArg(options::OPT_fno_blocks))) {
6954 CmdArgs.push_back(
"-fblocks");
6957 CmdArgs.push_back(
"-fblocks-runtime-optional");
6962 CmdArgs.push_back(
"-fencode-extended-block-signature");
6964 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
6965 options::OPT_fno_coro_aligned_allocation,
false) &&
6967 CmdArgs.push_back(
"-fcoro-aligned-allocation");
6969 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
6970 options::OPT_fno_double_square_bracket_attributes);
6972 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
6973 options::OPT_fno_access_control);
6974 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
6975 options::OPT_fno_elide_constructors);
6981 CmdArgs.push_back(
"-fno-rtti");
6984 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
6985 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
6986 CmdArgs.push_back(
"-fshort-enums");
6992 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
6993 !RawTriple.isOSAIX() && !RawTriple.isOSWindows() &&
6994 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
6995 RawTriple.hasEnvironment())) ||
6997 CmdArgs.push_back(
"-fno-use-cxa-atexit");
6999 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7000 options::OPT_fno_register_global_dtors_with_atexit,
7001 RawTriple.isOSDarwin() && !KernelOrKext))
7002 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7004 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7005 options::OPT_fno_use_line_directives);
7008 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7009 options::OPT_fno_minimize_whitespace,
false)) {
7010 types::ID InputType = Inputs[0].getType();
7011 if (!isDerivedFromC(InputType))
7012 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7014 CmdArgs.push_back(
"-fminimize-whitespace");
7018 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7019 options::OPT_fno_keep_system_includes,
false)) {
7020 types::ID InputType = Inputs[0].getType();
7021 if (!isDerivedFromC(InputType))
7022 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7024 CmdArgs.push_back(
"-fkeep-system-includes");
7028 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7030 CmdArgs.push_back(
"-fms-extensions");
7033 bool IsMSVCCompat = Args.hasFlag(
7034 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7035 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7036 options::OPT_fno_ms_extensions,
true)));
7038 CmdArgs.push_back(
"-fms-compatibility");
7040 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7041 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7045 VersionTuple GNUCVer;
7046 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7049 StringRef Val = A->getValue();
7050 Val = Val.empty() ?
"0" : Val;
7051 bool Invalid = GNUCVer.tryParse(Val);
7052 unsigned Minor = GNUCVer.getMinor().value_or(0);
7053 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7054 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7055 D.
Diag(diag::err_drv_invalid_value)
7056 << A->getAsString(Args) << A->getValue();
7058 }
else if (!IsMSVCCompat) {
7060 GNUCVer = VersionTuple(4, 2, 1);
7062 if (!GNUCVer.empty()) {
7064 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7070 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7072 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7073 if (ImplyVCPPCVer) {
7074 StringRef LanguageStandard;
7075 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7077 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7078 .Case(
"c11",
"-std=c11")
7079 .Case(
"c17",
"-std=c17")
7081 if (LanguageStandard.empty())
7082 D.
Diag(clang::diag::warn_drv_unused_argument)
7083 << StdArg->getAsString(Args);
7085 CmdArgs.push_back(LanguageStandard.data());
7087 if (ImplyVCPPCXXVer) {
7088 StringRef LanguageStandard;
7089 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7091 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7092 .Case(
"c++14",
"-std=c++14")
7093 .Case(
"c++17",
"-std=c++17")
7094 .Case(
"c++20",
"-std=c++20")
7096 .Case(
"c++latest",
"-std=c++26")
7098 if (LanguageStandard.empty())
7099 D.
Diag(clang::diag::warn_drv_unused_argument)
7100 << StdArg->getAsString(Args);
7103 if (LanguageStandard.empty()) {
7104 if (IsMSVC2015Compatible)
7105 LanguageStandard =
"-std=c++14";
7107 LanguageStandard =
"-std=c++11";
7110 CmdArgs.push_back(LanguageStandard.data());
7113 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7114 options::OPT_fno_borland_extensions);
7117 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7119 CmdArgs.push_back(
"-fdeclspec");
7120 else if (Args.hasArg(options::OPT_fno_declspec))
7121 CmdArgs.push_back(
"-fno-declspec");
7125 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7126 options::OPT_fno_threadsafe_statics,
7128 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7129 CmdArgs.push_back(
"-fno-threadsafe-statics");
7132 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7134 CmdArgs.push_back(
"-fno-assumptions");
7138 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7139 options::OPT_fno_gnu_keywords);
7141 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7142 options::OPT_fno_gnu89_inline);
7144 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7145 options::OPT_finline_hint_functions,
7146 options::OPT_fno_inline_functions);
7147 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7148 if (A->getOption().matches(options::OPT_fno_inline))
7149 A->render(Args, CmdArgs);
7150 }
else if (InlineArg) {
7151 InlineArg->render(Args, CmdArgs);
7154 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7159 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"gnu++2a") ||
7160 Std->containsValue(
"c++20") ||
Std->containsValue(
"gnu++20") ||
7161 Std->containsValue(
"c++2b") ||
Std->containsValue(
"gnu++2b") ||
7162 Std->containsValue(
"c++23") ||
Std->containsValue(
"gnu++23") ||
7163 Std->containsValue(
"c++2c") ||
Std->containsValue(
"gnu++2c") ||
7164 Std->containsValue(
"c++26") ||
Std->containsValue(
"gnu++26") ||
7165 Std->containsValue(
"c++latest") ||
Std->containsValue(
"gnu++latest"));
7180 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7181 options::OPT_fno_delayed_template_parsing,
7182 IsWindowsMSVC && !HaveCxx20)) {
7184 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7186 CmdArgs.push_back(
"-fdelayed-template-parsing");
7189 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7190 options::OPT_fno_pch_validate_input_files_content,
false))
7191 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7192 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7193 options::OPT_fno_pch_instantiate_templates,
false))
7194 CmdArgs.push_back(
"-fpch-instantiate-templates");
7195 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7197 CmdArgs.push_back(
"-fmodules-codegen");
7198 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7200 CmdArgs.push_back(
"-fmodules-debuginfo");
7202 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7207 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7208 options::OPT_fno_objc_encode_cxx_class_template_spec,
7210 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7212 if (Args.hasFlag(options::OPT_fapplication_extension,
7213 options::OPT_fno_application_extension,
false))
7214 CmdArgs.push_back(
"-fapplication-extension");
7218 if (!
C.getDriver().IsCLMode())
7219 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7222 Arg *A = Args.getLastArg(
7223 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7224 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7226 const Option &Opt = A->getOption();
7227 if (Opt.matches(options::OPT_fsjlj_exceptions))
7228 CmdArgs.push_back(
"-exception-model=sjlj");
7229 if (Opt.matches(options::OPT_fseh_exceptions))
7230 CmdArgs.push_back(
"-exception-model=seh");
7231 if (Opt.matches(options::OPT_fdwarf_exceptions))
7232 CmdArgs.push_back(
"-exception-model=dwarf");
7233 if (Opt.matches(options::OPT_fwasm_exceptions))
7234 CmdArgs.push_back(
"-exception-model=wasm");
7239 case llvm::ExceptionHandling::DwarfCFI:
7240 CmdArgs.push_back(
"-exception-model=dwarf");
7242 case llvm::ExceptionHandling::SjLj:
7243 CmdArgs.push_back(
"-exception-model=sjlj");
7245 case llvm::ExceptionHandling::WinEH:
7246 CmdArgs.push_back(
"-exception-model=seh");
7252 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7253 options::OPT_fno_assume_sane_operator_new);
7256 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7257 options::OPT_fno_assume_unique_vtables);
7262 Args.addOptInFlag(CmdArgs, options::OPT_frelaxed_template_template_args,
7263 options::OPT_fno_relaxed_template_template_args);
7267 Args.addOptInFlag(CmdArgs, options::OPT_fsized_deallocation,
7268 options::OPT_fno_sized_deallocation);
7272 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7273 options::OPT_fno_aligned_allocation,
7274 options::OPT_faligned_new_EQ)) {
7275 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7276 CmdArgs.push_back(
"-fno-aligned-allocation");
7278 CmdArgs.push_back(
"-faligned-allocation");
7283 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7284 options::OPT_faligned_new_EQ))
7286 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7290 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7291 options::OPT_fno_constant_cfstrings,
true) ||
7292 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7293 options::OPT_mno_constant_cfstrings,
true))
7294 CmdArgs.push_back(
"-fno-constant-cfstrings");
7296 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7297 options::OPT_fno_pascal_strings);
7301 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7302 std::string PackStructStr =
"-fpack-struct=";
7303 PackStructStr += A->getValue();
7304 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7305 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7306 options::OPT_fno_pack_struct,
false)) {
7307 CmdArgs.push_back(
"-fpack-struct=1");
7311 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7312 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7313 if (!SkipMaxTypeAlign) {
7314 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7315 MaxTypeAlignStr += A->getValue();
7316 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7318 }
else if (RawTriple.isOSDarwin()) {
7319 if (!SkipMaxTypeAlign) {
7320 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7321 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7325 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7326 CmdArgs.push_back(
"-Qn");
7329 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7333 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7334 options::OPT_funsigned_bitfields,
true))
7335 D.
Diag(diag::warn_drv_clang_unsupported)
7336 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7339 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7340 D.
Diag(diag::err_drv_clang_unsupported)
7341 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7344 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7345 StringRef value = inputCharset->getValue();
7346 if (!value.equals_insensitive(
"utf-8"))
7347 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7352 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7353 StringRef value = execCharset->getValue();
7354 if (!value.equals_insensitive(
"utf-8"))
7355 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7361 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7362 options::OPT_fno_asm_blocks);
7364 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7365 options::OPT_fno_gnu_inline_asm);
7371 OptSpecifier VectorizeAliasOption =
7372 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
7373 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
7374 options::OPT_fno_vectorize, EnableVec))
7375 CmdArgs.push_back(
"-vectorize-loops");
7379 OptSpecifier SLPVectAliasOption =
7380 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
7381 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
7382 options::OPT_fno_slp_vectorize, EnableSLPVec))
7383 CmdArgs.push_back(
"-vectorize-slp");
7387 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7388 Args.AddLastArg(CmdArgs,
7389 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7393 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7394 options::OPT_fno_dollars_in_identifiers)) {
7395 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7396 CmdArgs.push_back(
"-fdollars-in-identifiers");
7398 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7401 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7402 options::OPT_fno_apple_pragma_pack);
7408 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7409 options::OPT_fno_rewrite_imports,
false);
7411 CmdArgs.push_back(
"-frewrite-imports");
7413 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7414 options::OPT_fno_directives_only);
7420 if (Args.hasFlag(options::OPT_frewrite_includes,
7421 options::OPT_fno_rewrite_includes,
false) ||
7422 (
C.isForDiagnostics() && !HaveModules))
7423 CmdArgs.push_back(
"-frewrite-includes");
7426 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7427 options::OPT_traditional_cpp)) {
7428 if (isa<PreprocessJobAction>(JA))
7429 CmdArgs.push_back(
"-traditional-cpp");
7431 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7434 Args.AddLastArg(CmdArgs, options::OPT_dM);
7435 Args.AddLastArg(CmdArgs, options::OPT_dD);
7436 Args.AddLastArg(CmdArgs, options::OPT_dI);
7438 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7441 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7442 CmdArgs.push_back(
"-serialize-diagnostic-file");
7443 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7446 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7447 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7450 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7452 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7455 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7456 CmdArgs.push_back(
"-load");
7457 CmdArgs.push_back(A->getValue());
7469 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7470 auto ArgValue = StringRef(A->getValue());
7471 auto FirstDashIndex = ArgValue.find(
'-');
7472 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7473 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7476 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7477 if (PluginName.empty()) {
7478 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7480 D.
Diag(diag::warn_drv_missing_plugin_arg)
7481 << PluginName << A->getAsString(Args);
7486 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7487 CmdArgs.push_back(Args.MakeArgString(Arg));
7491 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7493 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7498 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7499 CmdArgs.push_back(
"--vfsoverlay");
7500 CmdArgs.push_back(A->getValue());
7504 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7505 options::OPT_fno_safe_buffer_usage_suggestions);
7509 if (!StatsFile.empty()) {
7510 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7512 CmdArgs.push_back(
"-stats-file-append");
7517 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7521 if (
C.getDriver().isSaveTempsEnabled() &&
7522 !isa<PreprocessJobAction>(JA)) {
7523 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7526 CmdArgs.push_back(Arg->getValue());
7528 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7534 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7535 CmdArgs.push_back(
"-disable-llvm-optzns");
7537 A->render(Args, CmdArgs);
7549 if ((
C.getDriver().isSaveTempsEnabled() ||
7551 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7552 isa<CompileJobAction>(JA))
7553 CmdArgs.push_back(
"-disable-llvm-passes");
7555 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7564 auto GRecordSwitches =
7565 Args.hasFlag(options::OPT_grecord_command_line,
7566 options::OPT_gno_record_command_line,
false);
7567 auto FRecordSwitches =
7568 Args.hasFlag(options::OPT_frecord_command_line,
7569 options::OPT_fno_record_command_line,
false);
7570 if (FRecordSwitches && !Triple.isOSBinFormatELF() &&
7571 !Triple.isOSBinFormatXCOFF() && !Triple.isOSBinFormatMachO())
7572 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7573 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
7576 ArgStringList OriginalArgs;
7577 for (
const auto &Arg : Args)
7578 Arg->render(Args, OriginalArgs);
7582 for (
const char *OriginalArg : OriginalArgs) {
7586 Flags += EscapedArg;
7588 auto FlagsArgString = Args.MakeArgString(Flags);
7590 CmdArgs.push_back(
"-dwarf-debug-flags");
7591 CmdArgs.push_back(FlagsArgString);
7593 if (FRecordSwitches) {
7594 CmdArgs.push_back(
"-record-command-line");
7595 CmdArgs.push_back(FlagsArgString);
7602 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7603 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7604 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7605 }
else if (!HostOffloadingInputs.empty()) {
7606 if ((IsCuda || IsHIP) && !IsRDCMode) {
7607 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7608 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7609 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7611 for (
const InputInfo Input : HostOffloadingInputs)
7612 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7618 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7619 options::OPT_fno_cuda_short_ptr,
false))
7620 CmdArgs.push_back(
"-fcuda-short-ptr");
7623 if (IsCuda || IsHIP) {
7625 const Action *SourceAction = &JA;
7627 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7628 SourceAction = SourceAction->
getInputs()[0];
7630 auto CUID = cast<InputAction>(SourceAction)->getId();
7632 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7636 bool UseApproxTranscendentals = Args.hasFlag(
7637 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7638 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7639 options::OPT_fno_gpu_approx_transcendentals,
7640 UseApproxTranscendentals))
7641 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7643 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7644 options::OPT_fno_gpu_approx_transcendentals);
7648 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7649 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7652 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7653 options::OPT_fno_offload_uniform_block);
7655 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7656 options::OPT_fno_offload_implicit_host_device_templates);
7658 if (IsCudaDevice || IsHIPDevice) {
7659 StringRef InlineThresh =
7660 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7661 if (!InlineThresh.empty()) {
7662 std::string ArgStr =
7663 std::string(
"-inline-threshold=") + InlineThresh.str();
7664 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7669 Args.addOptOutFlag(CmdArgs,
7670 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7671 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7678 if (IsOpenMPDevice) {
7679 CmdArgs.push_back(
"-fopenmp-is-target-device");
7680 if (OpenMPDeviceInput) {
7681 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7682 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7686 if (Triple.isAMDGPU()) {
7689 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7690 options::OPT_mno_unsafe_fp_atomics);
7691 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7692 options::OPT_mno_amdgpu_ieee);
7702 std::transform(TCRange.first, TCRange.second, std::back_inserter(Triples),
7703 [](
auto TC) { return TC.second->getTripleString(); });
7704 CmdArgs.push_back(Args.MakeArgString(Targets + llvm::join(Triples,
",")));
7707 bool VirtualFunctionElimination =
7708 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7709 options::OPT_fno_virtual_function_elimination,
false);
7710 if (VirtualFunctionElimination) {
7714 D.
Diag(diag::err_drv_argument_only_allowed_with)
7715 <<
"-fvirtual-function-elimination"
7718 CmdArgs.push_back(
"-fvirtual-function-elimination");
7722 bool WholeProgramVTables = Args.hasFlag(
7723 options::OPT_fwhole_program_vtables,
7724 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7725 if (VirtualFunctionElimination && !WholeProgramVTables) {
7726 D.
Diag(diag::err_drv_argument_not_allowed_with)
7727 <<
"-fno-whole-program-vtables"
7728 <<
"-fvirtual-function-elimination";
7731 if (WholeProgramVTables) {
7741 if ((!IsUsingLTO && !D.
isUsingLTO(!IsDeviceOffloadAction)) ||
7743 D.
Diag(diag::err_drv_argument_only_allowed_with)
7744 <<
"-fwhole-program-vtables"
7745 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7749 CmdArgs.push_back(
"-fwhole-program-vtables");
7752 bool DefaultsSplitLTOUnit =
7753 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7755 (!Triple.isPS4() && UnifiedLTO);
7757 Args.hasFlag(options::OPT_fsplit_lto_unit,
7758 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
7759 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
7760 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
7761 <<
"-fsanitize=cfi";
7763 CmdArgs.push_back(
"-fsplit-lto-unit");
7765 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7766 options::OPT_fno_fat_lto_objects)) {
7767 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
7769 if (!Triple.isOSBinFormatELF()) {
7770 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7773 CmdArgs.push_back(Args.MakeArgString(
7774 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
7775 CmdArgs.push_back(
"-flto-unit");
7776 CmdArgs.push_back(
"-ffat-lto-objects");
7777 A->render(Args, CmdArgs);
7781 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7782 options::OPT_fno_global_isel)) {
7783 CmdArgs.push_back(
"-mllvm");
7784 if (A->getOption().matches(options::OPT_fglobal_isel)) {
7785 CmdArgs.push_back(
"-global-isel=1");
7790 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
7791 bool IsOptLevelSupported =
false;
7793 Arg *A = Args.getLastArg(options::OPT_O_Group);
7794 if (Triple.getArch() == llvm::Triple::aarch64) {
7795 if (!A || A->getOption().matches(options::OPT_O0))
7796 IsOptLevelSupported =
true;
7798 if (!IsArchSupported || !IsOptLevelSupported) {
7799 CmdArgs.push_back(
"-mllvm");
7800 CmdArgs.push_back(
"-global-isel-abort=2");
7802 if (!IsArchSupported)
7803 D.
Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
7805 D.
Diag(diag::warn_drv_global_isel_incomplete_opt);
7808 CmdArgs.push_back(
"-global-isel=0");
7812 if (Args.hasArg(options::OPT_forder_file_instrumentation)) {
7813 CmdArgs.push_back(
"-forder-file-instrumentation");
7818 CmdArgs.push_back(
"-mllvm");
7819 CmdArgs.push_back(
"-enable-order-file-instrumentation");
7823 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7824 options::OPT_fno_force_enable_int128)) {
7825 if (A->getOption().matches(options::OPT_fforce_enable_int128))
7826 CmdArgs.push_back(
"-fforce-enable-int128");
7829 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7830 options::OPT_fno_keep_static_consts);
7831 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7832 options::OPT_fno_keep_persistent_storage_variables);
7833 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7834 options::OPT_fno_complete_member_pointers);
7835 Args.addOptOutFlag(CmdArgs, options::OPT_fcxx_static_destructors,
7836 options::OPT_fno_cxx_static_destructors);
7842 if (Triple.isAArch64() &&
7843 (Args.hasArg(options::OPT_mno_fmv) ||
7844 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
7847 CmdArgs.push_back(
"-target-feature");
7848 CmdArgs.push_back(
"-fmv");
7851 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7858 CmdArgs.push_back(
"-faddrsig");
7860 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
7861 (EH || UnwindTables || AsyncUnwindTables ||
7862 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
7863 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
7865 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7866 std::string Str = A->getAsString(Args);
7868 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7870 CmdArgs.push_back(Args.MakeArgString(Str));
7875 if (Output.
getType() == types::TY_Dependencies) {
7878 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
7879 Output.
getType() == clang::driver::types::TY_IFS) {
7881 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
7882 CmdArgs.push_back(
"-o");
7883 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7885 CmdArgs.push_back(
"-o");
7889 assert(Output.
isNothing() &&
"Invalid output.");
7896 FrontendInputs = ExtractAPIInputs;
7898 FrontendInputs = {};
7900 for (
const InputInfo &Input : FrontendInputs) {
7909 C.addCommand(std::make_unique<CC1Command>(
7913 C.addCommand(std::make_unique<Command>(
7919 if (Output.
getType() == types::TY_Object &&
7920 Args.hasFlag(options::OPT__SLASH_showFilenames,
7921 options::OPT__SLASH_showFilenames_,
false)) {
7922 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
7925 if (Arg *A = Args.getLastArg(options::OPT_pg))
7927 !Args.hasArg(options::OPT_mfentry))
7928 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
7929 << A->getAsString(Args);
7935 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
7939 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
7940 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
7943 Args.ClaimAllArgs(options::OPT_emit_llvm);
7950 :
Tool(
"clang",
"clang frontend", TC), HasBackend(HasIntegratedBackend) {}
7957ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
7959 ArgStringList &cmdArgs,
7960 RewriteKind rewriteKind)
const {
7963 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
7964 options::OPT_fobjc_runtime_EQ);
7969 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
7971 StringRef value = runtimeArg->getValue();
7977 (runtime.
getVersion() >= VersionTuple(2, 0)))
7981 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
7985 runtimeArg->render(args, cmdArgs);
7994 unsigned objcABIVersion = 1;
7996 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
7997 StringRef value = abiArg->getValue();
8000 else if (value ==
"2")
8002 else if (value ==
"3")
8008 bool nonFragileABIIsDefault =
8009 (rewriteKind == RK_NonFragile ||
8010 (rewriteKind == RK_None &&
8012 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
8013 options::OPT_fno_objc_nonfragile_abi,
8014 nonFragileABIIsDefault)) {
8016#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
8017 unsigned nonFragileABIVersion = 1;
8019 unsigned nonFragileABIVersion = 2;
8023 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
8024 StringRef value = abiArg->getValue();
8026 nonFragileABIVersion = 1;
8027 else if (value ==
"2")
8028 nonFragileABIVersion = 2;
8034 objcABIVersion = 1 + nonFragileABIVersion;
8042 bool isNonFragile = objcABIVersion != 1;
8048 switch (rewriteKind) {
8061 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
8073 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
8082 if (llvm::any_of(inputs, [](
const InputInfo &input) {
8086 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
8091 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
8099 bool Asynch =
false;
8100 bool NoUnwindC =
false;
8112 bool isWindowsMSVC) {
8115 std::vector<std::string> EHArgs =
8116 Args.getAllArgValues(options::OPT__SLASH_EH);
8117 for (
auto EHVal : EHArgs) {
8118 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
8124 if (!isWindowsMSVC) {
8126 D.
Diag(clang::diag::warn_drv_unused_argument) <<
"/EHa" << EHVal;
8143 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
8149 if (EHArgs.empty() &&
8150 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
8153 EH.NoUnwindC =
true;
8156 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8158 EH.NoUnwindC =
false;
8165void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
8166 ArgStringList &CmdArgs)
const {
8171 if (Arg *ShowIncludes =
8172 Args.getLastArg(options::OPT__SLASH_showIncludes,
8173 options::OPT__SLASH_showIncludes_user)) {
8174 CmdArgs.push_back(
"--show-includes");
8175 if (ShowIncludes->getOption().matches(options::OPT__SLASH_showIncludes))
8176 CmdArgs.push_back(
"-sys-header-deps");
8180 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8182 CmdArgs.push_back(
"-fno-rtti-data");
8186 if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
8188 CmdArgs.push_back(
"-stack-protector");
8196 if (!isNVPTX && (EH.Synch || EH.Asynch)) {
8198 CmdArgs.push_back(
"-fcxx-exceptions");
8199 CmdArgs.push_back(
"-fexceptions");
8201 CmdArgs.push_back(
"-fasync-exceptions");
8203 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
8204 CmdArgs.push_back(
"-fexternc-nounwind");
8207 if (Args.hasArg(options::OPT__SLASH_EP)) {
8208 CmdArgs.push_back(
"-E");
8209 CmdArgs.push_back(
"-P");
8212 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
8213 options::OPT__SLASH_Zc_dllexportInlines,
8215 CmdArgs.push_back(
"-fno-dllexport-inlines");
8218 if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
8219 options::OPT__SLASH_Zc_wchar_t,
false)) {
8220 CmdArgs.push_back(
"-fno-wchar");
8223 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8225 std::vector<std::string> Values =
8226 Args.getAllArgValues(options::OPT__SLASH_arch);
8227 if (!Values.empty()) {
8228 llvm::SmallSet<std::string, 4> SupportedArches;
8229 if (Arch == llvm::Triple::x86)
8230 SupportedArches.insert(
"IA32");
8232 for (
auto &
V : Values)
8233 if (!SupportedArches.contains(
V))
8234 D.
Diag(diag::err_drv_argument_not_allowed_with)
8235 << std::string(
"/arch:").append(
V) <<
"/kernel";
8238 CmdArgs.push_back(
"-fno-rtti");
8239 if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_,
false))
8240 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"/GR"
8244 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
8245 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
8246 if (MostGeneralArg && BestCaseArg)
8247 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
8248 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
8250 if (MostGeneralArg) {
8251 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
8252 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
8253 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
8255 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
8256 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
8257 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
8258 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
8259 << FirstConflict->getAsString(Args)
8260 << SecondConflict->getAsString(Args);
8263 CmdArgs.push_back(
"-fms-memptr-rep=single");
8264 else if (MultipleArg)
8265 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
8267 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
8270 if (Args.hasArg(options::OPT_regcall4))
8271 CmdArgs.push_back(
"-regcall4");
8275 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
8276 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
8277 options::OPT__SLASH_Gregcall)) {
8278 unsigned DCCOptId = CCArg->getOption().getID();
8279 const char *DCCFlag =
nullptr;
8280 bool ArchSupported = !isNVPTX;
8283 case options::OPT__SLASH_Gd:
8284 DCCFlag =
"-fdefault-calling-conv=cdecl";
8286 case options::OPT__SLASH_Gr:
8287 ArchSupported = Arch == llvm::Triple::x86;
8288 DCCFlag =
"-fdefault-calling-conv=fastcall";
8290 case options::OPT__SLASH_Gz:
8291 ArchSupported = Arch == llvm::Triple::x86;
8292 DCCFlag =
"-fdefault-calling-conv=stdcall";
8294 case options::OPT__SLASH_Gv:
8295 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8296 DCCFlag =
"-fdefault-calling-conv=vectorcall";
8298 case options::OPT__SLASH_Gregcall:
8299 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8300 DCCFlag =
"-fdefault-calling-conv=regcall";
8305 if (ArchSupported && DCCFlag)
8306 CmdArgs.push_back(DCCFlag);
8309 if (Args.hasArg(options::OPT__SLASH_Gregcall4))
8310 CmdArgs.push_back(
"-regcall4");
8312 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
8314 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
8315 CmdArgs.push_back(
"-fdiagnostics-format");
8316 CmdArgs.push_back(
"msvc");
8319 if (Args.hasArg(options::OPT__SLASH_kernel))
8320 CmdArgs.push_back(
"-fms-kernel");
8322 for (
const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
8323 StringRef GuardArgs = A->getValue();
8326 if (GuardArgs.equals_insensitive(
"cf")) {
8328 CmdArgs.push_back(
"-cfguard");
8329 }
else if (GuardArgs.equals_insensitive(
"cf,nochecks")) {
8331 CmdArgs.push_back(
"-cfguard-no-checks");
8332 }
else if (GuardArgs.equals_insensitive(
"ehcont")) {
8334 CmdArgs.push_back(
"-ehcontguard");
8335 }
else if (GuardArgs.equals_insensitive(
"cf-") ||
8336 GuardArgs.equals_insensitive(
"ehcont-")) {
8339 D.
Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
8347 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
8354 if (
const char *End = strrchr(Str,
'.'))
8355 return Args.MakeArgString(std::string(Str, End));
8364 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
8366 llvm::sys::path::replace_extension(OutputFilename, llvm::Twine(
'd'));
8367 return Args.MakeArgString(OutputFilename);
8376 ArgStringList &CmdArgs)
const {
8382 CmdArgs.push_back(
"-target-abi");
8383 CmdArgs.push_back(ABIName.data());
8387 ArgStringList &CmdArgs)
const {
8391 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
8392 StringRef
Value = A->getValue();
8394 CmdArgs.push_back(
"-mllvm");
8395 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
8398 << A->getSpelling() <<
Value;
8404 ArgStringList &CmdArgs)
const {
8405 CmdArgs.push_back(
"-target-abi");
8412 ArgStringList &CmdArgs)
const {
8416 CmdArgs.push_back(
"-target-abi");
8417 CmdArgs.push_back(ABIName.data());
8419 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8420 options::OPT_mno_default_build_attributes,
true)) {
8421 CmdArgs.push_back(
"-mllvm");
8422 CmdArgs.push_back(
"-riscv-add-build-attributes");
8428 const ArgList &Args,
8429 const char *LinkingOutput)
const {
8430 ArgStringList CmdArgs;
8432 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
8436 const std::string &TripleStr = Triple.getTriple();
8440 Args.ClaimAllArgs(options::OPT_w);
8442 Args.ClaimAllArgs(options::OPT_emit_llvm);
8449 CmdArgs.push_back(
"-cc1as");
8452 CmdArgs.push_back(
"-triple");
8453 CmdArgs.push_back(Args.MakeArgString(TripleStr));
8459 CmdArgs.push_back(
"-filetype");
8460 CmdArgs.push_back(
"obj");
8464 CmdArgs.push_back(
"-main-file-name");
8468 std::string CPU =
getCPUName(D, Args, Triple,
true);
8470 CmdArgs.push_back(
"-target-cpu");
8471 CmdArgs.push_back(Args.MakeArgString(CPU));
8478 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
8481 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
8484 auto FindSource = [](
const Action *S) ->
const Action * {
8486 assert(!S->getInputs().empty() &&
"unexpected root action!");
8487 S = S->getInputs()[0];
8491 const Action *SourceAction = FindSource(&JA);
8495 bool WantDebug =
false;
8496 Args.ClaimAllArgs(options::OPT_g_Group);
8497 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8498 WantDebug = !A->getOption().matches(options::OPT_g0) &&
8499 !A->getOption().matches(options::OPT_ggdb0);
8501 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
8502 llvm::codegenoptions::NoDebugInfo;
8505 const char *DebugCompilationDir =
8508 if (SourceAction->
getType() == types::TY_Asm ||
8509 SourceAction->
getType() == types::TY_PP_Asm) {
8514 DebugInfoKind = (WantDebug ? llvm::codegenoptions::DebugInfoConstructor
8515 : llvm::codegenoptions::NoDebugInfo);
8522 CmdArgs.push_back(
"-dwarf-debug-producer");
8526 Args.AddAllArgs(CmdArgs, options::OPT_I);
8530 llvm::DebuggerKind::Default);
8536 llvm::Reloc::Model RelocationModel;
8539 std::tie(RelocationModel, PICLevel, IsPIE) =
8544 CmdArgs.push_back(
"-mrelocation-model");
8545 CmdArgs.push_back(RMName);
8551 ArgStringList OriginalArgs;
8552 for (
const auto &Arg : Args)
8553 Arg->render(Args, OriginalArgs);
8558 for (
const char *OriginalArg : OriginalArgs) {
8562 Flags += EscapedArg;
8564 CmdArgs.push_back(
"-dwarf-debug-flags");
8565 CmdArgs.push_back(Args.MakeArgString(Flags));
8575 case llvm::Triple::mips:
8576 case llvm::Triple::mipsel:
8577 case llvm::Triple::mips64:
8578 case llvm::Triple::mips64el:
8582 case llvm::Triple::x86:
8583 case llvm::Triple::x86_64:
8587 case llvm::Triple::arm:
8588 case llvm::Triple::armeb:
8589 case llvm::Triple::thumb:
8590 case llvm::Triple::thumbeb:
8593 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8594 options::OPT_mno_default_build_attributes,
true)) {
8595 CmdArgs.push_back(
"-mllvm");
8596 CmdArgs.push_back(
"-arm-add-build-attributes");
8600 case llvm::Triple::aarch64:
8601 case llvm::Triple::aarch64_32:
8602 case llvm::Triple::aarch64_be:
8603 if (Args.hasArg(options::OPT_mmark_bti_property)) {
8604 CmdArgs.push_back(
"-mllvm");
8605 CmdArgs.push_back(
"-aarch64-mark-bti-property");
8609 case llvm::Triple::loongarch32:
8610 case llvm::Triple::loongarch64:
8614 case llvm::Triple::riscv32:
8615 case llvm::Triple::riscv64:
8619 case llvm::Triple::hexagon:
8620 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8621 options::OPT_mno_default_build_attributes,
true)) {
8622 CmdArgs.push_back(
"-mllvm");
8623 CmdArgs.push_back(
"-hexagon-add-build-attributes");
8633 Args.ClaimAllArgs(options::OPT_W_Group);
8638 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
8640 if (DebugInfoKind > llvm::codegenoptions::NoDebugInfo && Output.
isFilename())
8647 if (SourceAction != FindSource(&J.getSource()))
8649 auto &JArgs = J.getArguments();
8650 for (
unsigned I = 0; I < JArgs.size(); ++I) {
8651 if (StringRef(JArgs[I]).starts_with(
"-object-file-name=") &&
8653 ArgStringList NewArgs(JArgs.begin(), JArgs.begin() + I);
8656 NewArgs.append(JArgs.begin() + I + 1, JArgs.end());
8657 J.replaceArguments(NewArgs);
8663 assert(Output.
isFilename() &&
"Unexpected lipo output.");
8664 CmdArgs.push_back(
"-o");
8670 T.isOSBinFormatELF()) {
8671 CmdArgs.push_back(
"-split-dwarf-output");
8675 if (Triple.isAMDGPU())
8678 assert(Input.
isFilename() &&
"Invalid input.");
8684 C.addCommand(std::make_unique<CC1Command>(
8688 C.addCommand(std::make_unique<Command>(
8698 const llvm::opt::ArgList &TCArgs,
8699 const char *LinkingOutput)
const {
8701 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
8711 ArgStringList CmdArgs;
8714 CmdArgs.push_back(TCArgs.MakeArgString(
8717 assert(JA.
getInputs().size() == Inputs.size() &&
8718 "Not have inputs for all dependence actions??");
8722 Triples +=
"-targets=";
8723 for (
unsigned I = 0; I < Inputs.size(); ++I) {
8732 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
8734 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
8735 assert(CurTC ==
nullptr &&
"Expected one dependence!");
8742 Triples += CurTC->
getTriple().normalize();
8751 StringRef GPUArchName;
8754 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
8755 auto ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
8756 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
8758 GPUArchName = ArchStr.substr(7);
8763 Triples += GPUArchName.str();
8766 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
8770 TCArgs.MakeArgString(Twine(
"-output=") + Output.
getFilename()));
8773 for (
unsigned I = 0; I < Inputs.size(); ++I) {
8779 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
8781 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
8782 assert(CurTC ==
nullptr &&
"Expected one dependence!");
8785 UB +=
C.addTempFile(
8790 CmdArgs.push_back(TCArgs.MakeArgString(UB));
8794 C.addCommand(std::make_unique<Command>(
8797 CmdArgs, std::nullopt, Output));
8802 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
8803 const char *LinkingOutput)
const {
8805 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
8816 ArgStringList CmdArgs;
8818 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
8822 CmdArgs.push_back(TCArgs.MakeArgString(
8827 Triples +=
"-targets=";
8828 auto DepInfo = UA.getDependentActionsInfo();
8829 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
8833 auto &Dep = DepInfo[I];
8836 Triples += Dep.DependentToolChain->getTriple().normalize();
8839 !Dep.DependentBoundArch.empty()) {
8841 Triples += Dep.DependentBoundArch;
8845 StringRef GPUArchName;
8848 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
8849 StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
8850 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
8852 GPUArchName = ArchStr.substr(7);
8857 Triples += GPUArchName.str();
8861 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
8865 TCArgs.MakeArgString(Twine(
"-input=") + Input.
getFilename()));
8868 for (
unsigned I = 0; I < Outputs.size(); ++I) {
8871 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
8872 CmdArgs.push_back(TCArgs.MakeArgString(UB));
8874 CmdArgs.push_back(
"-unbundle");
8875 CmdArgs.push_back(
"-allow-missing-bundles");
8876 if (TCArgs.hasArg(options::OPT_v))
8877 CmdArgs.push_back(
"-verbose");
8880 C.addCommand(std::make_unique<Command>(
8883 CmdArgs, std::nullopt, Outputs));
8889 const llvm::opt::ArgList &Args,
8890 const char *LinkingOutput)
const {
8891 ArgStringList CmdArgs;
8894 assert(Output.
isFilename() &&
"Invalid output.");
8895 CmdArgs.push_back(
"-o");
8902 const ArgList &TCArgs =
8908 : TCArgs.getLastArgValue(options::OPT_march_EQ);
8912 ArgStringList Features;
8916 llvm::copy_if(Features, std::back_inserter(FeatureArgs),
8917 [](StringRef Arg) {
return !Arg.starts_with(
"-target"); });
8920 for (StringRef Feature : llvm::split(Arch.split(
':').second,
':')) {
8921 FeatureArgs.emplace_back(
8922 Args.MakeArgString(Feature.take_back() + Feature.drop_back()));
8929 "file=" +
File.str(),
8931 "arch=" + Arch.str(),
8932 "kind=" + Kind.str(),
8937 for (StringRef Feature : FeatureArgs)
8938 Parts.emplace_back(
"feature=" + Feature.str());
8940 CmdArgs.push_back(Args.MakeArgString(
"--image=" + llvm::join(Parts,
",")));
8943 C.addCommand(std::make_unique<Command>(
8946 CmdArgs, Inputs, Output));
8952 const ArgList &Args,
8953 const char *LinkingOutput)
const {
8956 ArgStringList CmdArgs;
8960 auto TCRange =
C.getOffloadToolChains(Kind);
8961 for (
auto &I : llvm::make_range(TCRange.first, TCRange.second)) {
8965 if (CudaInstallation.
isValid())
8966 CmdArgs.push_back(Args.MakeArgString(
8974 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
8976 if (A->getOption().matches(options::OPT_O4) ||
8977 A->getOption().matches(options::OPT_Ofast))
8979 else if (A->getOption().matches(options::OPT_O)) {
8980 OOpt = A->getValue();
8983 else if (OOpt ==
"s" || OOpt ==
"z")
8985 }
else if (A->getOption().matches(options::OPT_O0))
8988 CmdArgs.push_back(Args.MakeArgString(Twine(
"--opt-level=O") + OOpt));
8992 Args.MakeArgString(
"--host-triple=" + TheTriple.getTriple()));
8993 if (Args.hasArg(options::OPT_v))
8994 CmdArgs.push_back(
"--wrapper-verbose");
8996 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
8997 if (!A->getOption().matches(options::OPT_g0))
8998 CmdArgs.push_back(
"--device-debug");
9003 if (
const Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
9004 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
9005 CmdArgs.push_back(Args.MakeArgString(
9006 Twine(
"--amdhsa-code-object-version=") + A->getValue()));
9009 for (
const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
9010 CmdArgs.push_back(Args.MakeArgString(
"--ptxas-arg=" + A));
9013 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
9014 CmdArgs.push_back(Args.MakeArgString(Twine(
"--offload-opt=-pass-remarks=") +
9016 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
9017 CmdArgs.push_back(Args.MakeArgString(
9018 Twine(
"--offload-opt=-pass-remarks-missed=") + A->getValue()));
9019 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
9020 CmdArgs.push_back(Args.MakeArgString(
9021 Twine(
"--offload-opt=-pass-remarks-analysis=") + A->getValue()));
9022 if (Args.getLastArg(options::OPT_save_temps_EQ))
9023 CmdArgs.push_back(
"--save-temps");
9026 Linker->
ConstructJob(
C, JA, Output, Inputs, Args, LinkingOutput);
9027 const auto &LinkCommand =
C.getJobs().getJobs().back();
9030 for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) {
9031 StringRef Val = A->getValue(0);
9034 Args.MakeArgString(Twine(
"--device-linker=") + A->getValue(1)));
9036 CmdArgs.push_back(Args.MakeArgString(
9037 "--device-linker=" +
9041 Args.ClaimAllArgs(options::OPT_Xoffload_linker);
9044 if (Args.hasFlag(options::OPT_fopenmp_target_jit,
9045 options::OPT_fno_openmp_target_jit,
false))
9046 CmdArgs.push_back(
"--embed-bitcode");
9049 for (Arg *A : Args.filtered(options::OPT_mllvm)) {
9050 CmdArgs.push_back(
"-mllvm");
9051 CmdArgs.push_back(A->getValue());
9056 CmdArgs.push_back(Args.MakeArgString(Twine(
"--linker-path=") +
9057 LinkCommand->getExecutable()));
9058 for (
const char *LinkArg : LinkCommand->getArguments())
9059 CmdArgs.push_back(LinkArg);
9064 Args.MakeArgString(
getToolChain().GetProgramPath(
"clang-linker-wrapper"));
9068 LinkCommand->replaceExecutable(Exec);
9069 LinkCommand->replaceArguments(CmdArgs);
static StringRef bytes(const std::vector< T, Allocator > &v)
static std::string ComplexRangeKindToStr(LangOptions::ComplexRangeKind Range)
static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
The -mprefer-vector-width option accepts either a positive integer or the string "none".
static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC)
static bool checkDebugInfoOption(const Arg *A, const ArgList &Args, const Driver &D, const ToolChain &TC)
static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs, types::ID InputType)
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, ArgStringList &CmdArgs)
static std::string RenderComplexRangeOption(LangOptions::ComplexRangeKind Range)
static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind, unsigned DwarfVersion, llvm::DebuggerKind DebuggerTuning)
static void ProcessVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static void renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, bool IRInput, ArgStringList &CmdArgs, const InputInfo &Output, llvm::codegenoptions::DebugInfoKind &DebugInfoKind, DwarfFissionKind &DwarfFission)
static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec)
Vectorize at all optimization levels greater than 1 except for -Oz.
static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
static bool maybeHasClangPchSignature(const Driver &D, StringRef Path)
static bool addExceptionArgs(const ArgList &Args, types::ID InputType, const ToolChain &TC, bool KernelOrKext, const ObjCRuntime &objcRuntime, ArgStringList &CmdArgs)
Adds exception related arguments to the driver command arguments.
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args)
void AddAAPCSVolatileBitfieldArgs(const ArgList &Args, ArgStringList &CmdArgs)
static bool isSignedCharDefault(const llvm::Triple &Triple)
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args, bool isWindowsMSVC)
/EH controls whether to run destructor cleanups when exceptions are thrown.
static bool gchProbe(const Driver &D, StringRef Path)
static void RenderOpenACCOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs, types::ID InputType)
static void EmitComplexRangeDiag(const Driver &D, std::string str1, std::string str2)
static bool CheckARMImplicitITArg(StringRef Value)
static bool hasMultipleInvocations(const llvm::Triple &Triple, const ArgList &Args)
static void handleAMDGPUCodeObjectVersionOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs, bool IsCC1As=false)
static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
static void ParseMRecip(const Driver &D, const ArgList &Args, ArgStringList &OutStrings)
The -mrecip flag requires processing of many optional parameters.
static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs, types::ID InputType)
static void renderDwarfFormat(const Driver &D, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs, unsigned DwarfVersion)
static void RenderObjCOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, ObjCRuntime &Runtime, bool InferCovariantReturns, const InputInfo &Input, ArgStringList &CmdArgs)
static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the coverage file path prefix map.
static void AddARMImplicitITArgs(const ArgList &Args, ArgStringList &CmdArgs, StringRef Value)
static bool checkRemarksOptions(const Driver &D, const ArgList &Args, const llvm::Triple &Triple)
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
static bool RenderModulesOptions(Compilation &C, const Driver &D, const ArgList &Args, const InputInfo &Input, const InputInfo &Output, bool HaveStd20, ArgStringList &CmdArgs)
static void SetRISCVSmallDataLimit(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static void forAllAssociatedToolChains(Compilation &C, const JobAction &JA, const ToolChain &RegularToolChain, llvm::function_ref< void(const ToolChain &)> Work)
Apply Work on the current tool chain RegularToolChain and any other offloading tool chain that is ass...
static bool isValidSymbolName(StringRef S)
static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the macro file path prefix map.
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
static std::string ComplexArithmeticStr(LangOptions::ComplexRangeKind Range)
static void addDebugObjectName(const ArgList &Args, ArgStringList &CmdArgs, const char *DebugCompilationDir, const char *OutputFileName)
static bool getRefinementStep(StringRef In, const Driver &D, const Arg &A, size_t &Position)
This is a helper function for validating the optional refinement step parameter in reciprocal argumen...
static void CollectARMPACBTIOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool isAArch64)
static void RenderSSPOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext)
static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs)
static void RenderSCPOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static void RenderTrivialAutoVarInitOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static bool maybeConsumeDash(const std::string &EH, size_t &I)
static const char * addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs, const llvm::vfs::FileSystem &VFS)
Add a CC1 option to specify the debug compilation directory.
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args)
static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC, const JobAction &JA)
static void EscapeSpacesAndBackslashes(const char *Arg, SmallVectorImpl< char > &Res)
static void addDebugPrefixMapArg(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the debug file path prefix map.
static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input)
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, bool OFastEnabled, const ArgList &Args, ArgStringList &CmdArgs, const JobAction &JA)
static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C, const JobAction &JA, const InputInfo &Output, const ArgList &Args, SanitizerArgs &SanArgs, ArgStringList &CmdArgs)
clang::CodeGenOptions::FramePointerKind getFramePointerKind(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
Defines the clang::LangOptions interface.
llvm::MachO::Target Target
Defines types useful for describing an Objective-C runtime.
Defines version macros and version-related utility functions for Clang.
static StringRef getWarningOptionForGroup(diag::Group)
Given a group ID, returns the flag that toggles the group.
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
ComplexRangeKind
Controls the various implementations for complex multiplication and.
@ CX_Full
Implementation of complex division and multiplication using a call to runtime library functions(gener...
@ CX_Basic
Implementation of complex division and multiplication using algebraic formulas at source precision.
@ CX_Promoted
Implementation of complex division using algebraic formulas at higher precision.
@ CX_None
No range rule is enabled.
@ CX_Improved
Implementation of complex division offering an improved handling for overflow in intermediate calcula...
The basic abstraction for the target Objective-C runtime.
bool allowsWeak() const
Does this runtime allow the use of __weak?
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
const VersionTuple & getVersion() const
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
std::string getAsString() const
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
Scope - A scope is a transient data structure that is used while parsing the program.
Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
Action - Represent an abstract compilation step to perform.
const char * getOffloadingArch() const
types::ID getType() const
const ToolChain * getOffloadingToolChain() const
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
ActionClass getKind() const
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
OffloadKind getOffloadingDeviceKind() const
bool isHostOffloading(unsigned int OKind) const
Check if this action have any offload kinds.
bool isDeviceOffloading(OffloadKind OKind) const
bool isOffloading(OffloadKind OKind) const
Command - An executable path/name and argument vector to execute.
Compilation - A set of tasks to perform for a single driver invocation.
A class to find a viable CUDA installation.
StringRef getInstallPath() const
Get the detected Cuda installation path.
bool isValid() const
Check whether we detected a valid Cuda install.
Distro - Helper class for detecting and classifying Linux distributions.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
DiagnosticsEngine & getDiags() const
const char * getPrependArg() const
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
static bool getDefaultModuleCachePath(SmallVectorImpl< char > &Result)
Compute the default -fmodule-cache-path.
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
const char * getClangProgramPath() const
Get the path to the main clang executable.
DiagnosticBuilder Diag(unsigned DiagID) const
unsigned CCPrintInternalStats
Set CC_PRINT_INTERNAL_STAT mode, which causes the driver to dump internal performance report to CC_PR...
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
std::string ClangExecutable
The original path to the clang executable.
void PrintVersion(const Compilation &C, raw_ostream &OS) const
PrintVersion - Print the driver version.
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
std::string CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
std::string CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
std::string ResourceDir
The path to the compiler resource directory.
llvm::vfs::FileSystem & getVFS() const
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
std::string Dir
The path the driver executable was in, as invoked from the command line.
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
HeaderIncludeFormatKind CCPrintHeadersFormat
The format of the header information that is emitted.
HeaderIncludeFilteringKind CCPrintHeadersFiltering
This flag determines whether clang should filter the header information that is emitted.
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
bool getProbePrecompiled() const
An offload action combines host or/and device actions according to the programming model implementati...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
bool isHLSL(ID Id)
isHLSL - Is this an HLSL input.
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed,...
bool isLLVMIR(ID Id)
Is this LLVM IR.
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
bool isOpenCL(ID Id)
isOpenCL - Is this an "OpenCL" input.
bool isSrcFile(ID Id)
isSrcFile - Is this a source file, i.e.
const char * getTypeTempSuffix(ID Id, bool CLStyle=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type,...
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
bool willEmitRemarks(const llvm::opt::ArgList &Args)
@ Quoted
'#include ""' paths, added by 'gcc -iquote'.
The JSON file list parser is used to communicate input to InstallAPI.
std::optional< diag::Group > diagGroupFromCLWarningID(unsigned)
For cl.exe warning IDs that cleany map to clang diagnostic groups, returns the corresponding group.
void quoteMakeTarget(StringRef Target, SmallVectorImpl< char > &Res)
Quote target names for inclusion in GNU Make dependency files.
const char * headerIncludeFormatKindToString(HeaderIncludeFormatKind K)
const char * headerIncludeFilteringKindToString(HeaderIncludeFilteringKind K)
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ Result
The result type of a method or function.
const char * CudaVersionToString(CudaVersion V)
const FunctionProtoType * T
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
static constexpr ResponseFileSupport AtFileUTF8()