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/AArch64TargetParser.h"
59#include "llvm/TargetParser/ARMTargetParserCommon.h"
60#include "llvm/TargetParser/Host.h"
61#include "llvm/TargetParser/LoongArchTargetParser.h"
62#include "llvm/TargetParser/RISCVISAInfo.h"
63#include "llvm/TargetParser/RISCVTargetParser.h"
72 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
73 options::OPT_fminimize_whitespace,
74 options::OPT_fno_minimize_whitespace,
75 options::OPT_fkeep_system_includes,
76 options::OPT_fno_keep_system_includes)) {
77 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
78 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
79 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
80 << A->getBaseArg().getAsString(Args)
81 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
88 if (Args.hasArg(options::OPT_static))
90 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
91 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
100 for (; *Arg; ++Arg) {
118 llvm::function_ref<
void(
const ToolChain &)> Work) {
120 Work(RegularToolChain);
135 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
150 const Arg &A,
size_t &Position) {
151 const char RefinementStepToken =
':';
152 Position = In.find(RefinementStepToken);
153 if (Position != StringRef::npos) {
154 StringRef Option = A.getOption().getName();
155 StringRef RefStep = In.substr(Position + 1);
163 if (RefStep.size() != 1) {
164 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
167 char RefStepChar = RefStep[0];
168 if (RefStepChar <
'0' || RefStepChar >
'9') {
169 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
178 ArgStringList &OutStrings) {
179 StringRef DisabledPrefixIn =
"!";
180 StringRef DisabledPrefixOut =
"!";
181 StringRef EnabledPrefixOut =
"";
182 StringRef Out =
"-mrecip=";
184 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
188 unsigned NumOptions = A->getNumValues();
189 if (NumOptions == 0) {
191 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
196 if (NumOptions == 1) {
197 StringRef Val = A->getValue(0);
201 StringRef ValBase = Val.slice(0, RefStepLoc);
202 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
203 OutStrings.push_back(Args.MakeArgString(Out + Val));
212 llvm::StringMap<bool> OptionStrings;
213 OptionStrings.insert(std::make_pair(
"divd",
false));
214 OptionStrings.insert(std::make_pair(
"divf",
false));
215 OptionStrings.insert(std::make_pair(
"divh",
false));
216 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
217 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
218 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
219 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
220 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
221 OptionStrings.insert(std::make_pair(
"sqrth",
false));
222 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
223 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
224 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
226 for (
unsigned i = 0; i != NumOptions; ++i) {
227 StringRef Val = A->getValue(i);
229 bool IsDisabled = Val.starts_with(DisabledPrefixIn);
238 StringRef ValBase = Val.slice(0, RefStep);
239 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
240 if (OptionIter == OptionStrings.end()) {
242 OptionIter = OptionStrings.find(ValBase.str() +
'f');
243 if (OptionIter == OptionStrings.end()) {
245 D.
Diag(diag::err_drv_unknown_argument) << Val;
251 if (OptionStrings[ValBase.str() +
'd'] ||
252 OptionStrings[ValBase.str() +
'h']) {
253 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
258 if (OptionIter->second ==
true) {
260 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
265 OptionIter->second =
true;
269 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
270 OptionStrings[ValBase.str() +
'd'] =
true;
271 OptionStrings[ValBase.str() +
'h'] =
true;
275 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
276 Out = Args.MakeArgString(Out + Prefix + Val);
277 if (i != NumOptions - 1)
278 Out = Args.MakeArgString(Out +
",");
281 OutStrings.push_back(Args.MakeArgString(Out));
287 ArgStringList &CmdArgs) {
288 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
292 StringRef
Value = A->getValue();
293 if (
Value ==
"none") {
294 CmdArgs.push_back(
"-mprefer-vector-width=none");
297 if (
Value.getAsInteger(10, Width)) {
298 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
301 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
307 const llvm::Triple &Triple) {
314 if (!Triple.isMacOSX())
317 return (!Triple.isMacOSXVersionLT(10, 5) &&
318 (Triple.getArch() == llvm::Triple::x86_64 ||
319 Triple.getArch() == llvm::Triple::arm));
329 ArgStringList &CmdArgs) {
330 const llvm::Triple &Triple = TC.
getTriple();
335 Args.ClaimAllArgs(options::OPT_fexceptions);
336 Args.ClaimAllArgs(options::OPT_fno_exceptions);
337 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
338 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
339 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
340 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
341 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
342 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
347 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
351 if (Triple.isWindowsMSVCEnvironment()) {
352 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
353 options::OPT_fno_async_exceptions,
false);
355 CmdArgs.push_back(
"-fasync-exceptions");
363 Args.hasFlag(options::OPT_fobjc_exceptions,
364 options::OPT_fno_objc_exceptions,
true)) {
365 CmdArgs.push_back(
"-fobjc-exceptions");
372 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
373 !Triple.isPS() && !Triple.isDriverKit();
374 Arg *ExceptionArg = Args.getLastArg(
375 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
376 options::OPT_fexceptions, options::OPT_fno_exceptions);
378 CXXExceptionsEnabled =
379 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
380 ExceptionArg->getOption().matches(options::OPT_fexceptions);
382 if (CXXExceptionsEnabled) {
383 CmdArgs.push_back(
"-fcxx-exceptions");
392 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
394 Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,
395 options::OPT_fno_assume_nothrow_exception_dtor);
398 CmdArgs.push_back(
"-fexceptions");
414 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
420 ArgStringList &CmdArgs,
421 const llvm::vfs::FileSystem &VFS) {
422 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
423 options::OPT_fdebug_compilation_dir_EQ)) {
424 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
425 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
428 A->render(Args, CmdArgs);
429 }
else if (llvm::ErrorOr<std::string> CWD =
430 VFS.getCurrentWorkingDirectory()) {
431 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
433 StringRef Path(CmdArgs.back());
434 return Path.substr(Path.find(
'=') + 1).data();
438 const char *DebugCompilationDir,
439 const char *OutputFileName) {
441 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
442 if (StringRef(Arg->getValue()).starts_with(
"-object-file-name"))
445 if (Args.hasArg(options::OPT_object_file_name_EQ))
449 if (ObjFileNameForDebug !=
"-" &&
450 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
451 (!DebugCompilationDir ||
452 llvm::sys::path::is_absolute(DebugCompilationDir))) {
454 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
460 llvm::sys::path::Style Style =
461 llvm::sys::path::is_absolute(ObjFileNameForDebug)
462 ? llvm::sys::path::Style::native
463 : llvm::sys::path::Style::windows_backslash;
464 llvm::sys::path::remove_dots(ObjFileNameForDebug,
true,
467 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
472 const ArgList &Args, ArgStringList &CmdArgs) {
473 auto AddOneArg = [&](StringRef Map, StringRef Name) {
474 if (!Map.contains(
'='))
475 D.
Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
477 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
480 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
481 options::OPT_fdebug_prefix_map_EQ)) {
482 AddOneArg(A->getValue(), A->getOption().getName());
486 if (GlobalRemapEntry.empty())
488 AddOneArg(GlobalRemapEntry,
"environment");
493 ArgStringList &CmdArgs) {
494 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
495 options::OPT_fmacro_prefix_map_EQ)) {
496 StringRef Map = A->getValue();
497 if (!Map.contains(
'='))
498 D.
Diag(diag::err_drv_invalid_argument_to_option)
499 << Map << A->getOption().getName();
501 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
508 ArgStringList &CmdArgs) {
509 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
510 options::OPT_fcoverage_prefix_map_EQ)) {
511 StringRef Map = A->getValue();
512 if (!Map.contains(
'='))
513 D.
Diag(diag::err_drv_invalid_argument_to_option)
514 << Map << A->getOption().getName();
516 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
525 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
526 if (A->getOption().matches(options::OPT_O4) ||
527 A->getOption().matches(options::OPT_Ofast))
530 if (A->getOption().matches(options::OPT_O0))
533 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
536 StringRef S(A->getValue());
544 unsigned OptLevel = 0;
545 if (S.getAsInteger(10, OptLevel))
556 ArgStringList &CmdArgs) {
559 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
562 CmdArgs.push_back(
"-x");
563 if (Args.hasArg(options::OPT_rewrite_objc))
569 const char *ClangType;
571 case types::TY_CXXModule:
574 case types::TY_PP_CXXModule:
575 ClangType =
"c++-cpp-output";
581 CmdArgs.push_back(ClangType);
588 ArgStringList &CmdArgs) {
590 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
591 options::OPT_fprofile_generate_EQ,
592 options::OPT_fno_profile_generate);
593 if (PGOGenerateArg &&
594 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
595 PGOGenerateArg =
nullptr;
599 auto *ProfileGenerateArg = Args.getLastArg(
600 options::OPT_fprofile_instr_generate,
601 options::OPT_fprofile_instr_generate_EQ,
602 options::OPT_fno_profile_instr_generate);
603 if (ProfileGenerateArg &&
604 ProfileGenerateArg->getOption().matches(
605 options::OPT_fno_profile_instr_generate))
606 ProfileGenerateArg =
nullptr;
608 if (PGOGenerateArg && ProfileGenerateArg)
609 D.
Diag(diag::err_drv_argument_not_allowed_with)
610 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
614 if (PGOGenerateArg && ProfileUseArg)
615 D.
Diag(diag::err_drv_argument_not_allowed_with)
616 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
618 if (ProfileGenerateArg && ProfileUseArg)
619 D.
Diag(diag::err_drv_argument_not_allowed_with)
620 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
622 if (CSPGOGenerateArg && PGOGenerateArg) {
623 D.
Diag(diag::err_drv_argument_not_allowed_with)
624 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
625 PGOGenerateArg =
nullptr;
630 D.
Diag(diag::err_drv_unsupported_opt_for_target)
631 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
634 if (ProfileGenerateArg) {
635 if (ProfileGenerateArg->getOption().matches(
636 options::OPT_fprofile_instr_generate_EQ))
637 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
638 ProfileGenerateArg->getValue()));
640 CmdArgs.push_back(
"-fprofile-instrument=clang");
641 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
642 Args.hasFlag(options::OPT_frtlib_defaultlib,
643 options::OPT_fno_rtlib_defaultlib,
true)) {
645 CmdArgs.push_back(Args.MakeArgString(
650 Arg *PGOGenArg =
nullptr;
651 if (PGOGenerateArg) {
652 assert(!CSPGOGenerateArg);
653 PGOGenArg = PGOGenerateArg;
654 CmdArgs.push_back(
"-fprofile-instrument=llvm");
656 if (CSPGOGenerateArg) {
657 assert(!PGOGenerateArg);
658 PGOGenArg = CSPGOGenerateArg;
659 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
662 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
663 Args.hasFlag(options::OPT_frtlib_defaultlib,
664 options::OPT_fno_rtlib_defaultlib,
true)) {
666 CmdArgs.push_back(Args.MakeArgString(
669 if (PGOGenArg->getOption().matches(
670 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
671 : options::OPT_fcs_profile_generate_EQ)) {
673 llvm::sys::path::append(Path,
"default_%m.profraw");
675 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
680 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
681 CmdArgs.push_back(Args.MakeArgString(
682 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
683 else if ((ProfileUseArg->getOption().matches(
684 options::OPT_fprofile_use_EQ) ||
685 ProfileUseArg->getOption().matches(
686 options::OPT_fprofile_instr_use))) {
688 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
689 if (Path.empty() || llvm::sys::fs::is_directory(Path))
690 llvm::sys::path::append(Path,
"default.profdata");
692 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
696 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
697 options::OPT_fno_test_coverage,
false) ||
698 Args.hasArg(options::OPT_coverage);
701 if (Args.hasFlag(options::OPT_fcoverage_mapping,
702 options::OPT_fno_coverage_mapping,
false)) {
703 if (!ProfileGenerateArg)
704 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
705 <<
"-fcoverage-mapping"
706 <<
"-fprofile-instr-generate";
708 CmdArgs.push_back(
"-fcoverage-mapping");
711 if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
713 if (!Args.hasFlag(options::OPT_fcoverage_mapping,
714 options::OPT_fno_coverage_mapping,
false))
715 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
717 <<
"-fcoverage-mapping";
719 CmdArgs.push_back(
"-fcoverage-mcdc");
722 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
723 options::OPT_fcoverage_compilation_dir_EQ)) {
724 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
725 CmdArgs.push_back(Args.MakeArgString(
726 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
728 A->render(Args, CmdArgs);
729 }
else if (llvm::ErrorOr<std::string> CWD =
730 D.
getVFS().getCurrentWorkingDirectory()) {
731 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
734 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
735 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
736 if (!Args.hasArg(options::OPT_coverage))
737 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
738 <<
"-fprofile-exclude-files="
741 StringRef
v = Arg->getValue();
743 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
746 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
747 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
748 if (!Args.hasArg(options::OPT_coverage))
749 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
750 <<
"-fprofile-filter-files="
753 StringRef
v = Arg->getValue();
754 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
757 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
758 StringRef Val = A->getValue();
759 if (Val ==
"atomic" || Val ==
"prefer-atomic")
760 CmdArgs.push_back(
"-fprofile-update=atomic");
761 else if (Val !=
"single")
762 D.
Diag(diag::err_drv_unsupported_option_argument)
763 << A->getSpelling() << Val;
766 int FunctionGroups = 1;
767 int SelectedFunctionGroup = 0;
768 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
769 StringRef Val = A->getValue();
770 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
771 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
774 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
775 StringRef Val = A->getValue();
776 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
777 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
778 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
780 if (FunctionGroups != 1)
781 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
782 Twine(FunctionGroups)));
783 if (SelectedFunctionGroup != 0)
784 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
785 Twine(SelectedFunctionGroup)));
791 Arg *FProfileDir =
nullptr;
792 if (Args.hasArg(options::OPT_fprofile_arcs) ||
793 Args.hasArg(options::OPT_coverage))
794 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
798 (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
803 if (EmitCovNotes || EmitCovData) {
805 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
808 CoverageFilename = DumpDir->getValue();
809 CoverageFilename += llvm::sys::path::filename(Output.
getBaseInput());
810 }
else if (Arg *FinalOutput =
811 C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
812 CoverageFilename = FinalOutput->getValue();
813 }
else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o)) {
814 CoverageFilename = FinalOutput->getValue();
816 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
818 if (llvm::sys::path::is_relative(CoverageFilename))
819 (void)D.
getVFS().makeAbsolute(CoverageFilename);
820 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
823 Args.MakeArgString(
"-coverage-notes-file=" + CoverageFilename));
829 CoverageFilename = FProfileDir->getValue();
830 llvm::sys::path::append(CoverageFilename, Gcno);
832 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
834 Args.MakeArgString(
"-coverage-data-file=" + CoverageFilename));
841 llvm::codegenoptions::DebugInfoKind DebugInfoKind,
842 unsigned DwarfVersion,
843 llvm::DebuggerKind DebuggerTuning) {
845 if (DwarfVersion > 0)
847 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
848 switch (DebuggerTuning) {
849 case llvm::DebuggerKind::GDB:
850 CmdArgs.push_back(
"-debugger-tuning=gdb");
852 case llvm::DebuggerKind::LLDB:
853 CmdArgs.push_back(
"-debugger-tuning=lldb");
855 case llvm::DebuggerKind::SCE:
856 CmdArgs.push_back(
"-debugger-tuning=sce");
858 case llvm::DebuggerKind::DBX:
859 CmdArgs.push_back(
"-debugger-tuning=dbx");
868 assert(A &&
"Expected non-nullptr argument.");
871 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
877 ArgStringList &CmdArgs,
880 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
884 StringRef
Value = A->getValue();
885 if (
Value ==
"none") {
886 CmdArgs.push_back(
"--compress-debug-sections=none");
887 }
else if (
Value ==
"zlib") {
888 if (llvm::compression::zlib::isAvailable()) {
890 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
892 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
894 }
else if (
Value ==
"zstd") {
895 if (llvm::compression::zstd::isAvailable()) {
897 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
899 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
902 D.
Diag(diag::err_drv_unsupported_option_argument)
903 << A->getSpelling() <<
Value;
910 ArgStringList &CmdArgs,
911 bool IsCC1As =
false) {
919 CmdArgs.insert(CmdArgs.begin() + 1,
920 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
922 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
925 CmdArgs.insert(CmdArgs.begin() + 1,
926 Args.MakeArgString(Twine(
"-mcode-object-version=") +
932 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MemBuf =
933 D.
getVFS().getBufferForFile(Path);
936 llvm::file_magic Magic = llvm::identify_magic((*MemBuf)->getBuffer());
937 if (Magic == llvm::file_magic::unknown)
941 if (Magic == llvm::file_magic::clang_ast)
944 llvm::object::ObjectFile::createObjectFile(**MemBuf, Magic);
945 return !Obj.takeError();
949 llvm::ErrorOr<llvm::vfs::Status> Status = D.
getVFS().status(Path);
953 if (Status->isDirectory()) {
955 for (llvm::vfs::directory_iterator DI = D.
getVFS().dir_begin(Path, EC), DE;
956 !EC && DI != DE; DI = DI.increment(EC)) {
960 D.
Diag(diag::warn_drv_pch_ignoring_gch_dir) << Path;
966 D.
Diag(diag::warn_drv_pch_ignoring_gch_file) << Path;
971 const Driver &D,
const ArgList &Args,
972 ArgStringList &CmdArgs,
979 Args.AddLastArg(CmdArgs, options::OPT_C);
980 Args.AddLastArg(CmdArgs, options::OPT_CC);
983 Arg *ArgM = Args.getLastArg(options::OPT_MM);
985 ArgM = Args.getLastArg(options::OPT_M);
986 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
988 ArgMD = Args.getLastArg(options::OPT_MD);
992 CmdArgs.push_back(
"-w");
999 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1000 DepFile = MF->getValue();
1001 C.addFailureResultFile(DepFile, &JA);
1002 }
else if (Output.
getType() == types::TY_Dependencies) {
1004 }
else if (!ArgMD) {
1008 C.addFailureResultFile(DepFile, &JA);
1010 CmdArgs.push_back(
"-dependency-file");
1011 CmdArgs.push_back(DepFile);
1013 bool HasTarget =
false;
1014 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1017 if (A->getOption().matches(options::OPT_MT)) {
1018 A->render(Args, CmdArgs);
1020 CmdArgs.push_back(
"-MT");
1023 CmdArgs.push_back(Args.MakeArgString(Quoted));
1029 const char *DepTarget;
1033 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1034 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1035 DepTarget = OutputOpt->getValue();
1041 llvm::sys::path::replace_extension(
P,
"o");
1042 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1045 CmdArgs.push_back(
"-MT");
1048 CmdArgs.push_back(Args.MakeArgString(Quoted));
1051 if (ArgM->getOption().matches(options::OPT_M) ||
1052 ArgM->getOption().matches(options::OPT_MD))
1053 CmdArgs.push_back(
"-sys-header-deps");
1054 if ((isa<PrecompileJobAction>(JA) &&
1055 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1056 Args.hasArg(options::OPT_fmodule_file_deps))
1057 CmdArgs.push_back(
"-module-file-deps");
1060 if (Args.hasArg(options::OPT_MG)) {
1061 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1062 ArgM->getOption().matches(options::OPT_MMD))
1063 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1064 CmdArgs.push_back(
"-MG");
1067 Args.AddLastArg(CmdArgs, options::OPT_MP);
1068 Args.AddLastArg(CmdArgs, options::OPT_MV);
1081 if (!Args.hasArg(options::OPT_nostdinc) &&
1082 !Args.hasArg(options::OPT_nogpuinc) &&
1083 !Args.hasArg(options::OPT_nobuiltininc)) {
1091 llvm::sys::path::append(
P,
"include");
1092 llvm::sys::path::append(
P,
getToolChain().getTripleString());
1093 CmdArgs.push_back(
"-internal-isystem");
1094 CmdArgs.push_back(Args.MakeArgString(
P));
1099 llvm::sys::path::append(
P,
"include");
1100 llvm::sys::path::append(
P,
"llvm_libc_wrappers");
1101 CmdArgs.push_back(
"-internal-isystem");
1102 CmdArgs.push_back(Args.MakeArgString(
P));
1109 !Args.hasArg(options::OPT_nostdinc) &&
1110 !Args.hasArg(options::OPT_nogpuinc) &&
1113 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1117 llvm::sys::path::append(
P,
"include");
1118 llvm::sys::path::append(
P,
"openmp_wrappers");
1119 CmdArgs.push_back(
"-internal-isystem");
1120 CmdArgs.push_back(Args.MakeArgString(
P));
1123 CmdArgs.push_back(
"-include");
1124 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1134 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1135 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1138 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1141 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1142 options::OPT_fno_pch_instantiate_templates,
true))
1143 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1145 if (YcArg || YuArg) {
1146 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1147 if (!isa<PrecompileJobAction>(JA)) {
1148 CmdArgs.push_back(
"-include-pch");
1150 C, !ThroughHeader.empty()
1152 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1155 if (ThroughHeader.empty()) {
1156 CmdArgs.push_back(Args.MakeArgString(
1157 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1160 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1165 bool RenderedImplicitInclude =
false;
1166 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1167 if (A->getOption().matches(options::OPT_include) &&
1170 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1171 RenderedImplicitInclude =
true;
1173 bool FoundPCH =
false;
1178 llvm::sys::path::replace_extension(
P,
"pch");
1184 llvm::sys::path::replace_extension(
P,
"gch");
1189 if (IsFirstImplicitInclude) {
1191 CmdArgs.push_back(
"-include-pch");
1192 CmdArgs.push_back(Args.MakeArgString(
P));
1196 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1197 << A->getAsString(Args);
1200 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1207 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1210 }
else if (A->getOption().matches(options::OPT_ibuiltininc)) {
1217 A->render(Args, CmdArgs);
1220 Args.addAllArgs(CmdArgs,
1221 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1222 options::OPT_F, options::OPT_index_header_map});
1230 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1231 options::OPT_Xpreprocessor);
1234 if (Arg *A = Args.getLastArg(options::OPT_I_))
1235 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1239 StringRef sysroot =
C.getSysRoot();
1240 if (sysroot !=
"") {
1241 if (!Args.hasArg(options::OPT_isysroot)) {
1242 CmdArgs.push_back(
"-isysroot");
1243 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1260 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1268 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1271 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1280 [&Args, &CmdArgs](
const ToolChain &TC) {
1291 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1292 options::OPT_fno_file_reproducible);
1294 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1295 CmdArgs.push_back(
"-source-date-epoch");
1296 CmdArgs.push_back(Args.MakeArgString(Epoch));
1299 Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,
1300 options::OPT_fno_define_target_os_macros);
1305 switch (Triple.getArch()) {
1309 case llvm::Triple::aarch64:
1310 case llvm::Triple::aarch64_32:
1311 case llvm::Triple::aarch64_be:
1312 case llvm::Triple::arm:
1313 case llvm::Triple::armeb:
1314 case llvm::Triple::thumb:
1315 case llvm::Triple::thumbeb:
1316 if (Triple.isOSDarwin() || Triple.isOSWindows())
1320 case llvm::Triple::ppc:
1321 case llvm::Triple::ppc64:
1322 if (Triple.isOSDarwin())
1326 case llvm::Triple::hexagon:
1327 case llvm::Triple::ppcle:
1328 case llvm::Triple::ppc64le:
1329 case llvm::Triple::riscv32:
1330 case llvm::Triple::riscv64:
1331 case llvm::Triple::systemz:
1332 case llvm::Triple::xcore:
1338 const ArgList &Args) {
1341 if (!Triple.isOSDarwin())
1345 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1349 const llvm::Triple &Triple) {
1354 bool hasExplicitOutputFile =
1355 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1357 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1358 <<
"-foptimization-record-file";
1365 const llvm::Triple &Triple,
1368 StringRef Format =
"yaml";
1369 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1370 Format = A->getValue();
1372 CmdArgs.push_back(
"-opt-record-file");
1374 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1376 CmdArgs.push_back(A->getValue());
1378 bool hasMultipleArchs =
1379 Triple.isOSDarwin() &&
1380 Args.getAllArgValues(options::OPT_arch).size() > 1;
1384 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1385 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1386 F = FinalOutput->getValue();
1388 if (Format !=
"yaml" &&
1389 Triple.isOSDarwin() &&
1403 llvm::sys::path::replace_extension(F,
"");
1405 Triple.normalize());
1415 if (hasMultipleArchs) {
1419 llvm::sys::path::replace_extension(F,
"");
1422 F += Triple.getArchName();
1424 llvm::sys::path::replace_extension(F, OldExtension);
1428 Extension +=
"opt.";
1429 Extension += Format;
1431 llvm::sys::path::replace_extension(F, Extension);
1432 CmdArgs.push_back(Args.MakeArgString(F));
1436 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1437 CmdArgs.push_back(
"-opt-record-passes");
1438 CmdArgs.push_back(A->getValue());
1441 if (!Format.empty()) {
1442 CmdArgs.push_back(
"-opt-record-format");
1443 CmdArgs.push_back(Format.data());
1448 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1449 options::OPT_fno_aapcs_bitfield_width,
true))
1450 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1452 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1453 CmdArgs.push_back(
"-faapcs-bitfield-load");
1457void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1458 const ArgList &Args, ArgStringList &CmdArgs) {
1462 const char *ABIName =
nullptr;
1463 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1464 ABIName = A->getValue();
1466 std::string CPU =
getCPUName(D, Args, Triple,
false);
1467 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1470 CmdArgs.push_back(
"-target-abi");
1471 CmdArgs.push_back(ABIName);
1474void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1475 auto StrictAlignIter =
1476 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1477 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1479 if (StrictAlignIter != CmdArgs.rend() &&
1480 StringRef(*StrictAlignIter) ==
"+strict-align")
1481 CmdArgs.push_back(
"-Wunaligned-access");
1486 ArgStringList &CmdArgs,
bool isAArch64) {
1487 const Arg *A = isAArch64
1488 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1489 options::OPT_mbranch_protection_EQ)
1490 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1496 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1497 D.
Diag(diag::warn_incompatible_branch_protection_option)
1498 << Triple.getArchName();
1500 StringRef
Scope, Key;
1501 bool IndirectBranches, BranchProtectionPAuthLR, GuardedControlStack;
1503 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1504 Scope = A->getValue();
1506 D.
Diag(diag::err_drv_unsupported_option_argument)
1507 << A->getSpelling() <<
Scope;
1509 IndirectBranches =
false;
1510 BranchProtectionPAuthLR =
false;
1511 GuardedControlStack =
false;
1514 llvm::ARM::ParsedBranchProtection PBP;
1515 bool EnablePAuthLR =
false;
1522 auto isPAuthLR = [](
const char *member) {
1523 llvm::AArch64::ExtensionInfo pauthlr_extension =
1524 llvm::AArch64::getExtensionByID(llvm::AArch64::AEK_PAUTHLR);
1525 return pauthlr_extension.Feature == member;
1528 if (std::any_of(CmdArgs.begin(), CmdArgs.end(), isPAuthLR))
1529 EnablePAuthLR =
true;
1531 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg,
1533 D.
Diag(diag::err_drv_unsupported_option_argument)
1534 << A->getSpelling() << DiagMsg;
1535 if (!isAArch64 && PBP.Key ==
"b_key")
1536 D.
Diag(diag::warn_unsupported_branch_protection)
1537 <<
"b-key" << A->getAsString(Args);
1540 BranchProtectionPAuthLR = PBP.BranchProtectionPAuthLR;
1541 IndirectBranches = PBP.BranchTargetEnforcement;
1542 GuardedControlStack = PBP.GuardedControlStack;
1546 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1547 if (
Scope !=
"none")
1549 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1550 if (BranchProtectionPAuthLR)
1552 Args.MakeArgString(Twine(
"-mbranch-protection-pauth-lr")));
1553 if (IndirectBranches)
1554 CmdArgs.push_back(
"-mbranch-target-enforce");
1555 if (GuardedControlStack)
1556 CmdArgs.push_back(
"-mguarded-control-stack");
1559void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1560 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1561 RenderARMABI(
getToolChain().getDriver(), Triple, Args, CmdArgs);
1568 CmdArgs.push_back(
"-msoft-float");
1569 CmdArgs.push_back(
"-mfloat-abi");
1570 CmdArgs.push_back(
"soft");
1573 CmdArgs.push_back(
"-mfloat-abi");
1574 CmdArgs.push_back(
"soft");
1578 CmdArgs.push_back(
"-mfloat-abi");
1579 CmdArgs.push_back(
"hard");
1583 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1584 options::OPT_mno_global_merge)) {
1585 CmdArgs.push_back(
"-mllvm");
1586 if (A->getOption().matches(options::OPT_mno_global_merge))
1587 CmdArgs.push_back(
"-arm-global-merge=false");
1589 CmdArgs.push_back(
"-arm-global-merge=true");
1592 if (!Args.hasFlag(options::OPT_mimplicit_float,
1593 options::OPT_mno_implicit_float,
true))
1594 CmdArgs.push_back(
"-no-implicit-float");
1596 if (Args.getLastArg(options::OPT_mcmse))
1597 CmdArgs.push_back(
"-mcmse");
1604 AddUnalignedAccessWarning(CmdArgs);
1607void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1608 const ArgList &Args,
bool KernelOrKext,
1609 ArgStringList &CmdArgs)
const {
1620 case llvm::Triple::arm:
1621 case llvm::Triple::armeb:
1622 case llvm::Triple::thumb:
1623 case llvm::Triple::thumbeb:
1625 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1628 case llvm::Triple::aarch64:
1629 case llvm::Triple::aarch64_32:
1630 case llvm::Triple::aarch64_be:
1631 AddAArch64TargetArgs(Args, CmdArgs);
1634 case llvm::Triple::loongarch32:
1635 case llvm::Triple::loongarch64:
1636 AddLoongArchTargetArgs(Args, CmdArgs);
1639 case llvm::Triple::mips:
1640 case llvm::Triple::mipsel:
1641 case llvm::Triple::mips64:
1642 case llvm::Triple::mips64el:
1643 AddMIPSTargetArgs(Args, CmdArgs);
1646 case llvm::Triple::ppc:
1647 case llvm::Triple::ppcle:
1648 case llvm::Triple::ppc64:
1649 case llvm::Triple::ppc64le:
1650 AddPPCTargetArgs(Args, CmdArgs);
1653 case llvm::Triple::riscv32:
1654 case llvm::Triple::riscv64:
1655 AddRISCVTargetArgs(Args, CmdArgs);
1658 case llvm::Triple::sparc:
1659 case llvm::Triple::sparcel:
1660 case llvm::Triple::sparcv9:
1661 AddSparcTargetArgs(Args, CmdArgs);
1664 case llvm::Triple::systemz:
1665 AddSystemZTargetArgs(Args, CmdArgs);
1668 case llvm::Triple::x86:
1669 case llvm::Triple::x86_64:
1670 AddX86TargetArgs(Args, CmdArgs);
1673 case llvm::Triple::lanai:
1674 AddLanaiTargetArgs(Args, CmdArgs);
1677 case llvm::Triple::hexagon:
1678 AddHexagonTargetArgs(Args, CmdArgs);
1681 case llvm::Triple::wasm32:
1682 case llvm::Triple::wasm64:
1683 AddWebAssemblyTargetArgs(Args, CmdArgs);
1686 case llvm::Triple::ve:
1687 AddVETargetArgs(Args, CmdArgs);
1693void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1694 ArgStringList &CmdArgs) {
1695 const char *ABIName =
nullptr;
1696 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1697 ABIName = A->getValue();
1698 else if (Triple.isOSDarwin())
1699 ABIName =
"darwinpcs";
1703 CmdArgs.push_back(
"-target-abi");
1704 CmdArgs.push_back(ABIName);
1708void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1709 ArgStringList &CmdArgs)
const {
1712 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1713 Args.hasArg(options::OPT_mkernel) ||
1714 Args.hasArg(options::OPT_fapple_kext))
1715 CmdArgs.push_back(
"-disable-red-zone");
1717 if (!Args.hasFlag(options::OPT_mimplicit_float,
1718 options::OPT_mno_implicit_float,
true))
1719 CmdArgs.push_back(
"-no-implicit-float");
1721 RenderAArch64ABI(Triple, Args, CmdArgs);
1724 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1725 options::OPT_mno_global_merge)) {
1726 CmdArgs.push_back(
"-mllvm");
1727 if (A->getOption().matches(options::OPT_mno_global_merge))
1728 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1730 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1737 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1738 StringRef Val = A->getValue();
1740 if (Val ==
"128" || Val ==
"256" || Val ==
"512" || Val ==
"1024" ||
1741 Val ==
"2048" || Val ==
"128+" || Val ==
"256+" || Val ==
"512+" ||
1742 Val ==
"1024+" || Val ==
"2048+") {
1744 if (!Val.consume_back(
"+")) {
1746 assert(!
Invalid &&
"Failed to parse value");
1748 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1752 assert(!
Invalid &&
"Failed to parse value");
1754 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1756 }
else if (Val !=
"scalable")
1758 D.
Diag(diag::err_drv_unsupported_option_argument)
1759 << A->getSpelling() << Val;
1764 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1765 CmdArgs.push_back(
"-tune-cpu");
1766 if (strcmp(A->getValue(),
"native") == 0)
1767 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1769 CmdArgs.push_back(A->getValue());
1772 AddUnalignedAccessWarning(CmdArgs);
1774 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
1775 options::OPT_fno_ptrauth_intrinsics);
1776 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_calls,
1777 options::OPT_fno_ptrauth_calls);
1778 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_returns,
1779 options::OPT_fno_ptrauth_returns);
1780 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_auth_traps,
1781 options::OPT_fno_ptrauth_auth_traps);
1783 CmdArgs, options::OPT_fptrauth_vtable_pointer_address_discrimination,
1784 options::OPT_fno_ptrauth_vtable_pointer_address_discrimination);
1786 CmdArgs, options::OPT_fptrauth_vtable_pointer_type_discrimination,
1787 options::OPT_fno_ptrauth_vtable_pointer_type_discrimination);
1788 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_init_fini,
1789 options::OPT_fno_ptrauth_init_fini);
1792void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1793 ArgStringList &CmdArgs)
const {
1796 CmdArgs.push_back(
"-target-abi");
1802 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1803 std::string TuneCPU = A->getValue();
1805 CmdArgs.push_back(
"-tune-cpu");
1806 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1810void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1811 ArgStringList &CmdArgs)
const {
1818 CmdArgs.push_back(
"-target-abi");
1819 CmdArgs.push_back(ABIName.data());
1824 CmdArgs.push_back(
"-msoft-float");
1825 CmdArgs.push_back(
"-mfloat-abi");
1826 CmdArgs.push_back(
"soft");
1830 CmdArgs.push_back(
"-mfloat-abi");
1831 CmdArgs.push_back(
"hard");
1834 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1835 options::OPT_mno_ldc1_sdc1)) {
1836 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1837 CmdArgs.push_back(
"-mllvm");
1838 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1842 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1843 options::OPT_mno_check_zero_division)) {
1844 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1845 CmdArgs.push_back(
"-mllvm");
1846 CmdArgs.push_back(
"-mno-check-zero-division");
1850 if (Args.getLastArg(options::OPT_mfix4300)) {
1851 CmdArgs.push_back(
"-mllvm");
1852 CmdArgs.push_back(
"-mfix4300");
1855 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1856 StringRef
v = A->getValue();
1857 CmdArgs.push_back(
"-mllvm");
1858 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1862 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1864 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1877 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1879 llvm::Reloc::Model RelocationModel;
1882 std::tie(RelocationModel, PICLevel, IsPIE) =
1885 NoABICalls = NoABICalls ||
1886 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1888 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1890 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1891 CmdArgs.push_back(
"-mllvm");
1892 CmdArgs.push_back(
"-mgpopt");
1894 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1895 options::OPT_mno_local_sdata);
1896 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1897 options::OPT_mno_extern_sdata);
1898 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1899 options::OPT_mno_embedded_data);
1901 CmdArgs.push_back(
"-mllvm");
1902 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1903 CmdArgs.push_back(
"-mlocal-sdata=1");
1905 CmdArgs.push_back(
"-mlocal-sdata=0");
1907 LocalSData->claim();
1911 CmdArgs.push_back(
"-mllvm");
1912 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1913 CmdArgs.push_back(
"-mextern-sdata=1");
1915 CmdArgs.push_back(
"-mextern-sdata=0");
1917 ExternSData->claim();
1921 CmdArgs.push_back(
"-mllvm");
1922 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1923 CmdArgs.push_back(
"-membedded-data=1");
1925 CmdArgs.push_back(
"-membedded-data=0");
1927 EmbeddedData->claim();
1930 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1931 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1936 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1937 StringRef Val = StringRef(A->getValue());
1939 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1940 CmdArgs.push_back(
"-mllvm");
1941 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1943 D.
Diag(diag::err_drv_unsupported_option_argument)
1944 << A->getSpelling() << Val;
1946 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1949 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1950 options::OPT_mno_relax_pic_calls)) {
1951 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1952 CmdArgs.push_back(
"-mllvm");
1953 CmdArgs.push_back(
"-mips-jalr-reloc=0");
1958void Clang::AddPPCTargetArgs(
const ArgList &Args,
1959 ArgStringList &CmdArgs)
const {
1962 if (Args.getLastArg(options::OPT_mtune_EQ)) {
1963 CmdArgs.push_back(
"-tune-cpu");
1965 CmdArgs.push_back(Args.MakeArgString(CPU));
1969 const char *ABIName =
nullptr;
1970 if (
T.isOSBinFormatELF()) {
1972 case llvm::Triple::ppc64: {
1973 if (
T.isPPC64ELFv2ABI())
1979 case llvm::Triple::ppc64le:
1988 bool VecExtabi =
false;
1989 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
1990 StringRef
V = A->getValue();
1991 if (
V ==
"ieeelongdouble") {
1992 IEEELongDouble =
true;
1994 }
else if (
V ==
"ibmlongdouble") {
1995 IEEELongDouble =
false;
1997 }
else if (
V ==
"vec-default") {
2000 }
else if (
V ==
"vec-extabi") {
2003 }
else if (
V ==
"elfv1") {
2006 }
else if (
V ==
"elfv2") {
2009 }
else if (
V !=
"altivec")
2013 ABIName = A->getValue();
2016 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2019 D.
Diag(diag::err_drv_unsupported_opt_for_target)
2020 <<
"-mabi=vec-extabi" <<
T.str();
2021 CmdArgs.push_back(
"-mabi=vec-extabi");
2027 CmdArgs.push_back(
"-msoft-float");
2028 CmdArgs.push_back(
"-mfloat-abi");
2029 CmdArgs.push_back(
"soft");
2033 CmdArgs.push_back(
"-mfloat-abi");
2034 CmdArgs.push_back(
"hard");
2038 CmdArgs.push_back(
"-target-abi");
2039 CmdArgs.push_back(ABIName);
2044 ArgStringList &CmdArgs) {
2046 const llvm::Triple &Triple = TC.
getTriple();
2048 const char *SmallDataLimit =
"8";
2050 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2051 options::OPT_fPIC)) {
2053 SmallDataLimit =
"0";
2054 if (Args.hasArg(options::OPT_G)) {
2055 D.
Diag(diag::warn_drv_unsupported_sdata);
2057 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2058 .equals_insensitive(
"large") &&
2059 (Triple.getArch() == llvm::Triple::riscv64)) {
2061 SmallDataLimit =
"0";
2062 if (Args.hasArg(options::OPT_G)) {
2063 D.
Diag(diag::warn_drv_unsupported_sdata);
2065 }
else if (Triple.isAndroid()) {
2067 SmallDataLimit =
"0";
2068 if (Args.hasArg(options::OPT_G)) {
2069 D.
Diag(diag::warn_drv_unsupported_sdata);
2071 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2072 SmallDataLimit = A->getValue();
2075 CmdArgs.push_back(
"-msmall-data-limit");
2076 CmdArgs.push_back(SmallDataLimit);
2079void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2080 ArgStringList &CmdArgs)
const {
2084 CmdArgs.push_back(
"-target-abi");
2085 CmdArgs.push_back(ABIName.data());
2089 if (!Args.hasFlag(options::OPT_mimplicit_float,
2090 options::OPT_mno_implicit_float,
true))
2091 CmdArgs.push_back(
"-no-implicit-float");
2093 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2094 CmdArgs.push_back(
"-tune-cpu");
2095 if (strcmp(A->getValue(),
"native") == 0)
2096 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2098 CmdArgs.push_back(A->getValue());
2102 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2103 StringRef Val = A->getValue();
2107 unsigned MinVLen = 0;
2109 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
2112 if (!errorToBool(ISAInfo.takeError()))
2113 MinVLen = (*ISAInfo)->getMinVLen();
2118 if (Val ==
"zvl" && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
2120 }
else if (!Val.getAsInteger(10, Bits)) {
2123 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
2124 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
2130 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
2132 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
2134 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
2135 }
else if (Val !=
"scalable") {
2137 D.
Diag(diag::err_drv_unsupported_option_argument)
2138 << A->getSpelling() << Val;
2143void Clang::AddSparcTargetArgs(
const ArgList &Args,
2144 ArgStringList &CmdArgs)
const {
2150 CmdArgs.push_back(
"-msoft-float");
2151 CmdArgs.push_back(
"-mfloat-abi");
2152 CmdArgs.push_back(
"soft");
2156 CmdArgs.push_back(
"-mfloat-abi");
2157 CmdArgs.push_back(
"hard");
2160 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2161 StringRef Name = A->getValue();
2162 std::string TuneCPU;
2163 if (Name ==
"native")
2164 TuneCPU = std::string(llvm::sys::getHostCPUName());
2166 TuneCPU = std::string(Name);
2168 CmdArgs.push_back(
"-tune-cpu");
2169 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2173void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2174 ArgStringList &CmdArgs)
const {
2175 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2176 CmdArgs.push_back(
"-tune-cpu");
2177 if (strcmp(A->getValue(),
"native") == 0)
2178 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2180 CmdArgs.push_back(A->getValue());
2184 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2185 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2186 options::OPT_mno_packed_stack,
false);
2190 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2192 D.
Diag(diag::err_drv_unsupported_opt)
2193 <<
"-mpacked-stack -mbackchain -mhard-float";
2196 CmdArgs.push_back(
"-mbackchain");
2198 CmdArgs.push_back(
"-mpacked-stack");
2201 CmdArgs.push_back(
"-msoft-float");
2202 CmdArgs.push_back(
"-mfloat-abi");
2203 CmdArgs.push_back(
"soft");
2207void Clang::AddX86TargetArgs(
const ArgList &Args,
2208 ArgStringList &CmdArgs)
const {
2212 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2213 Args.hasArg(options::OPT_mkernel) ||
2214 Args.hasArg(options::OPT_fapple_kext))
2215 CmdArgs.push_back(
"-disable-red-zone");
2217 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2218 options::OPT_mno_tls_direct_seg_refs,
true))
2219 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2223 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2224 Args.hasArg(options::OPT_fapple_kext));
2225 if (Arg *A = Args.getLastArg(
2226 options::OPT_msoft_float, options::OPT_mno_soft_float,
2227 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2228 const Option &O = A->getOption();
2229 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2230 O.matches(options::OPT_msoft_float));
2232 if (NoImplicitFloat)
2233 CmdArgs.push_back(
"-no-implicit-float");
2235 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2236 StringRef
Value = A->getValue();
2238 CmdArgs.push_back(
"-mllvm");
2239 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2240 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2242 D.
Diag(diag::err_drv_unsupported_option_argument)
2243 << A->getSpelling() <<
Value;
2246 CmdArgs.push_back(
"-mllvm");
2247 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2250 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2251 options::OPT_mno_skip_rax_setup))
2252 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2253 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2256 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2257 CmdArgs.push_back(
"-mfloat-abi");
2258 CmdArgs.push_back(
"soft");
2259 CmdArgs.push_back(
"-mstack-alignment=4");
2265 std::string TuneCPU;
2266 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2268 TuneCPU =
"generic";
2271 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2272 StringRef Name = A->getValue();
2274 if (Name ==
"native") {
2275 Name = llvm::sys::getHostCPUName();
2277 TuneCPU = std::string(Name);
2279 TuneCPU = std::string(Name);
2282 if (!TuneCPU.empty()) {
2283 CmdArgs.push_back(
"-tune-cpu");
2284 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2288void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2289 ArgStringList &CmdArgs)
const {
2290 CmdArgs.push_back(
"-mqdsp6-compat");
2291 CmdArgs.push_back(
"-Wreturn-type");
2294 CmdArgs.push_back(
"-mllvm");
2296 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2299 if (!Args.hasArg(options::OPT_fno_short_enums))
2300 CmdArgs.push_back(
"-fshort-enums");
2301 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2302 CmdArgs.push_back(
"-mllvm");
2303 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2305 CmdArgs.push_back(
"-mllvm");
2306 CmdArgs.push_back(
"-machine-sink-split=0");
2309void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2310 ArgStringList &CmdArgs)
const {
2311 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2312 StringRef CPUName = A->getValue();
2314 CmdArgs.push_back(
"-target-cpu");
2315 CmdArgs.push_back(Args.MakeArgString(CPUName));
2317 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2318 StringRef
Value = A->getValue();
2322 if (
Value.getAsInteger(10, Mregparm)) {
2323 if (Mregparm != 4) {
2325 diag::err_drv_unsupported_option_argument)
2326 << A->getSpelling() <<
Value;
2332void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2333 ArgStringList &CmdArgs)
const {
2335 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2336 options::OPT_fvisibility_ms_compat))
2337 CmdArgs.push_back(
"-fvisibility=hidden");
2340void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2342 CmdArgs.push_back(
"-mfloat-abi");
2343 CmdArgs.push_back(
"hard");
2348 const InputInfo &Input,
const ArgList &Args)
const {
2350 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2353 using llvm::yaml::escape;
2356 if (!CompilationDatabase) {
2358 auto File = std::make_unique<llvm::raw_fd_ostream>(
2360 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2362 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2366 CompilationDatabase = std::move(
File);
2368 auto &CDB = *CompilationDatabase;
2369 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2372 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2373 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2375 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2380 CDB <<
", \"" << escape(Buf) <<
"\"";
2381 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2384 CDB <<
", \"" << escape(Buf) <<
"\"";
2386 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2388 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2389 for (
auto &A: Args) {
2390 auto &O = A->getOption();
2392 if (O.getID() == options::OPT_x)
2395 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2397 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2400 if (O.getKind() == Option::InputClass)
2403 if (O.getID() == options::OPT_o)
2407 A->render(Args, ASL);
2409 CDB <<
", \"" << escape(it) <<
"\"";
2413 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2416void Clang::DumpCompilationDatabaseFragmentToDir(
2418 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2420 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2423 if (CompilationDatabase)
2424 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2427 const auto &
Driver =
C.getDriver();
2429 auto Err = llvm::sys::fs::create_directory(Path,
true);
2431 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2435 llvm::sys::path::append(
2437 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2440 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2441 llvm::sys::fs::OF_Text);
2443 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2446 CompilationDatabase =
2447 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2448 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2458 CmdArgs.push_back(
"-mllvm");
2459 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2463 const ArgList &Args,
2464 ArgStringList &CmdArgs,
2474 Args.addOptInFlag(CmdArgs, options::OPT_mrelax_all,
2475 options::OPT_mno_relax_all);
2479 bool DefaultIncrementalLinkerCompatible =
2480 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2481 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2482 options::OPT_mno_incremental_linker_compatible,
2483 DefaultIncrementalLinkerCompatible))
2484 CmdArgs.push_back(
"-mincremental-linker-compatible");
2486 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2488 Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2489 options::OPT_fno_emit_compact_unwind_non_canonical);
2499 bool TakeNextArg =
false;
2501 bool UseRelaxRelocations =
C.getDefaultToolChain().useRelaxRelocations();
2502 bool UseNoExecStack =
false;
2503 const char *MipsTargetFeature =
nullptr;
2504 StringRef ImplicitIt;
2506 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2507 options::OPT_mimplicit_it_EQ)) {
2510 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2511 switch (
C.getDefaultToolChain().getArch()) {
2512 case llvm::Triple::arm:
2513 case llvm::Triple::armeb:
2514 case llvm::Triple::thumb:
2515 case llvm::Triple::thumbeb:
2517 ImplicitIt = A->getValue();
2519 D.
Diag(diag::err_drv_unsupported_option_argument)
2520 << A->getSpelling() << ImplicitIt;
2527 for (StringRef
Value : A->getValues()) {
2529 CmdArgs.push_back(
Value.data());
2530 TakeNextArg =
false;
2534 if (
C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2535 Value ==
"-mbig-obj")
2538 switch (
C.getDefaultToolChain().getArch()) {
2541 case llvm::Triple::wasm32:
2542 case llvm::Triple::wasm64:
2543 if (
Value ==
"--no-type-check") {
2544 CmdArgs.push_back(
"-mno-type-check");
2548 case llvm::Triple::thumb:
2549 case llvm::Triple::thumbeb:
2550 case llvm::Triple::arm:
2551 case llvm::Triple::armeb:
2552 if (
Value.starts_with(
"-mimplicit-it=")) {
2554 ImplicitIt =
Value.split(
"=").second;
2558 if (
Value ==
"-mthumb")
2563 case llvm::Triple::mips:
2564 case llvm::Triple::mipsel:
2565 case llvm::Triple::mips64:
2566 case llvm::Triple::mips64el:
2567 if (
Value ==
"--trap") {
2568 CmdArgs.push_back(
"-target-feature");
2569 CmdArgs.push_back(
"+use-tcc-in-div");
2572 if (
Value ==
"--break") {
2573 CmdArgs.push_back(
"-target-feature");
2574 CmdArgs.push_back(
"-use-tcc-in-div");
2577 if (
Value.starts_with(
"-msoft-float")) {
2578 CmdArgs.push_back(
"-target-feature");
2579 CmdArgs.push_back(
"+soft-float");
2582 if (
Value.starts_with(
"-mhard-float")) {
2583 CmdArgs.push_back(
"-target-feature");
2584 CmdArgs.push_back(
"-soft-float");
2588 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2589 .Case(
"-mips1",
"+mips1")
2590 .Case(
"-mips2",
"+mips2")
2591 .Case(
"-mips3",
"+mips3")
2592 .Case(
"-mips4",
"+mips4")
2593 .Case(
"-mips5",
"+mips5")
2594 .Case(
"-mips32",
"+mips32")
2595 .Case(
"-mips32r2",
"+mips32r2")
2596 .Case(
"-mips32r3",
"+mips32r3")
2597 .Case(
"-mips32r5",
"+mips32r5")
2598 .Case(
"-mips32r6",
"+mips32r6")
2599 .Case(
"-mips64",
"+mips64")
2600 .Case(
"-mips64r2",
"+mips64r2")
2601 .Case(
"-mips64r3",
"+mips64r3")
2602 .Case(
"-mips64r5",
"+mips64r5")
2603 .Case(
"-mips64r6",
"+mips64r6")
2605 if (MipsTargetFeature)
2609 if (
Value ==
"-force_cpusubtype_ALL") {
2611 }
else if (
Value ==
"-L") {
2612 CmdArgs.push_back(
"-msave-temp-labels");
2613 }
else if (
Value ==
"--fatal-warnings") {
2614 CmdArgs.push_back(
"-massembler-fatal-warnings");
2615 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2616 CmdArgs.push_back(
"-massembler-no-warn");
2617 }
else if (
Value ==
"--noexecstack") {
2618 UseNoExecStack =
true;
2619 }
else if (
Value.starts_with(
"-compress-debug-sections") ||
2620 Value.starts_with(
"--compress-debug-sections") ||
2621 Value ==
"-nocompress-debug-sections" ||
2622 Value ==
"--nocompress-debug-sections") {
2623 CmdArgs.push_back(
Value.data());
2624 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2625 Value ==
"--mrelax-relocations=yes") {
2626 UseRelaxRelocations =
true;
2627 }
else if (
Value ==
"-mrelax-relocations=no" ||
2628 Value ==
"--mrelax-relocations=no") {
2629 UseRelaxRelocations =
false;
2630 }
else if (
Value.starts_with(
"-I")) {
2631 CmdArgs.push_back(
Value.data());
2636 }
else if (
Value.starts_with(
"-gdwarf-")) {
2639 if (DwarfVersion == 0) {
2640 CmdArgs.push_back(
Value.data());
2643 llvm::codegenoptions::DebugInfoConstructor,
2644 DwarfVersion, llvm::DebuggerKind::Default);
2646 }
else if (
Value.starts_with(
"-mcpu") ||
Value.starts_with(
"-mfpu") ||
2647 Value.starts_with(
"-mhwdiv") ||
Value.starts_with(
"-march")) {
2649 }
else if (
Value ==
"-defsym") {
2650 if (A->getNumValues() != 2) {
2651 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2654 const char *S = A->getValue(1);
2655 auto Pair = StringRef(S).split(
'=');
2656 auto Sym = Pair.first;
2657 auto SVal = Pair.second;
2659 if (Sym.empty() || SVal.empty()) {
2660 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2664 if (SVal.getAsInteger(0, IVal)) {
2665 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2668 CmdArgs.push_back(
Value.data());
2670 }
else if (
Value ==
"-fdebug-compilation-dir") {
2671 CmdArgs.push_back(
"-fdebug-compilation-dir");
2673 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2677 CmdArgs.push_back(
"-fdebug-compilation-dir");
2678 CmdArgs.push_back(
Value.data());
2679 }
else if (
Value ==
"--version") {
2682 D.
Diag(diag::err_drv_unsupported_option_argument)
2683 << A->getSpelling() <<
Value;
2687 if (ImplicitIt.size())
2689 if (!UseRelaxRelocations)
2690 CmdArgs.push_back(
"-mrelax-relocations=no");
2692 CmdArgs.push_back(
"-mnoexecstack");
2693 if (MipsTargetFeature !=
nullptr) {
2694 CmdArgs.push_back(
"-target-feature");
2695 CmdArgs.push_back(MipsTargetFeature);
2699 if (
C.getDriver().embedBitcodeEnabled() ||
2700 C.getDriver().embedBitcodeMarkerOnly())
2701 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2703 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2704 CmdArgs.push_back(
"-as-secure-log-file");
2705 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2736 if ((str1.compare(str2) != 0) && !str2.empty() && !str1.empty()) {
2737 D.
Diag(clang::diag::warn_drv_overriding_option) << str1 << str2;
2744 if (!ComplexRangeStr.empty())
2745 return "-complex-range=" + ComplexRangeStr;
2746 return ComplexRangeStr;
2750 bool OFastEnabled,
const ArgList &Args,
2751 ArgStringList &CmdArgs,
2758 bool HonorINFs =
true;
2759 bool HonorNaNs =
true;
2760 bool ApproxFunc =
false;
2763 bool AssociativeMath =
false;
2764 bool ReciprocalMath =
false;
2765 bool SignedZeros =
true;
2766 bool TrappingMath =
false;
2767 bool TrappingMathPresent =
false;
2769 bool RoundingFPMath =
false;
2771 StringRef FPModel =
"";
2773 StringRef FPExceptionBehavior =
"";
2775 StringRef FPEvalMethod =
"";
2776 llvm::DenormalMode DenormalFPMath =
2778 llvm::DenormalMode DenormalFP32Math =
2783 StringRef FPContract;
2784 StringRef LastSeenFfpContractOption;
2785 bool SeenUnsafeMathModeOption =
false;
2789 bool StrictFPModel =
false;
2790 StringRef Float16ExcessPrecision =
"";
2791 StringRef BFloat16ExcessPrecision =
"";
2793 std::string ComplexRangeStr =
"";
2794 std::string GccRangeComplexOption =
"";
2797 auto applyFastMath = [&]() {
2801 AssociativeMath =
true;
2802 ReciprocalMath =
true;
2804 SignedZeros =
false;
2805 TrappingMath =
false;
2806 RoundingFPMath =
false;
2807 FPExceptionBehavior =
"";
2809 FPContract =
"fast";
2819 !GccRangeComplexOption.empty()
2820 ? GccRangeComplexOption
2823 SeenUnsafeMathModeOption =
true;
2826 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2827 CmdArgs.push_back(
"-mlimit-float-precision");
2828 CmdArgs.push_back(A->getValue());
2831 for (
const Arg *A : Args) {
2832 switch (A->getOption().getID()) {
2836 case options::OPT_fcx_limited_range:
2837 if (GccRangeComplexOption.empty()) {
2840 "-fcx-limited-range");
2842 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
2845 GccRangeComplexOption =
"-fcx-limited-range";
2848 case options::OPT_fno_cx_limited_range:
2849 if (GccRangeComplexOption.empty()) {
2851 "-fno-cx-limited-range");
2853 if (GccRangeComplexOption.compare(
"-fcx-limited-range") != 0 &&
2854 GccRangeComplexOption.compare(
"-fno-cx-fortran-rules") != 0)
2856 "-fno-cx-limited-range");
2858 GccRangeComplexOption =
"-fno-cx-limited-range";
2861 case options::OPT_fcx_fortran_rules:
2862 if (GccRangeComplexOption.empty())
2864 "-fcx-fortran-rules");
2867 GccRangeComplexOption =
"-fcx-fortran-rules";
2870 case options::OPT_fno_cx_fortran_rules:
2871 if (GccRangeComplexOption.empty()) {
2873 "-fno-cx-fortran-rules");
2875 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
2877 "-fno-cx-fortran-rules");
2879 GccRangeComplexOption =
"-fno-cx-fortran-rules";
2882 case options::OPT_fcomplex_arithmetic_EQ: {
2884 StringRef Val = A->getValue();
2887 else if (Val ==
"improved")
2889 else if (Val ==
"promoted")
2891 else if (Val ==
"basic")
2894 D.
Diag(diag::err_drv_unsupported_option_argument)
2895 << A->getSpelling() << Val;
2898 if (!GccRangeComplexOption.empty()) {
2899 if (GccRangeComplexOption.compare(
"-fcx-limited-range") != 0) {
2900 if (GccRangeComplexOption.compare(
"-fcx-fortran-rules") != 0) {
2917 case options::OPT_ffp_model_EQ: {
2924 AssociativeMath =
false;
2925 ReciprocalMath =
false;
2929 StringRef Val = A->getValue();
2930 if (OFastEnabled && Val !=
"fast") {
2932 D.
Diag(clang::diag::warn_drv_overriding_option)
2933 << Args.MakeArgString(
"-ffp-model=" + Val) <<
"-Ofast";
2936 StrictFPModel =
false;
2937 if (!FPModel.empty() && FPModel != Val)
2938 D.
Diag(clang::diag::warn_drv_overriding_option)
2939 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2940 << Args.MakeArgString(
"-ffp-model=" + Val);
2941 if (Val ==
"fast") {
2944 }
else if (Val ==
"precise") {
2947 }
else if (Val ==
"strict") {
2948 StrictFPModel =
true;
2949 FPExceptionBehavior =
"strict";
2952 TrappingMath =
true;
2953 RoundingFPMath =
true;
2955 D.
Diag(diag::err_drv_unsupported_option_argument)
2956 << A->getSpelling() << Val;
2961 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2962 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2963 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2964 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2965 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2966 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2967 case options::OPT_fmath_errno: MathErrno =
true;
break;
2968 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2969 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2970 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2971 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2972 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2973 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2974 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2975 case options::OPT_ftrapping_math:
2976 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2977 FPExceptionBehavior !=
"strict")
2979 D.
Diag(clang::diag::warn_drv_overriding_option)
2980 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2981 FPExceptionBehavior)
2982 <<
"-ftrapping-math";
2983 TrappingMath =
true;
2984 TrappingMathPresent =
true;
2985 FPExceptionBehavior =
"strict";
2987 case options::OPT_fno_trapping_math:
2988 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2989 FPExceptionBehavior !=
"ignore")
2991 D.
Diag(clang::diag::warn_drv_overriding_option)
2992 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2993 FPExceptionBehavior)
2994 <<
"-fno-trapping-math";
2995 TrappingMath =
false;
2996 TrappingMathPresent =
true;
2997 FPExceptionBehavior =
"ignore";
3000 case options::OPT_frounding_math:
3001 RoundingFPMath =
true;
3004 case options::OPT_fno_rounding_math:
3005 RoundingFPMath =
false;
3008 case options::OPT_fdenormal_fp_math_EQ:
3009 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
3010 DenormalFP32Math = DenormalFPMath;
3011 if (!DenormalFPMath.isValid()) {
3012 D.
Diag(diag::err_drv_invalid_value)
3013 << A->getAsString(Args) << A->getValue();
3017 case options::OPT_fdenormal_fp_math_f32_EQ:
3018 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
3019 if (!DenormalFP32Math.isValid()) {
3020 D.
Diag(diag::err_drv_invalid_value)
3021 << A->getAsString(Args) << A->getValue();
3026 case options::OPT_ffp_contract: {
3027 StringRef Val = A->getValue();
3028 if (Val ==
"fast" || Val ==
"on" || Val ==
"off" ||
3029 Val ==
"fast-honor-pragmas") {
3031 LastSeenFfpContractOption = Val;
3033 D.
Diag(diag::err_drv_unsupported_option_argument)
3034 << A->getSpelling() << Val;
3039 case options::OPT_ffp_exception_behavior_EQ: {
3040 StringRef Val = A->getValue();
3041 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
3042 FPExceptionBehavior != Val)
3044 D.
Diag(clang::diag::warn_drv_overriding_option)
3045 << Args.MakeArgString(
"-ffp-exception-behavior=" +
3046 FPExceptionBehavior)
3047 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
3048 TrappingMath = TrappingMathPresent =
false;
3049 if (Val ==
"ignore" || Val ==
"maytrap")
3050 FPExceptionBehavior = Val;
3051 else if (Val ==
"strict") {
3052 FPExceptionBehavior = Val;
3053 TrappingMath = TrappingMathPresent =
true;
3055 D.
Diag(diag::err_drv_unsupported_option_argument)
3056 << A->getSpelling() << Val;
3061 case options::OPT_ffp_eval_method_EQ: {
3062 StringRef Val = A->getValue();
3063 if (Val ==
"double" || Val ==
"extended" || Val ==
"source")
3066 D.
Diag(diag::err_drv_unsupported_option_argument)
3067 << A->getSpelling() << Val;
3071 case options::OPT_fexcess_precision_EQ: {
3072 StringRef Val = A->getValue();
3073 const llvm::Triple::ArchType Arch = TC.
getArch();
3074 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
3075 if (Val ==
"standard" || Val ==
"fast")
3076 Float16ExcessPrecision = Val;
3080 else if (Val ==
"16")
3081 Float16ExcessPrecision =
"none";
3083 D.
Diag(diag::err_drv_unsupported_option_argument)
3084 << A->getSpelling() << Val;
3086 if (!(Val ==
"standard" || Val ==
"fast"))
3087 D.
Diag(diag::err_drv_unsupported_option_argument)
3088 << A->getSpelling() << Val;
3090 BFloat16ExcessPrecision = Float16ExcessPrecision;
3093 case options::OPT_ffinite_math_only:
3097 case options::OPT_fno_finite_math_only:
3102 case options::OPT_funsafe_math_optimizations:
3103 AssociativeMath =
true;
3104 ReciprocalMath =
true;
3105 SignedZeros =
false;
3107 TrappingMath =
false;
3108 FPExceptionBehavior =
"";
3109 FPContract =
"fast";
3110 SeenUnsafeMathModeOption =
true;
3112 case options::OPT_fno_unsafe_math_optimizations:
3113 AssociativeMath =
false;
3114 ReciprocalMath =
false;
3120 if (LastSeenFfpContractOption !=
"") {
3121 FPContract = LastSeenFfpContractOption;
3122 }
else if (SeenUnsafeMathModeOption)
3127 case options::OPT_Ofast:
3132 case options::OPT_ffast_math: {
3136 case options::OPT_fno_fast_math:
3143 AssociativeMath =
false;
3144 ReciprocalMath =
false;
3150 if (LastSeenFfpContractOption !=
"") {
3151 FPContract = LastSeenFfpContractOption;
3152 }
else if (SeenUnsafeMathModeOption)
3163 if (StrictFPModel) {
3166 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3167 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3168 FPContract ==
"off")
3172 StrictFPModel =
false;
3174 auto RHS = (A->getNumValues() == 0)
3176 : Args.MakeArgString(A->getSpelling() + A->getValue());
3177 if (RHS !=
"-ffp-model=strict")
3178 D.
Diag(clang::diag::warn_drv_overriding_option)
3179 <<
"-ffp-model=strict" << RHS;
3188 CmdArgs.push_back(
"-menable-no-infs");
3191 CmdArgs.push_back(
"-menable-no-nans");
3194 CmdArgs.push_back(
"-fapprox-func");
3197 CmdArgs.push_back(
"-fmath-errno");
3199 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3201 CmdArgs.push_back(
"-funsafe-math-optimizations");
3204 CmdArgs.push_back(
"-fno-signed-zeros");
3206 if (AssociativeMath && !SignedZeros && !TrappingMath)
3207 CmdArgs.push_back(
"-mreassociate");
3210 CmdArgs.push_back(
"-freciprocal-math");
3214 assert(FPExceptionBehavior ==
"strict");
3218 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3220 llvm::raw_svector_ostream ArgStr(DenormFlag);
3221 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3222 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3226 if (DenormalFP32Math != DenormalFPMath) {
3228 llvm::raw_svector_ostream ArgStr(DenormFlag);
3229 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3230 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3233 if (!FPContract.empty())
3234 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3237 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3239 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3241 if (!FPExceptionBehavior.empty())
3242 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3243 FPExceptionBehavior));
3245 if (!FPEvalMethod.empty())
3246 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3248 if (!Float16ExcessPrecision.empty())
3249 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3250 Float16ExcessPrecision));
3251 if (!BFloat16ExcessPrecision.empty())
3252 CmdArgs.push_back(Args.MakeArgString(
"-fbfloat16-excess-precision=" +
3253 BFloat16ExcessPrecision));
3260 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3261 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3262 CmdArgs.push_back(
"-ffast-math");
3263 if (FPModel ==
"fast") {
3264 if (FPContract ==
"fast")
3267 else if (FPContract.empty())
3269 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3271 D.
Diag(clang::diag::warn_drv_overriding_option)
3272 <<
"-ffp-model=fast"
3273 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3278 if (!HonorINFs && !HonorNaNs)
3279 CmdArgs.push_back(
"-ffinite-math-only");
3281 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3282 CmdArgs.push_back(
"-mfpmath");
3283 CmdArgs.push_back(A->getValue());
3287 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3288 options::OPT_fstrict_float_cast_overflow,
false))
3289 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3293 if (!ComplexRangeStr.empty()) {
3294 CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
3295 if (Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))
3296 CmdArgs.push_back(Args.MakeArgString(
"-fcomplex-arithmetic=" +
3299 if (Args.hasArg(options::OPT_fcx_limited_range))
3300 CmdArgs.push_back(
"-fcx-limited-range");
3301 if (Args.hasArg(options::OPT_fcx_fortran_rules))
3302 CmdArgs.push_back(
"-fcx-fortran-rules");
3303 if (Args.hasArg(options::OPT_fno_cx_limited_range))
3304 CmdArgs.push_back(
"-fno-cx-limited-range");
3305 if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
3306 CmdArgs.push_back(
"-fno-cx-fortran-rules");
3310 const llvm::Triple &Triple,
3313 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3314 CmdArgs.push_back(
"-analyzer-checker=core");
3315 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3317 if (!Triple.isWindowsMSVCEnvironment()) {
3318 CmdArgs.push_back(
"-analyzer-checker=unix");
3321 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3322 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3323 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3324 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3325 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3326 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3330 if (Triple.isPS()) {
3331 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3332 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3335 if (Triple.isOSDarwin()) {
3336 CmdArgs.push_back(
"-analyzer-checker=osx");
3338 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3340 else if (Triple.isOSFuchsia())
3341 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3343 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3346 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3348 if (!Triple.isPS()) {
3349 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3350 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3351 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3352 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3353 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3354 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3358 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3359 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3363 CmdArgs.push_back(
"-analyzer-output");
3364 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3365 CmdArgs.push_back(A->getValue());
3367 CmdArgs.push_back(
"plist");
3372 CmdArgs.push_back(
"-w");
3375 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3382 if (std::isdigit(S[0]))
3385 return llvm::all_of(S, [](
char C) {
return std::isalnum(
C) ||
C ==
'_'; });
3389 const ArgList &Args, ArgStringList &CmdArgs,
3390 bool KernelOrKext) {
3395 if (EffectiveTriple.isNVPTX())
3403 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3404 options::OPT_fstack_protector_all,
3405 options::OPT_fstack_protector_strong,
3406 options::OPT_fstack_protector)) {
3407 if (A->getOption().matches(options::OPT_fstack_protector))
3408 StackProtectorLevel =
3410 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3412 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3416 D.
Diag(diag::warn_drv_unsupported_option_for_target)
3417 << A->getSpelling() << EffectiveTriple.getTriple();
3418 StackProtectorLevel = DefaultStackProtectorLevel;
3421 StackProtectorLevel = DefaultStackProtectorLevel;
3424 if (StackProtectorLevel) {
3425 CmdArgs.push_back(
"-stack-protector");
3426 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3430 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3431 StringRef Str(A->getValue());
3432 if (Str.starts_with(
"ssp-buffer-size=")) {
3433 if (StackProtectorLevel) {
3434 CmdArgs.push_back(
"-stack-protector-buffer-size");
3436 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3442 const std::string &TripleStr = EffectiveTriple.getTriple();
3443 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3444 StringRef
Value = A->getValue();
3445 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3446 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3447 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3448 << A->getAsString(Args) << TripleStr;
3449 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3450 EffectiveTriple.isThumb()) &&
3452 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3453 << A->getOption().getName() <<
Value <<
"tls global";
3456 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3458 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3459 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3460 << A->getAsString(Args);
3465 D.
Diag(diag::err_target_unsupported_tp_hard)
3466 << EffectiveTriple.getArchName();
3470 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3471 StringRef
Value = A->getValue();
3472 if (
Value !=
"cp15") {
3473 D.
Diag(diag::err_drv_argument_not_allowed_with)
3474 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3478 CmdArgs.push_back(
"-target-feature");
3479 CmdArgs.push_back(
"+read-tp-tpidruro");
3481 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3482 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3483 << A->getOption().getName() <<
Value <<
"sysreg global";
3486 A->render(Args, CmdArgs);
3489 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3490 StringRef
Value = A->getValue();
3491 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3492 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3493 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3494 << A->getAsString(Args) << TripleStr;
3496 if (
Value.getAsInteger(10, Offset)) {
3497 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3500 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3501 (Offset < 0 || Offset > 0xfffff)) {
3502 D.
Diag(diag::err_drv_invalid_int_value)
3503 << A->getOption().getName() <<
Value;
3506 A->render(Args, CmdArgs);
3509 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3510 StringRef
Value = A->getValue();
3511 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3512 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3513 << A->getAsString(Args) << TripleStr;
3514 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3515 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3516 << A->getOption().getName() <<
Value <<
"fs gs";
3519 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3520 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3523 A->render(Args, CmdArgs);
3526 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3527 StringRef
Value = A->getValue();
3529 D.
Diag(diag::err_drv_argument_only_allowed_with)
3530 << A->getOption().getName() <<
"legal symbol name";
3533 A->render(Args, CmdArgs);
3538 ArgStringList &CmdArgs) {
3541 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3544 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3545 !EffectiveTriple.isPPC64() && !EffectiveTriple.isAArch64())
3548 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3549 options::OPT_fno_stack_clash_protection);
3554 const ArgList &Args,
3555 ArgStringList &CmdArgs) {
3557 StringRef TrivialAutoVarInit =
"";
3559 for (
const Arg *A : Args) {
3560 switch (A->getOption().getID()) {
3563 case options::OPT_ftrivial_auto_var_init: {
3565 StringRef Val = A->getValue();
3566 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3567 TrivialAutoVarInit = Val;
3569 D.
Diag(diag::err_drv_unsupported_option_argument)
3570 << A->getSpelling() << Val;
3576 if (TrivialAutoVarInit.empty())
3577 switch (DefaultTrivialAutoVarInit) {
3581 TrivialAutoVarInit =
"pattern";
3584 TrivialAutoVarInit =
"zero";
3588 if (!TrivialAutoVarInit.empty()) {
3590 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3594 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3595 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3597 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3599 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3601 StringRef Val = A->getValue();
3602 if (std::stoi(Val.str()) <= 0)
3603 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3605 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3608 if (Arg *A = Args.getLastArg(options::OPT_ftrivial_auto_var_init_max_size)) {
3609 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3611 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3613 D.
Diag(diag::err_drv_trivial_auto_var_init_max_size_missing_dependency);
3615 StringRef Val = A->getValue();
3616 if (std::stoi(Val.str()) <= 0)
3617 D.
Diag(diag::err_drv_trivial_auto_var_init_max_size_invalid_value);
3619 Args.MakeArgString(
"-ftrivial-auto-var-init-max-size=" + Val));
3627 const unsigned ForwardedArguments[] = {
3628 options::OPT_cl_opt_disable,
3629 options::OPT_cl_strict_aliasing,
3630 options::OPT_cl_single_precision_constant,
3631 options::OPT_cl_finite_math_only,
3632 options::OPT_cl_kernel_arg_info,
3633 options::OPT_cl_unsafe_math_optimizations,
3634 options::OPT_cl_fast_relaxed_math,
3635 options::OPT_cl_mad_enable,
3636 options::OPT_cl_no_signed_zeros,
3637 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3638 options::OPT_cl_uniform_work_group_size
3641 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3642 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3643 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3644 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3645 std::string CLExtStr = std::string(
"-cl-ext=") + A->getValue();
3646 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3649 for (
const auto &Arg : ForwardedArguments)
3650 if (
const auto *A = Args.getLastArg(Arg))
3651 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3656 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3657 CmdArgs.push_back(
"-finclude-default-header");
3658 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3664 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3669 options::OPT_emit_llvm,
3670 options::OPT_emit_obj,
3671 options::OPT_disable_llvm_passes,
3672 options::OPT_fnative_half_type,
3673 options::OPT_hlsl_entrypoint};
3676 for (
const auto &Arg : ForwardedArguments)
3677 if (
const auto *A = Args.getLastArg(Arg))
3678 A->renderAsInput(Args, CmdArgs);
3680 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3681 !Args.hasArg(options::OPT_nostdinc))
3682 CmdArgs.push_back(
"-finclude-default-header");
3686 ArgStringList &CmdArgs,
types::ID InputType) {
3687 if (!Args.hasArg(options::OPT_fopenacc))
3690 CmdArgs.push_back(
"-fopenacc");
3692 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override)) {
3693 StringRef
Value = A->getValue();
3695 if (!
Value.getAsInteger(10, Version))
3696 A->renderAsInput(Args, CmdArgs);
3698 D.
Diag(diag::err_drv_clang_unsupported) <<
Value;
3703 ArgStringList &CmdArgs) {
3704 bool ARCMTEnabled =
false;
3705 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3706 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3707 options::OPT_ccc_arcmt_modify,
3708 options::OPT_ccc_arcmt_migrate)) {
3709 ARCMTEnabled =
true;
3710 switch (A->getOption().getID()) {
3711 default: llvm_unreachable(
"missed a case");
3712 case options::OPT_ccc_arcmt_check:
3713 CmdArgs.push_back(
"-arcmt-action=check");
3715 case options::OPT_ccc_arcmt_modify:
3716 CmdArgs.push_back(
"-arcmt-action=modify");
3718 case options::OPT_ccc_arcmt_migrate:
3719 CmdArgs.push_back(
"-arcmt-action=migrate");
3720 CmdArgs.push_back(
"-mt-migrate-directory");
3721 CmdArgs.push_back(A->getValue());
3723 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3724 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3729 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3730 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3731 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3734 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3736 D.
Diag(diag::err_drv_argument_not_allowed_with)
3737 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3739 CmdArgs.push_back(
"-mt-migrate-directory");
3740 CmdArgs.push_back(A->getValue());
3742 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3743 options::OPT_objcmt_migrate_subscripting,
3744 options::OPT_objcmt_migrate_property)) {
3746 CmdArgs.push_back(
"-objcmt-migrate-literals");
3747 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3748 CmdArgs.push_back(
"-objcmt-migrate-property");
3750 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3751 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3752 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3755 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3756 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3757 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3758 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3759 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3760 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3761 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3762 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3763 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3764 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3765 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3766 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3767 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3768 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3769 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3770 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3775 const ArgList &Args, ArgStringList &CmdArgs) {
3778 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3779 !Args.hasArg(options::OPT_mkernel));
3781 CmdArgs.push_back(
"-fno-builtin");
3784 if (Args.hasArg(options::OPT_ffreestanding))
3785 UseBuiltins =
false;
3788 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3794 A->render(Args, CmdArgs);
3800 if (TC.
getArch() == llvm::Triple::le32)
3801 CmdArgs.push_back(
"-fno-math-builtin");
3805 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
3808 return Path.getSingleStringRef() !=
"";
3810 if (llvm::sys::path::cache_directory(
Result)) {
3811 llvm::sys::path::append(
Result,
"clang");
3812 llvm::sys::path::append(
Result,
"ModuleCache");
3820 const char *BaseInput) {
3821 if (Arg *ModuleOutputEQ = Args.getLastArg(options::OPT_fmodule_output_EQ))
3822 return StringRef(ModuleOutputEQ->getValue());
3825 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o);
3826 FinalOutput && Args.hasArg(options::OPT_c))
3827 OutputPath = FinalOutput->getValue();
3829 OutputPath = BaseInput;
3832 llvm::sys::path::replace_extension(OutputPath, Extension);
3837 const ArgList &Args,
const InputInfo &Input,
3838 const InputInfo &Output,
bool HaveStd20,
3839 ArgStringList &CmdArgs) {
3841 bool HaveStdCXXModules = IsCXX && HaveStd20;
3842 bool HaveModules = HaveStdCXXModules;
3847 bool HaveClangModules =
false;
3848 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3849 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3850 options::OPT_fno_cxx_modules,
true);
3851 if (AllowedInCXX || !IsCXX) {
3852 CmdArgs.push_back(
"-fmodules");
3853 HaveClangModules =
true;
3857 HaveModules |= HaveClangModules;
3861 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3862 options::OPT_fno_implicit_module_maps, HaveClangModules))
3863 CmdArgs.push_back(
"-fimplicit-module-maps");
3866 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3867 options::OPT_fno_modules_decluse);
3871 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3872 options::OPT_fno_modules_strict_decluse,
false))
3873 CmdArgs.push_back(
"-fmodules-strict-decluse");
3876 bool ImplicitModules =
false;
3877 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3878 options::OPT_fno_implicit_modules, HaveClangModules)) {
3880 CmdArgs.push_back(
"-fno-implicit-modules");
3881 }
else if (HaveModules) {
3882 ImplicitModules =
true;
3886 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3887 Path = A->getValue();
3889 bool HasPath =
true;
3890 if (
C.isForDiagnostics()) {
3894 llvm::sys::path::replace_extension(Path,
".cache");
3895 llvm::sys::path::append(Path,
"modules");
3896 }
else if (Path.empty()) {
3904 const char Arg[] =
"-fmodules-cache-path=";
3905 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3906 CmdArgs.push_back(Args.MakeArgString(Path));
3911 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3912 options::OPT_fno_prebuilt_implicit_modules,
false))
3913 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3914 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3915 options::OPT_fno_modules_validate_input_files_content,
3917 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3922 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3926 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3930 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3932 llvm::sys::path::append(BuiltinModuleMap,
"include");
3933 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3934 if (llvm::sys::fs::exists(BuiltinModuleMap))
3936 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3943 if (HaveModules || Input.
getType() == clang::driver::types::TY_ModuleFile) {
3944 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3947 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3948 CmdArgs.push_back(Args.MakeArgString(
3949 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3953 Args.ClaimAllArgs(options::OPT_fmodule_file);
3957 if (HaveClangModules &&
C.isForDiagnostics()) {
3959 llvm::sys::path::replace_extension(VFSDir,
".cache");
3961 C.addTempFile(Args.MakeArgString(VFSDir));
3963 llvm::sys::path::append(VFSDir,
"vfs");
3964 CmdArgs.push_back(
"-module-dependency-dir");
3965 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3968 if (HaveClangModules)
3969 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3972 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3973 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3974 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3976 if (HaveClangModules) {
3977 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3979 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3980 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3981 D.
Diag(diag::err_drv_argument_not_allowed_with)
3982 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3984 llvm::sys::fs::file_status Status;
3985 if (llvm::sys::fs::status(A->getValue(), Status))
3986 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3987 CmdArgs.push_back(Args.MakeArgString(
3988 "-fbuild-session-timestamp=" +
3989 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3990 Status.getLastModificationTime().time_since_epoch())
3994 if (Args.getLastArg(
3995 options::OPT_fmodules_validate_once_per_build_session)) {
3996 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3997 options::OPT_fbuild_session_file))
3998 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4000 Args.AddLastArg(CmdArgs,
4001 options::OPT_fmodules_validate_once_per_build_session);
4004 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
4005 options::OPT_fno_modules_validate_system_headers,
4007 CmdArgs.push_back(
"-fmodules-validate-system-headers");
4009 Args.AddLastArg(CmdArgs,
4010 options::OPT_fmodules_disable_diagnostic_validation);
4012 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
4013 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
4014 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
4015 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
4016 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
4017 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
4022 CmdArgs.push_back(
"-fskip-odr-check-in-gmf");
4024 if (Args.hasArg(options::OPT_modules_reduced_bmi) &&
4025 (Input.
getType() == driver::types::TY_CXXModule ||
4026 Input.
getType() == driver::types::TY_PP_CXXModule)) {
4027 CmdArgs.push_back(
"-fexperimental-modules-reduced-bmi");
4029 if (Args.hasArg(options::OPT_fmodule_output_EQ))
4030 Args.AddLastArg(CmdArgs, options::OPT_fmodule_output_EQ);
4032 CmdArgs.push_back(Args.MakeArgString(
4033 "-fmodule-output=" +
4040 Args.ClaimAllArgs(options::OPT_modules_reduced_bmi);
4048 if (Input.
getType() == driver::types::TY_CXXModule ||
4049 Input.
getType() == driver::types::TY_PP_CXXModule ||
4050 Input.
getType() == driver::types::TY_ModuleFile) {
4051 Args.ClaimAllArgs(options::OPT_fmodule_output);
4052 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
4059 ArgStringList &CmdArgs) {
4061 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
4062 options::OPT_fno_signed_char,
4063 options::OPT_funsigned_char,
4064 options::OPT_fno_unsigned_char)) {
4065 if (A->getOption().matches(options::OPT_funsigned_char) ||
4066 A->getOption().matches(options::OPT_fno_signed_char)) {
4067 CmdArgs.push_back(
"-fno-signed-char");
4070 CmdArgs.push_back(
"-fno-signed-char");
4074 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
4076 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4077 options::OPT_fno_short_wchar)) {
4078 if (A->getOption().matches(options::OPT_fshort_wchar)) {
4079 CmdArgs.push_back(
"-fwchar-type=short");
4080 CmdArgs.push_back(
"-fno-signed-wchar");
4082 bool IsARM =
T.isARM() ||
T.isThumb() ||
T.isAArch64();
4083 CmdArgs.push_back(
"-fwchar-type=int");
4085 (IsARM && !(
T.isOSWindows() ||
T.isOSNetBSD() ||
T.isOSOpenBSD())))
4086 CmdArgs.push_back(
"-fno-signed-wchar");
4088 CmdArgs.push_back(
"-fsigned-wchar");
4090 }
else if (
T.isOSzOS())
4091 CmdArgs.push_back(
"-fno-signed-wchar");
4095 const llvm::Triple &
T,
const ArgList &Args,
4097 const InputInfo &Input, ArgStringList &CmdArgs) {
4098 const llvm::Triple::ArchType Arch = TC.
getArch();
4104 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4105 options::OPT_fno_objc_legacy_dispatch,
4108 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
4110 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
4116 if (Arch == llvm::Triple::x86 &&
T.isMacOSX() &&
4118 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
4125 CmdArgs.push_back(
"-fobjc-arc");
4132 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
4134 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
4139 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4140 options::OPT_fno_objc_arc_exceptions,
4142 CmdArgs.push_back(
"-fobjc-arc-exceptions");
4147 if (Args.hasArg(options::OPT_fno_objc_arc)) {
4148 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4149 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4155 auto *Arg = Args.getLastArg(
4156 options::OPT_fobjc_convert_messages_to_runtime_calls,
4157 options::OPT_fno_objc_convert_messages_to_runtime_calls);
4159 Arg->getOption().matches(
4160 options::OPT_fno_objc_convert_messages_to_runtime_calls))
4161 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
4166 if (InferCovariantReturns)
4167 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4172 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4176 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4177 D.
Diag(diag::err_objc_weak_unsupported);
4179 WeakArg->render(Args, CmdArgs);
4183 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4184 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
4188 ArgStringList &CmdArgs) {
4189 bool CaretDefault =
true;
4190 bool ColumnDefault =
true;
4192 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4193 options::OPT__SLASH_diagnostics_column,
4194 options::OPT__SLASH_diagnostics_caret)) {
4195 switch (A->getOption().getID()) {
4196 case options::OPT__SLASH_diagnostics_caret:
4197 CaretDefault =
true;
4198 ColumnDefault =
true;
4200 case options::OPT__SLASH_diagnostics_column:
4201 CaretDefault =
false;
4202 ColumnDefault =
true;
4204 case options::OPT__SLASH_diagnostics_classic:
4205 CaretDefault =
false;
4206 ColumnDefault =
false;
4212 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4213 options::OPT_fno_caret_diagnostics, CaretDefault))
4214 CmdArgs.push_back(
"-fno-caret-diagnostics");
4216 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4217 options::OPT_fno_diagnostics_fixit_info);
4218 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4219 options::OPT_fno_diagnostics_show_option);
4222 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4223 CmdArgs.push_back(
"-fdiagnostics-show-category");
4224 CmdArgs.push_back(A->getValue());
4227 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4228 options::OPT_fno_diagnostics_show_hotness);
4231 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4233 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4234 CmdArgs.push_back(Args.MakeArgString(Opt));
4238 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4240 std::string(
"-fdiagnostics-misexpect-tolerance=") + A->getValue();
4241 CmdArgs.push_back(Args.MakeArgString(Opt));
4244 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4245 CmdArgs.push_back(
"-fdiagnostics-format");
4246 CmdArgs.push_back(A->getValue());
4247 if (StringRef(A->getValue()) ==
"sarif" ||
4248 StringRef(A->getValue()) ==
"SARIF")
4249 D.
Diag(diag::warn_drv_sarif_format_unstable);
4252 if (
const Arg *A = Args.getLastArg(
4253 options::OPT_fdiagnostics_show_note_include_stack,
4254 options::OPT_fno_diagnostics_show_note_include_stack)) {
4255 const Option &O = A->getOption();
4256 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4257 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4259 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4266 Args.getLastArg(options::OPT_fcolor_diagnostics,
4267 options::OPT_fno_color_diagnostics);
4268 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4269 StringRef
Value(A->getValue());
4271 D.
Diag(diag::err_drv_invalid_argument_to_option)
4272 <<
Value << A->getOption().getName();
4276 CmdArgs.push_back(
"-fcolor-diagnostics");
4278 if (Args.hasArg(options::OPT_fansi_escape_codes))
4279 CmdArgs.push_back(
"-fansi-escape-codes");
4281 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4282 options::OPT_fno_show_source_location);
4284 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4285 options::OPT_fno_diagnostics_show_line_numbers);
4287 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4288 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4290 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4292 CmdArgs.push_back(
"-fno-show-column");
4294 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4295 options::OPT_fno_spell_checking);
4299 const ArgList &Args, Arg *&Arg) {
4300 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4301 options::OPT_gno_split_dwarf);
4302 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4305 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4308 StringRef
Value = Arg->getValue();
4309 if (
Value ==
"split")
4311 if (
Value ==
"single")
4314 D.
Diag(diag::err_drv_unsupported_option_argument)
4315 << Arg->getSpelling() << Arg->getValue();
4320 const ArgList &Args, ArgStringList &CmdArgs,
4321 unsigned DwarfVersion) {
4322 auto *DwarfFormatArg =
4323 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4324 if (!DwarfFormatArg)
4327 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4328 if (DwarfVersion < 3)
4329 D.
Diag(diag::err_drv_argument_only_allowed_with)
4330 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4331 else if (!
T.isArch64Bit())
4332 D.
Diag(diag::err_drv_argument_only_allowed_with)
4333 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4334 else if (!
T.isOSBinFormatELF())
4335 D.
Diag(diag::err_drv_argument_only_allowed_with)
4336 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4339 DwarfFormatArg->render(Args, CmdArgs);
4344 const ArgList &Args,
bool IRInput, ArgStringList &CmdArgs,
4346 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
4348 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4349 options::OPT_fno_debug_info_for_profiling,
false) &&
4351 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4352 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4365 bool SplitDWARFInlining =
4366 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4367 options::OPT_fno_split_dwarf_inlining,
false);
4372 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4378 SplitDWARFInlining =
false;
4381 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4382 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4386 A->getOption().matches(options::OPT_gN_Group)) {
4392 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
4393 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
4394 (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
4395 SplitDWARFInlining))
4401 bool HasDebuggerTuning =
false;
4403 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4404 HasDebuggerTuning =
true;
4406 if (A->getOption().matches(options::OPT_glldb))
4407 DebuggerTuning = llvm::DebuggerKind::LLDB;
4408 else if (A->getOption().matches(options::OPT_gsce))
4409 DebuggerTuning = llvm::DebuggerKind::SCE;
4410 else if (A->getOption().matches(options::OPT_gdbx))
4411 DebuggerTuning = llvm::DebuggerKind::DBX;
4413 DebuggerTuning = llvm::DebuggerKind::GDB;
4418 bool EmitDwarf =
false;
4422 bool EmitCodeView =
false;
4423 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4428 if (!EmitCodeView && !EmitDwarf &&
4429 DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
4431 case llvm::codegenoptions::DIF_CodeView:
4432 EmitCodeView =
true;
4434 case llvm::codegenoptions::DIF_DWARF:
4440 unsigned RequestedDWARFVersion = 0;
4441 unsigned EffectiveDWARFVersion = 0;
4446 EffectiveDWARFVersion =
4449 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4453 if (RequestedDWARFVersion == 0 &&
4454 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
4455 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
4459 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4461 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4462 DebuggerTuning == llvm::DebuggerKind::DBX))
4463 CmdArgs.push_back(
"-gstrict-dwarf");
4466 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4474 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4476 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4478 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4479 DebuggerTuning != llvm::DebuggerKind::DBX)))
4480 CmdArgs.push_back(
"-gno-column-info");
4483 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4488 if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
4489 DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
4490 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4491 CmdArgs.push_back(
"-dwarf-ext-refs");
4492 CmdArgs.push_back(
"-fmodule-format=obj");
4497 if (
T.isOSBinFormatELF() && SplitDWARFInlining)
4498 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4505 bool NeedFullDebug = Args.hasFlag(
4506 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4507 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4509 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4512 if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
4513 DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
4514 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4515 options::OPT_feliminate_unused_debug_types,
false))
4516 DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
4517 else if (NeedFullDebug)
4518 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
4521 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4527 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4528 if (RequestedDWARFVersion < 5)
4529 D.
Diag(diag::err_drv_argument_only_allowed_with)
4530 << A->getAsString(Args) <<
"-gdwarf-5";
4531 else if (EffectiveDWARFVersion < 5)
4534 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4536 << EffectiveDWARFVersion;
4538 CmdArgs.push_back(
"-gembed-source");
4542 CmdArgs.push_back(
"-gcodeview");
4544 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4545 options::OPT_gno_codeview_ghash);
4547 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4548 options::OPT_gno_codeview_command_line);
4551 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4552 options::OPT_gno_inline_line_tables);
4556 DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
4557 DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
4565 T.isOSAIX() && !HasDebuggerTuning
4566 ? llvm::DebuggerKind::Default
4570 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4574 CmdArgs.push_back(
"-debug-info-macro");
4577 const auto *PubnamesArg =
4578 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4579 options::OPT_gpubnames, options::OPT_gno_pubnames);
4582 const bool OptionSet =
4584 (PubnamesArg->getOption().matches(options::OPT_gpubnames) ||
4585 PubnamesArg->getOption().matches(options::OPT_ggnu_pubnames)));
4586 if ((DebuggerTuning != llvm::DebuggerKind::LLDB || OptionSet) &&
4588 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4589 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames))))
4590 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4591 options::OPT_gpubnames)
4593 :
"-ggnu-pubnames");
4595 const auto *SimpleTemplateNamesArg =
4596 Args.getLastArg(options::OPT_gsimple_template_names,
4597 options::OPT_gno_simple_template_names);
4598 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4599 if (SimpleTemplateNamesArg &&
4601 const auto &Opt = SimpleTemplateNamesArg->getOption();
4602 if (Opt.matches(options::OPT_gsimple_template_names)) {
4603 ForwardTemplateParams =
true;
4604 CmdArgs.push_back(
"-gsimple-template-names=simple");
4609 bool UseDebugTemplateAlias =
4610 DebuggerTuning == llvm::DebuggerKind::SCE && RequestedDWARFVersion >= 4;
4611 if (
const auto *DebugTemplateAlias = Args.getLastArg(
4612 options::OPT_gtemplate_alias, options::OPT_gno_template_alias)) {
4616 const auto &Opt = DebugTemplateAlias->getOption();
4617 UseDebugTemplateAlias = Opt.matches(options::OPT_gtemplate_alias);
4620 if (UseDebugTemplateAlias)
4621 CmdArgs.push_back(
"-gtemplate-alias");
4623 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4624 StringRef
v = A->getValue();
4625 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4628 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4629 options::OPT_fno_debug_ranges_base_address);
4634 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4635 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4638 CmdArgs.push_back(
"-mllvm");
4639 CmdArgs.push_back(
"-generate-arange-section");
4642 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4643 options::OPT_fno_force_dwarf_frame);
4645 if (Args.hasFlag(options::OPT_fdebug_types_section,
4646 options::OPT_fno_debug_types_section,
false)) {
4647 if (!(
T.isOSBinFormatELF() ||
T.isOSBinFormatWasm())) {
4648 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4649 << Args.getLastArg(options::OPT_fdebug_types_section)
4653 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4655 CmdArgs.push_back(
"-mllvm");
4656 CmdArgs.push_back(
"-generate-type-units");
4663 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4664 options::OPT_fno_dwarf_directory_asm,
4666 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4670 if (ForwardTemplateParams)
4671 CmdArgs.push_back(
"-debug-forward-template-params");
4675 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4676 CmdArgs.push_back(
"-dwarf-explicit-import");
4682 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
4684 if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
4685 CmdArgs.push_back(
"-fjmc");
4687 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"/JMC"
4690 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
4693 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
4698 const char *DebugCompilationDir =
4710 ArgStringList &CmdArgs) {
4711 unsigned RTOptionID = options::OPT__SLASH_MT;
4713 if (Args.hasArg(options::OPT__SLASH_LDd))
4716 RTOptionID = options::OPT__SLASH_MTd;
4718 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4719 RTOptionID = A->getOption().getID();
4721 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4722 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4723 .Case(
"static", options::OPT__SLASH_MT)
4724 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4725 .Case(
"dll", options::OPT__SLASH_MD)
4726 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4727 .Default(options::OPT__SLASH_MT);
4730 StringRef FlagForCRT;
4731 switch (RTOptionID) {
4732 case options::OPT__SLASH_MD:
4733 if (Args.hasArg(options::OPT__SLASH_LDd))
4734 CmdArgs.push_back(
"-D_DEBUG");
4735 CmdArgs.push_back(
"-D_MT");
4736 CmdArgs.push_back(
"-D_DLL");
4737 FlagForCRT =
"--dependent-lib=msvcrt";
4739 case options::OPT__SLASH_MDd:
4740 CmdArgs.push_back(
"-D_DEBUG");
4741 CmdArgs.push_back(
"-D_MT");
4742 CmdArgs.push_back(
"-D_DLL");
4743 FlagForCRT =
"--dependent-lib=msvcrtd";
4745 case options::OPT__SLASH_MT:
4746 if (Args.hasArg(options::OPT__SLASH_LDd))
4747 CmdArgs.push_back(
"-D_DEBUG");
4748 CmdArgs.push_back(
"-D_MT");
4749 CmdArgs.push_back(
"-flto-visibility-public-std");
4750 FlagForCRT =
"--dependent-lib=libcmt";
4752 case options::OPT__SLASH_MTd:
4753 CmdArgs.push_back(
"-D_DEBUG");
4754 CmdArgs.push_back(
"-D_MT");
4755 CmdArgs.push_back(
"-flto-visibility-public-std");
4756 FlagForCRT =
"--dependent-lib=libcmtd";
4759 llvm_unreachable(
"Unexpected option ID.");
4762 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4763 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4765 CmdArgs.push_back(FlagForCRT.data());
4770 CmdArgs.push_back(
"--dependent-lib=oldnames");
4777 CmdArgs.push_back(
"--dependent-lib=softintrin");
4782 const ArgList &Args,
const char *LinkingOutput)
const {
4784 const llvm::Triple &RawTriple = TC.
getTriple();
4786 const std::string &TripleStr = Triple.getTriple();
4789 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4791 ArgStringList CmdArgs;
4793 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4805 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4808 bool IsHostOffloadingAction =
4811 Args.hasFlag(options::OPT_offload_new_driver,
4812 options::OPT_no_offload_new_driver,
false));
4815 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4816 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4817 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4821 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4825 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4829 const InputInfo *CudaDeviceInput =
nullptr;
4830 const InputInfo *OpenMPDeviceInput =
nullptr;
4832 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4834 }
else if (IsExtractAPI) {
4835 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4836 if (I.getType() != ExpectedInputType) {
4837 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4841 ExtractAPIInputs.push_back(I);
4842 }
else if (IsHostOffloadingAction) {
4843 HostOffloadingInputs.push_back(I);
4844 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4845 CudaDeviceInput = &I;
4846 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4847 OpenMPDeviceInput = &I;
4849 llvm_unreachable(
"unexpectedly given multiple inputs");
4853 const llvm::Triple *AuxTriple =
4855 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4856 bool IsIAMCU = RawTriple.isOSIAMCU();
4861 if (IsCuda || IsHIP)
4862 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4866 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4871 CmdArgs.push_back(
"-cc1");
4874 CmdArgs.push_back(
"-triple");
4875 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4877 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4878 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4879 Args.ClaimAllArgs(options::OPT_MJ);
4880 }
else if (
const Arg *GenCDBFragment =
4881 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4882 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4883 TripleStr, Output, Input, Args);
4884 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4887 if (IsCuda || IsHIP) {
4890 std::string NormalizedTriple;
4908 assert(CTC &&
"Expected valid CUDA Toolchain.");
4910 CmdArgs.push_back(Args.MakeArgString(
4911 Twine(
"-target-sdk-version=") +
4919 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4922 CmdArgs.push_back(
"-aux-triple");
4923 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4928 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4929 CmdArgs.push_back(Args.MakeArgString(
4931 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4934 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4940 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
4943 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4944 CmdArgs.push_back(
"-fsycl-is-device");
4946 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4947 A->render(Args, CmdArgs);
4950 CmdArgs.push_back(
"-sycl-std=2020");
4954 if (IsOpenMPDevice) {
4956 std::string NormalizedTriple =
4960 CmdArgs.push_back(
"-aux-triple");
4961 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4964 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4965 Triple.getArch() == llvm::Triple::thumb)) {
4966 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4967 unsigned Version = 0;
4969 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
4970 if (Failure || Version < 7)
4971 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4981 if (Triple.isSPIR() || Triple.isSPIRV())
4982 CmdArgs.push_back(
"-Wspir-compat");
4985 RewriteKind rewriteKind = RK_None;
4987 bool UnifiedLTO =
false;
4989 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
4990 options::OPT_fno_unified_lto, Triple.isPS());
4992 CmdArgs.push_back(
"-funified-lto");
5002 if (!isa<AssembleJobAction>(JA)) {
5006 Args.ClaimAllArgs(options::OPT_mrelax_all);
5007 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5008 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5009 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5010 switch (
C.getDefaultToolChain().getArch()) {
5011 case llvm::Triple::arm:
5012 case llvm::Triple::armeb:
5013 case llvm::Triple::thumb:
5014 case llvm::Triple::thumbeb:
5015 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5021 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5022 Args.ClaimAllArgs(options::OPT_Xassembler);
5023 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5026 if (isa<AnalyzeJobAction>(JA)) {
5027 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5028 CmdArgs.push_back(
"-analyze");
5029 }
else if (isa<MigrateJobAction>(JA)) {
5030 CmdArgs.push_back(
"-migrate");
5031 }
else if (isa<PreprocessJobAction>(JA)) {
5032 if (Output.
getType() == types::TY_Dependencies)
5033 CmdArgs.push_back(
"-Eonly");
5035 CmdArgs.push_back(
"-E");
5036 if (Args.hasArg(options::OPT_rewrite_objc) &&
5037 !Args.hasArg(options::OPT_g_Group))
5038 CmdArgs.push_back(
"-P");
5039 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5040 CmdArgs.push_back(
"-fdirectives-only");
5042 }
else if (isa<AssembleJobAction>(JA)) {
5043 CmdArgs.push_back(
"-emit-obj");
5048 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5049 }
else if (isa<PrecompileJobAction>(JA)) {
5050 if (JA.
getType() == types::TY_Nothing)
5051 CmdArgs.push_back(
"-fsyntax-only");
5052 else if (JA.
getType() == types::TY_ModuleFile)
5053 CmdArgs.push_back(
"-emit-module-interface");
5054 else if (JA.
getType() == types::TY_HeaderUnit)
5055 CmdArgs.push_back(
"-emit-header-unit");
5057 CmdArgs.push_back(
"-emit-pch");
5058 }
else if (isa<VerifyPCHJobAction>(JA)) {
5059 CmdArgs.push_back(
"-verify-pch");
5060 }
else if (isa<ExtractAPIJobAction>(JA)) {
5061 assert(JA.
getType() == types::TY_API_INFO &&
5062 "Extract API actions must generate a API information.");
5063 CmdArgs.push_back(
"-extract-api");
5065 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5066 PrettySGFArg->render(Args, CmdArgs);
5068 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5070 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5071 ProductNameArg->render(Args, CmdArgs);
5072 if (Arg *ExtractAPIIgnoresFileArg =
5073 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5074 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5075 if (Arg *EmitExtensionSymbolGraphs =
5076 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5077 if (!SymbolGraphDirArg)
5078 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5080 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5082 if (SymbolGraphDirArg)
5083 SymbolGraphDirArg->render(Args, CmdArgs);
5085 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
5086 "Invalid action for clang tool.");
5087 if (JA.
getType() == types::TY_Nothing) {
5088 CmdArgs.push_back(
"-fsyntax-only");
5089 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5090 JA.
getType() == types::TY_LTO_IR) {
5091 CmdArgs.push_back(
"-emit-llvm");
5092 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5093 JA.
getType() == types::TY_LTO_BC) {
5095 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5096 Args.hasArg(options::OPT_emit_llvm)) {
5097 CmdArgs.push_back(
"-emit-llvm");
5099 CmdArgs.push_back(
"-emit-llvm-bc");
5101 }
else if (JA.
getType() == types::TY_IFS ||
5102 JA.
getType() == types::TY_IFS_CPP) {
5104 Args.hasArg(options::OPT_interface_stub_version_EQ)
5105 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5107 CmdArgs.push_back(
"-emit-interface-stubs");
5109 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5110 }
else if (JA.
getType() == types::TY_PP_Asm) {
5111 CmdArgs.push_back(
"-S");
5112 }
else if (JA.
getType() == types::TY_AST) {
5113 CmdArgs.push_back(
"-emit-pch");
5114 }
else if (JA.
getType() == types::TY_ModuleFile) {
5115 CmdArgs.push_back(
"-module-file-info");
5116 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5117 CmdArgs.push_back(
"-rewrite-objc");
5118 rewriteKind = RK_NonFragile;
5119 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5120 CmdArgs.push_back(
"-rewrite-objc");
5121 rewriteKind = RK_Fragile;
5123 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5130 if (JA.
getType() == types::TY_LLVM_BC)
5131 CmdArgs.push_back(
"-emit-llvm-uselists");
5135 !Args.hasFlag(options::OPT_offload_new_driver,
5136 options::OPT_no_offload_new_driver,
false) &&
5137 !Triple.isAMDGPU()) {
5138 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5139 << Args.getLastArg(options::OPT_foffload_lto,
5140 options::OPT_foffload_lto_EQ)
5142 << Triple.getTriple();
5143 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5145 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5146 << Args.getLastArg(options::OPT_foffload_lto,
5147 options::OPT_foffload_lto_EQ)
5152 CmdArgs.push_back(Args.MakeArgString(
5153 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5156 if (!RawTriple.isPS4() ||
5158 CmdArgs.push_back(
"-flto-unit");
5163 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5165 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5167 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5168 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5172 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5173 options::OPT_mno_regnames);
5175 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5176 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5178 if (Args.getLastArg(options::OPT_save_temps_EQ))
5179 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5181 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5182 options::OPT_fmemory_profile_EQ,
5183 options::OPT_fno_memory_profile);
5185 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5186 MemProfArg->render(Args, CmdArgs);
5188 if (
auto *MemProfUseArg =
5189 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5191 D.
Diag(diag::err_drv_argument_not_allowed_with)
5192 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5193 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5194 options::OPT_fprofile_generate_EQ))
5195 D.
Diag(diag::err_drv_argument_not_allowed_with)
5196 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5197 MemProfUseArg->render(Args, CmdArgs);
5202 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5203 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
5205 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5207 CmdArgs.push_back(
"-disable-llvm-passes");
5214 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5215 options::OPT_mkernel,
5216 options::OPT_fapple_kext,
5217 options::OPT_ffunction_sections,
5218 options::OPT_fno_function_sections,
5219 options::OPT_fdata_sections,
5220 options::OPT_fno_data_sections,
5221 options::OPT_fbasic_block_sections_EQ,
5222 options::OPT_funique_internal_linkage_names,
5223 options::OPT_fno_unique_internal_linkage_names,
5224 options::OPT_funique_section_names,
5225 options::OPT_fno_unique_section_names,
5226 options::OPT_funique_basic_block_section_names,
5227 options::OPT_fno_unique_basic_block_section_names,
5228 options::OPT_mrestrict_it,
5229 options::OPT_mno_restrict_it,
5230 options::OPT_mstackrealign,
5231 options::OPT_mno_stackrealign,
5232 options::OPT_mstack_alignment,
5233 options::OPT_mcmodel_EQ,
5234 options::OPT_mlong_calls,
5235 options::OPT_mno_long_calls,
5236 options::OPT_ggnu_pubnames,
5237 options::OPT_gdwarf_aranges,
5238 options::OPT_fdebug_types_section,
5239 options::OPT_fno_debug_types_section,
5240 options::OPT_fdwarf_directory_asm,
5241 options::OPT_fno_dwarf_directory_asm,
5242 options::OPT_mrelax_all,
5243 options::OPT_mno_relax_all,
5244 options::OPT_ftrap_function_EQ,
5245 options::OPT_ffixed_r9,
5246 options::OPT_mfix_cortex_a53_835769,
5247 options::OPT_mno_fix_cortex_a53_835769,
5248 options::OPT_ffixed_x18,
5249 options::OPT_mglobal_merge,
5250 options::OPT_mno_global_merge,
5251 options::OPT_mred_zone,
5252 options::OPT_mno_red_zone,
5253 options::OPT_Wa_COMMA,
5254 options::OPT_Xassembler,
5257 for (
const auto &A : Args)
5258 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5259 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5262 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5263 options::OPT_fno_optimize_sibling_calls);
5271 case llvm::Triple::arm:
5272 case llvm::Triple::armeb:
5273 case llvm::Triple::thumbeb:
5274 RenderARMABI(D, Triple, Args, CmdArgs);
5276 case llvm::Triple::aarch64:
5277 case llvm::Triple::aarch64_32:
5278 case llvm::Triple::aarch64_be:
5279 RenderAArch64ABI(Triple, Args, CmdArgs);
5284 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5285 if (A->getOption().matches(options::OPT_O4)) {
5286 CmdArgs.push_back(
"-O3");
5287 D.
Diag(diag::warn_O4_is_O3);
5289 A->render(Args, CmdArgs);
5294 if (Output.
getType() == types::TY_Dependencies) {
5297 CmdArgs.push_back(
"-o");
5300 assert(Output.
isNothing() &&
"Input output.");
5303 for (
const auto &II : Inputs) {
5305 if (II.isFilename())
5306 CmdArgs.push_back(II.getFilename());
5308 II.getInputArg().renderAsInput(Args, CmdArgs);
5311 C.addCommand(std::make_unique<Command>(
5317 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5318 CmdArgs.push_back(
"-fembed-bitcode=marker");
5323 if (!
C.isForDiagnostics())
5324 CmdArgs.push_back(
"-disable-free");
5325 CmdArgs.push_back(
"-clear-ast-before-backend");
5328 const bool IsAssertBuild =
false;
5330 const bool IsAssertBuild =
true;
5334 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5335 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5336 CmdArgs.push_back(
"-disable-llvm-verifier");
5340 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5341 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5342 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5344 return types::isLLVMIR(II.getType());
5346 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5348 CmdArgs.push_back(
"-discard-value-names");
5353 CmdArgs.push_back(
"-main-file-name");
5358 if (Args.hasArg(options::OPT_static))
5359 CmdArgs.push_back(
"-static-define");
5361 if (Args.hasArg(options::OPT_municode))
5362 CmdArgs.push_back(
"-DUNICODE");
5364 if (isa<AnalyzeJobAction>(JA))
5367 if (isa<AnalyzeJobAction>(JA) ||
5368 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5369 CmdArgs.push_back(
"-setup-static-analyzer");
5374 bool FoundAnalyzerConfig =
false;
5375 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5376 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5377 FoundAnalyzerConfig =
true;
5380 if (!FoundAnalyzerConfig)
5381 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5382 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5383 FoundAnalyzerConfig =
true;
5386 if (FoundAnalyzerConfig)
5387 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5392 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5393 if (FunctionAlignment) {
5394 CmdArgs.push_back(
"-function-alignment");
5395 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5400 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5402 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5404 << A->getAsString(Args) << A->getValue();
5406 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5407 << A->getAsString(Args) << A->getValue();
5410 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5411 Twine(std::min(
Value, 65536u))));
5414 if (Triple.isOSzOS()) {
5423 auto findMacroDefinition = [&](
const std::string &Macro) {
5424 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5425 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5426 return M == Macro || M.find(Macro +
'=') != std::string::npos;
5431 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5432 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5434 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5435 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5438 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5439 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5443 llvm::Reloc::Model RelocationModel;
5446 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5447 Arg *LastPICDataRelArg =
5448 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5449 options::OPT_mpic_data_is_text_relative);
5450 bool NoPICDataIsTextRelative =
false;
5451 if (LastPICDataRelArg) {
5452 if (LastPICDataRelArg->getOption().matches(
5453 options::OPT_mno_pic_data_is_text_relative)) {
5454 NoPICDataIsTextRelative =
true;
5456 D.
Diag(diag::err_drv_argument_only_allowed_with)
5457 <<
"-mno-pic-data-is-text-relative"
5460 if (!Triple.isSystemZ())
5461 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5462 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5463 :
"-mpic-data-is-text-relative")
5467 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5468 RelocationModel == llvm::Reloc::ROPI_RWPI;
5469 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5470 RelocationModel == llvm::Reloc::ROPI_RWPI;
5472 if (Args.hasArg(options::OPT_mcmse) &&
5473 !Args.hasArg(options::OPT_fallow_unsupported)) {
5475 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5477 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5481 !Args.hasArg(options::OPT_fallow_unsupported))
5482 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5486 CmdArgs.push_back(
"-mrelocation-model");
5487 CmdArgs.push_back(RMName);
5490 CmdArgs.push_back(
"-pic-level");
5491 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5493 CmdArgs.push_back(
"-pic-is-pie");
5494 if (NoPICDataIsTextRelative)
5495 CmdArgs.push_back(
"-mcmodel=medium");
5498 if (RelocationModel == llvm::Reloc::ROPI ||
5499 RelocationModel == llvm::Reloc::ROPI_RWPI)
5500 CmdArgs.push_back(
"-fropi");
5501 if (RelocationModel == llvm::Reloc::RWPI ||
5502 RelocationModel == llvm::Reloc::ROPI_RWPI)
5503 CmdArgs.push_back(
"-frwpi");
5505 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5506 CmdArgs.push_back(
"-meabi");
5507 CmdArgs.push_back(A->getValue());
5521 if (Triple.isOSBinFormatELF()) {
5522 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5523 options::OPT_fno_semantic_interposition);
5524 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5526 bool SupportsLocalAlias =
5527 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5529 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5530 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5531 A->render(Args, CmdArgs);
5532 else if (!SupportsLocalAlias)
5533 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5539 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5541 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5542 << A->getValue() << A->getAsString(Args);
5543 Model = A->getValue();
5546 if (Model !=
"posix") {
5547 CmdArgs.push_back(
"-mthread-model");
5548 CmdArgs.push_back(Args.MakeArgString(Model));
5552 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5553 StringRef Name = A->getValue();
5554 if (Name ==
"SVML") {
5555 if (Triple.getArch() != llvm::Triple::x86 &&
5556 Triple.getArch() != llvm::Triple::x86_64)
5557 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5558 << Name << Triple.getArchName();
5559 }
else if (Name ==
"LIBMVEC-X86") {
5560 if (Triple.getArch() != llvm::Triple::x86 &&
5561 Triple.getArch() != llvm::Triple::x86_64)
5562 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5563 << Name << Triple.getArchName();
5564 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5565 if (Triple.getArch() != llvm::Triple::aarch64 &&
5566 Triple.getArch() != llvm::Triple::aarch64_be)
5567 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5568 << Name << Triple.getArchName();
5570 A->render(Args, CmdArgs);
5573 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5574 options::OPT_fno_merge_all_constants,
false))
5575 CmdArgs.push_back(
"-fmerge-all-constants");
5577 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5578 options::OPT_fno_delete_null_pointer_checks);
5582 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5583 if (!Triple.isOSAIX() || Triple.isPPC32())
5584 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5585 << A->getSpelling() << RawTriple.str();
5586 CmdArgs.push_back(
"-mabi=quadword-atomics");
5589 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5592 if (Triple.isOSAIX())
5593 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5594 << A->getSpelling() << RawTriple.str();
5597 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5598 StringRef
V = A->getValue(), V1 =
V;
5600 if (V1.consumeInteger(10, Size) || !V1.empty())
5601 D.
Diag(diag::err_drv_invalid_argument_to_option)
5602 <<
V << A->getOption().getName();
5604 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5607 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5608 options::OPT_fno_jump_tables);
5609 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5610 options::OPT_fno_profile_sample_accurate);
5611 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5612 options::OPT_fno_preserve_as_comments);
5614 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5615 CmdArgs.push_back(
"-mregparm");
5616 CmdArgs.push_back(A->getValue());
5619 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5620 options::OPT_msvr4_struct_return)) {
5622 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5623 << A->getSpelling() << RawTriple.str();
5624 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5625 CmdArgs.push_back(
"-maix-struct-return");
5627 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5628 CmdArgs.push_back(
"-msvr4-struct-return");
5632 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5633 options::OPT_freg_struct_return)) {
5634 if (TC.
getArch() != llvm::Triple::x86) {
5635 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5636 << A->getSpelling() << RawTriple.str();
5637 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5638 CmdArgs.push_back(
"-fpcc-struct-return");
5640 assert(A->getOption().matches(options::OPT_freg_struct_return));
5641 CmdArgs.push_back(
"-freg-struct-return");
5645 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5646 if (Triple.getArch() == llvm::Triple::m68k)
5647 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5649 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5652 if (Args.hasArg(options::OPT_fenable_matrix)) {
5654 CmdArgs.push_back(
"-fenable-matrix");
5655 CmdArgs.push_back(
"-mllvm");
5656 CmdArgs.push_back(
"-enable-matrix");
5661 const char *FPKeepKindStr =
nullptr;
5662 switch (FPKeepKind) {
5664 FPKeepKindStr =
"-mframe-pointer=none";
5667 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5670 FPKeepKindStr =
"-mframe-pointer=all";
5673 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5674 CmdArgs.push_back(FPKeepKindStr);
5676 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5677 options::OPT_fno_zero_initialized_in_bss);
5682 OptSpecifier StrictAliasingAliasOption =
5683 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5686 bool TBAAOnByDefault = !D.
IsCLMode();
5687 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5688 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5689 CmdArgs.push_back(
"-relaxed-aliasing");
5690 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5691 options::OPT_fno_struct_path_tbaa,
true))
5692 CmdArgs.push_back(
"-no-struct-path-tbaa");
5693 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5694 options::OPT_fno_strict_enums);
5695 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5696 options::OPT_fno_strict_return);
5697 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5698 options::OPT_fno_allow_editor_placeholders);
5699 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5700 options::OPT_fno_strict_vtable_pointers);
5701 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5702 options::OPT_fno_force_emit_vtables);
5703 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5704 options::OPT_fno_optimize_sibling_calls);
5705 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5706 options::OPT_fno_escaping_block_tail_calls);
5708 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5709 options::OPT_fno_fine_grained_bitfield_accesses);
5711 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5712 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5714 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5715 options::OPT_fno_experimental_omit_vtable_rtti);
5718 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5719 options::OPT_fno_split_stack);
5722 if (Args.hasFlag(options::OPT_fprotect_parens,
5723 options::OPT_fno_protect_parens,
false))
5724 CmdArgs.push_back(
"-fprotect-parens");
5728 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5729 const llvm::Triple::ArchType Arch = TC.
getArch();
5730 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5731 StringRef
V = A->getValue();
5733 CmdArgs.push_back(
"-fextend-arguments=64");
5735 D.
Diag(diag::err_drv_invalid_argument_to_option)
5736 << A->getValue() << A->getOption().getName();
5738 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5739 << A->getOption().getName() << TripleStr;
5742 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5743 if (TC.
getArch() == llvm::Triple::avr)
5744 A->render(Args, CmdArgs);
5746 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5747 << A->getAsString(Args) << TripleStr;
5750 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5752 A->render(Args, CmdArgs);
5754 (A->getOption().getID() != options::OPT_mlong_double_80))
5755 A->render(Args, CmdArgs);
5757 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5758 << A->getAsString(Args) << TripleStr;
5764 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5765 IsIntegratedAssemblerDefault))
5766 CmdArgs.push_back(
"-fno-verbose-asm");
5770 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5771 StringRef
V = A->getValue();
5774 A->render(Args, CmdArgs);
5775 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5776 (
V.empty() || (
V.consume_front(
".") &&
5777 !
V.consumeInteger(10, Num) &&
V.empty())))
5778 A->render(Args, CmdArgs);
5780 D.
Diag(diag::err_drv_invalid_argument_to_option)
5781 << A->getValue() << A->getOption().getName();
5787 CmdArgs.push_back(
"-no-integrated-as");
5789 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5790 CmdArgs.push_back(
"-mdebug-pass");
5791 CmdArgs.push_back(
"Structure");
5793 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5794 CmdArgs.push_back(
"-mdebug-pass");
5795 CmdArgs.push_back(
"Arguments");
5801 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5802 CmdArgs.push_back(
"-mconstructor-aliases");
5806 if (KernelOrKext && RawTriple.isOSDarwin())
5807 CmdArgs.push_back(
"-fforbid-guard-variables");
5809 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5810 Triple.isWindowsGNUEnvironment())) {
5811 CmdArgs.push_back(
"-mms-bitfields");
5814 if (Triple.isWindowsGNUEnvironment()) {
5815 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5816 options::OPT_fno_auto_import);
5819 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5821 CmdArgs.push_back(
"-fms-volatile");
5826 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5827 options::OPT_fno_direct_access_external_data)) {
5828 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5830 A->render(Args, CmdArgs);
5831 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
5834 CmdArgs.push_back(
"-fno-direct-access-external-data");
5837 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5838 CmdArgs.push_back(
"-fno-plt");
5845 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5848 CmdArgs.push_back(
"-ffreestanding");
5850 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5857 bool IsAsyncUnwindTablesDefault =
5859 bool IsSyncUnwindTablesDefault =
5862 bool AsyncUnwindTables = Args.hasFlag(
5863 options::OPT_fasynchronous_unwind_tables,
5864 options::OPT_fno_asynchronous_unwind_tables,
5865 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5868 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5869 IsSyncUnwindTablesDefault && !Freestanding);
5870 if (AsyncUnwindTables)
5871 CmdArgs.push_back(
"-funwind-tables=2");
5872 else if (UnwindTables)
5873 CmdArgs.push_back(
"-funwind-tables=1");
5877 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5878 (IsCudaDevice || IsHIPDevice)) {
5879 const ArgList &HostArgs =
5881 std::string HostCPU =
5883 if (!HostCPU.empty()) {
5884 CmdArgs.push_back(
"-aux-target-cpu");
5885 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5893 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5894 StringRef CM = A->getValue();
5896 if (Triple.isOSAIX() && CM ==
"medium")
5898 if (Triple.isAArch64(64)) {
5899 Ok = CM ==
"tiny" || CM ==
"small" || CM ==
"large";
5900 if (CM ==
"large" && !Triple.isOSBinFormatMachO() &&
5901 RelocationModel != llvm::Reloc::Static)
5902 D.
Diag(diag::err_drv_argument_only_allowed_with)
5903 << A->getAsString(Args) <<
"-fno-pic";
5904 }
else if (Triple.isLoongArch()) {
5905 if (CM ==
"extreme" &&
5906 Args.hasFlagNoClaim(options::OPT_fplt, options::OPT_fno_plt,
false))
5907 D.
Diag(diag::err_drv_argument_not_allowed_with)
5908 << A->getAsString(Args) <<
"-fplt";
5909 Ok = CM ==
"normal" || CM ==
"medium" || CM ==
"extreme";
5912 CM = llvm::StringSwitch<StringRef>(CM)
5913 .Case(
"normal",
"small")
5914 .Case(
"extreme",
"large")
5916 }
else if (Triple.isPPC64() || Triple.isOSAIX()) {
5917 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
5918 }
else if (Triple.isRISCV()) {
5921 else if (CM ==
"medany")
5923 Ok = CM ==
"small" || CM ==
"medium";
5924 }
else if (Triple.getArch() == llvm::Triple::x86_64) {
5925 Ok = llvm::is_contained({
"small",
"kernel",
"medium",
"large",
"tiny"},
5927 }
else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {
5931 }
else if (Triple.isSPARC64()) {
5934 else if (CM ==
"medmid")
5936 else if (CM ==
"medany")
5938 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
5941 CmdArgs.push_back(Args.MakeArgString(
"-mcmodel=" + CM));
5943 D.
Diag(diag::err_drv_unsupported_option_argument_for_target)
5944 << A->getSpelling() << CM << TripleStr;
5948 if (Triple.getArch() == llvm::Triple::x86_64) {
5949 bool IsMediumCM =
false;
5950 bool IsLargeCM =
false;
5951 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5952 IsMediumCM = StringRef(A->getValue()) ==
"medium";
5953 IsLargeCM = StringRef(A->getValue()) ==
"large";
5955 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {
5956 if (!IsMediumCM && !IsLargeCM) {
5957 D.
Diag(diag::warn_drv_large_data_threshold_invalid_code_model)
5958 << A->getOption().getRenderName();
5960 A->render(Args, CmdArgs);
5962 }
else if (IsMediumCM) {
5963 CmdArgs.push_back(
"-mlarge-data-threshold=65536");
5964 }
else if (IsLargeCM) {
5965 CmdArgs.push_back(
"-mlarge-data-threshold=0");
5969 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5970 StringRef
Value = A->getValue();
5971 unsigned TLSSize = 0;
5972 Value.getAsInteger(10, TLSSize);
5973 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5974 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5975 << A->getOption().getName() << TripleStr;
5976 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5977 D.
Diag(diag::err_drv_invalid_int_value)
5978 << A->getOption().getName() <<
Value;
5979 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5983 CmdArgs.push_back(
"-enable-tlsdesc");
5986 std::string CPU =
getCPUName(D, Args, Triple,
false);
5988 CmdArgs.push_back(
"-target-cpu");
5989 CmdArgs.push_back(Args.MakeArgString(CPU));
5992 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5997 AddClangCLArgs(Args, InputType, CmdArgs);
5999 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6000 llvm::codegenoptions::NoDebugInfo;
6003 CmdArgs, Output, DebugInfoKind, DwarfFission);
6011 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
6012 isa<BackendJobAction>(JA));
6014 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6015 CmdArgs.push_back(
"-split-dwarf-file");
6016 CmdArgs.push_back(SplitDWARFOut);
6018 CmdArgs.push_back(
"-split-dwarf-output");
6019 CmdArgs.push_back(SplitDWARFOut);
6024 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6025 CmdArgs.push_back(
"-target-linker-version");
6026 CmdArgs.push_back(A->getValue());
6031 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6033 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6034 TC.
getArch() == llvm::Triple::x86) {
6035 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6036 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6037 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6038 << Unsupported->getOption().getName();
6041 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6042 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6043 << Unsupported->getOption().getName()
6044 <<
"please use -maltivec and include altivec.h explicitly";
6045 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6046 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6047 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6050 Args.AddAllArgs(CmdArgs, options::OPT_v);
6052 if (Args.getLastArg(options::OPT_H)) {
6053 CmdArgs.push_back(
"-H");
6054 CmdArgs.push_back(
"-sys-header-deps");
6056 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6059 CmdArgs.push_back(
"-header-include-file");
6063 CmdArgs.push_back(
"-sys-header-deps");
6064 CmdArgs.push_back(Args.MakeArgString(
6065 "-header-include-format=" +
6068 Args.MakeArgString(
"-header-include-filtering=" +
6072 Args.AddLastArg(CmdArgs, options::OPT_P);
6073 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6076 CmdArgs.push_back(
"-diagnostic-log-file");
6085 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6089 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6090 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6091 CmdArgs.push_back(
"-mllvm");
6092 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6097 if (Args.hasFlag(options::OPT_ffunction_sections,
6098 options::OPT_fno_function_sections, UseSeparateSections)) {
6099 CmdArgs.push_back(
"-ffunction-sections");
6102 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6103 options::OPT_fno_basic_block_address_map)) {
6104 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6105 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6106 A->render(Args, CmdArgs);
6108 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6109 << A->getAsString(Args) << TripleStr;
6113 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6114 StringRef Val = A->getValue();
6115 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6116 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
6117 !Val.starts_with(
"list="))
6118 D.
Diag(diag::err_drv_invalid_value)
6119 << A->getAsString(Args) << A->getValue();
6121 A->render(Args, CmdArgs);
6122 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6125 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6126 D.
Diag(diag::err_drv_invalid_value)
6127 << A->getAsString(Args) << A->getValue();
6129 A->render(Args, CmdArgs);
6130 }
else if (Triple.isNVPTX()) {
6133 }
else if (Val !=
"none") {
6136 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6137 << A->getAsString(Args) << TripleStr;
6141 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6142 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6143 UseSeparateSections || HasDefaultDataSections)) {
6144 CmdArgs.push_back(
"-fdata-sections");
6147 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6148 options::OPT_fno_unique_section_names);
6149 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6150 options::OPT_fno_separate_named_sections);
6151 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6152 options::OPT_fno_unique_internal_linkage_names);
6153 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6154 options::OPT_fno_unique_basic_block_section_names);
6155 Args.addOptInFlag(CmdArgs, options::OPT_fconvergent_functions,
6156 options::OPT_fno_convergent_functions);
6158 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6159 options::OPT_fno_split_machine_functions)) {
6160 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6162 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6163 A->render(Args, CmdArgs);
6165 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6166 << A->getAsString(Args) << TripleStr;
6170 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6171 options::OPT_finstrument_functions_after_inlining,
6172 options::OPT_finstrument_function_entry_bare);
6177 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
6180 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6183 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
6184 CmdArgs.push_back(
"-mllvm");
6185 CmdArgs.push_back(
"-sample-profile-use-profi");
6189 if (RawTriple.isPS() &&
6190 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6196 if (Args.hasArg(options::OPT_nostdinc)) {
6197 CmdArgs.push_back(
"-nostdsysteminc");
6198 CmdArgs.push_back(
"-nobuiltininc");
6200 if (Args.hasArg(options::OPT_nostdlibinc))
6201 CmdArgs.push_back(
"-nostdsysteminc");
6202 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6203 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6207 CmdArgs.push_back(
"-resource-dir");
6210 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6219 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6225 Args.ClaimAllArgs(options::OPT_D);
6228 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
6229 if (A->getOption().matches(options::OPT_O4)) {
6230 CmdArgs.push_back(
"-O3");
6231 D.
Diag(diag::warn_O4_is_O3);
6233 A->render(Args, CmdArgs);
6239 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6240 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6245 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6246 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6252 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6255 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6257 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6258 unsigned WarningNumber;
6259 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6260 D.
Diag(diag::err_drv_invalid_int_value)
6261 << A->getAsString(Args) << A->getValue();
6266 CmdArgs.push_back(Args.MakeArgString(
6271 A->render(Args, CmdArgs);
6274 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6276 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6277 CmdArgs.push_back(
"-pedantic");
6278 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6279 Args.AddLastArg(CmdArgs, options::OPT_w);
6281 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6282 options::OPT_fno_fixed_point);
6284 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6285 A->render(Args, CmdArgs);
6287 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6288 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6290 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6291 options::OPT_fno_experimental_omit_vtable_rtti);
6293 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6294 A->render(Args, CmdArgs);
6301 bool ImplyVCPPCVer =
false;
6302 bool ImplyVCPPCXXVer =
false;
6303 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6305 if (
Std->getOption().matches(options::OPT_ansi))
6307 CmdArgs.push_back(
"-std=c++98");
6309 CmdArgs.push_back(
"-std=c89");
6311 Std->render(Args, CmdArgs);
6314 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6315 options::OPT_ftrigraphs,
6316 options::OPT_fno_trigraphs))
6318 A->render(Args, CmdArgs);
6327 if (!Args.hasArg(options::OPT__SLASH_std)) {
6328 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6331 ImplyVCPPCVer =
true;
6333 else if (IsWindowsMSVC)
6334 ImplyVCPPCXXVer =
true;
6336 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6337 options::OPT_fno_trigraphs);
6353 Args.getLastArg(options::OPT_Wwrite_strings,
6354 options::OPT_Wno_write_strings, options::OPT_w);
6356 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6357 CmdArgs.push_back(
"-fconst-strings");
6364 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6366 CmdArgs.push_back(
"-fdeprecated-macro");
6370 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6371 if (
Asm->getOption().matches(options::OPT_fasm))
6372 CmdArgs.push_back(
"-fgnu-keywords");
6374 CmdArgs.push_back(
"-fno-gnu-keywords");
6378 CmdArgs.push_back(
"-fno-autolink");
6380 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6381 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6382 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6383 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6385 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6387 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6388 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6390 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6391 CmdArgs.push_back(
"-fbracket-depth");
6392 CmdArgs.push_back(A->getValue());
6395 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6396 options::OPT_Wlarge_by_value_copy_def)) {
6397 if (A->getNumValues()) {
6398 StringRef
bytes = A->getValue();
6399 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6401 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6404 if (Args.hasArg(options::OPT_relocatable_pch))
6405 CmdArgs.push_back(
"-relocatable-pch");
6407 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6408 static const char *kCFABIs[] = {
6409 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6412 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6413 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6415 A->render(Args, CmdArgs);
6418 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6419 CmdArgs.push_back(
"-fconstant-string-class");
6420 CmdArgs.push_back(A->getValue());
6423 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6424 CmdArgs.push_back(
"-ftabstop");
6425 CmdArgs.push_back(A->getValue());
6428 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6429 options::OPT_fno_stack_size_section);
6431 if (Args.hasArg(options::OPT_fstack_usage)) {
6432 CmdArgs.push_back(
"-stack-usage-file");
6434 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6436 llvm::sys::path::replace_extension(OutputFilename,
"su");
6437 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6443 CmdArgs.push_back(
"-ferror-limit");
6444 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6445 CmdArgs.push_back(A->getValue());
6447 CmdArgs.push_back(
"19");
6449 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6450 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6451 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6452 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6453 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6456 unsigned MessageLength = 0;
6457 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6458 StringRef
V(A->getValue());
6459 if (
V.getAsInteger(0, MessageLength))
6460 D.
Diag(diag::err_drv_invalid_argument_to_option)
6461 <<
V << A->getOption().getName();
6465 MessageLength = llvm::sys::Process::StandardErrColumns();
6467 if (MessageLength != 0)
6469 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6471 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6473 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6475 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6476 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6477 Twine(A->getValue(0))));
6480 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6481 options::OPT_fvisibility_ms_compat)) {
6482 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6483 A->render(Args, CmdArgs);
6485 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6486 CmdArgs.push_back(
"-fvisibility=hidden");
6487 CmdArgs.push_back(
"-ftype-visibility=default");
6489 }
else if (IsOpenMPDevice) {
6493 CmdArgs.push_back(
"-fvisibility=protected");
6497 if (!RawTriple.isPS()) {
6499 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6500 options::OPT_fno_visibility_from_dllstorageclass)) {
6501 if (A->getOption().matches(
6502 options::OPT_fvisibility_from_dllstorageclass)) {
6503 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6504 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6505 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6506 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6507 Args.AddLastArg(CmdArgs,
6508 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6513 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6514 options::OPT_fno_visibility_inlines_hidden,
false))
6515 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6517 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6518 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6523 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6524 D.
Diag(diag::warn_drv_deprecated_arg)
6525 << A->getAsString(Args) <<
true
6526 <<
"-fvisibility-global-new-delete=force-hidden";
6530 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6531 options::OPT_fvisibility_global_new_delete_hidden)) {
6532 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6533 A->render(Args, CmdArgs);
6535 assert(A->getOption().matches(
6536 options::OPT_fvisibility_global_new_delete_hidden));
6537 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6541 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6543 if (Args.hasFlag(options::OPT_fnew_infallible,
6544 options::OPT_fno_new_infallible,
false))
6545 CmdArgs.push_back(
"-fnew-infallible");
6547 if (Args.hasFlag(options::OPT_fno_operator_names,
6548 options::OPT_foperator_names,
false))
6549 CmdArgs.push_back(
"-fno-operator-names");
6552 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6553 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6554 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6555 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6557 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6558 Triple.hasDefaultEmulatedTLS()))
6559 CmdArgs.push_back(
"-femulated-tls");
6561 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6562 options::OPT_fno_check_new);
6564 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6568 if (!Triple.isX86() && !Triple.isAArch64())
6569 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6570 << A->getAsString(Args) << TripleStr;
6574 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
6575 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6577 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6578 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6582 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6583 options::OPT_fno_openmp,
false) &&
6590 CmdArgs.push_back(
"-fopenmp");
6595 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6596 options::OPT_fnoopenmp_use_tls,
true))
6597 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6598 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6599 options::OPT_fno_openmp_simd);
6600 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6601 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6602 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6603 options::OPT_fno_openmp_extensions,
true))
6604 CmdArgs.push_back(
"-fno-openmp-extensions");
6605 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6606 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6607 Args.AddAllArgs(CmdArgs,
6608 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6609 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6610 options::OPT_fno_openmp_optimistic_collapse,
6612 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6616 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6617 options::OPT_fno_openmp_cuda_mode,
false))
6618 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6621 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6622 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6623 options::OPT_fno_openmp_target_debug,
false))
6624 CmdArgs.push_back(
"-fopenmp-target-debug");
6628 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6629 options::OPT_fno_openmp_assume_teams_oversubscription,
6631 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6632 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6633 options::OPT_fno_openmp_assume_threads_oversubscription,
6635 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6636 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6637 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6638 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6639 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6640 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6641 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6642 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6643 CmdArgs.push_back(
"-fopenmp-force-usm");
6655 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6656 options::OPT_fno_openmp_simd);
6657 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6658 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6659 options::OPT_fno_openmp_extensions);
6663 if (Args.hasFlag(options::OPT_offload_new_driver,
6664 options::OPT_no_offload_new_driver,
false))
6665 CmdArgs.push_back(
"--offload-new-driver");
6667 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
6670 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6673 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6675 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" +
Filename));
6680 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6681 StringRef S0 = A->getValue(), S = S0;
6682 unsigned Size, Offset = 0;
6683 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6685 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6686 << A->getAsString(Args) << TripleStr;
6687 else if (S.consumeInteger(10, Size) ||
6688 (!S.empty() && (!S.consume_front(
",") ||
6689 S.consumeInteger(10, Offset) || !S.empty())))
6690 D.
Diag(diag::err_drv_invalid_argument_to_option)
6691 << S0 << A->getOption().getName();
6692 else if (Size < Offset)
6693 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6695 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6696 CmdArgs.push_back(Args.MakeArgString(
6697 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6701 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6704 Args.AddLastArg(CmdArgs, options::OPT_pg);
6706 llvm::Triple::ArchType Arch = TC.
getArch();
6707 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6708 if (Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6709 A->render(Args, CmdArgs);
6711 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6712 << A->getAsString(Args) << TripleStr;
6714 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6715 if (Arch == llvm::Triple::systemz)
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_mrecord_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;
6730 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6732 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6733 << A->getAsString(Args) << TripleStr;
6736 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6738 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6739 << A->getAsString(Args) << TripleStr;
6742 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6743 if (A->getOption().matches(options::OPT_p)) {
6745 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6746 CmdArgs.push_back(
"-pg");
6752 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6753 options::OPT_mxcoff_build_id_EQ)) {
6754 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6755 << A->getSpelling() << TripleStr;
6759 if (Args.getLastArg(options::OPT_fapple_kext) ||
6760 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6761 CmdArgs.push_back(
"-fapple-kext");
6763 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6764 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6765 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6766 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6767 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6768 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6769 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6770 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6771 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6772 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6774 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
6775 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
6776 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6779 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6780 CmdArgs.push_back(
"-ftrapv-handler");
6781 CmdArgs.push_back(A->getValue());
6784 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6788 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
6789 if (A->getOption().matches(options::OPT_fwrapv))
6790 CmdArgs.push_back(
"-fwrapv");
6791 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
6792 options::OPT_fno_strict_overflow)) {
6793 if (A->getOption().matches(options::OPT_fno_strict_overflow))
6794 CmdArgs.push_back(
"-fwrapv");
6797 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6798 options::OPT_fno_finite_loops);
6800 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6801 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6802 options::OPT_fno_unroll_loops);
6804 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6806 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6808 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6809 options::OPT_mno_speculative_load_hardening);
6815 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6817 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6818 options::OPT_mno_stackrealign);
6820 if (Args.hasArg(options::OPT_mstack_alignment)) {
6821 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
6822 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
6825 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6826 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6829 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6831 CmdArgs.push_back(
"-mstack-probe-size=0");
6834 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6835 options::OPT_mno_stack_arg_probe);
6837 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6838 options::OPT_mno_restrict_it)) {
6839 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6840 CmdArgs.push_back(
"-mllvm");
6841 CmdArgs.push_back(
"-arm-restrict-it");
6843 CmdArgs.push_back(
"-mllvm");
6844 CmdArgs.push_back(
"-arm-default-it");
6858 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6859 options::OPT_fno_hip_new_launch_api,
true))
6860 CmdArgs.push_back(
"-fhip-new-launch-api");
6861 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6862 options::OPT_fno_gpu_allow_device_init);
6863 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6864 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6865 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6866 options::OPT_fno_hip_kernel_arg_name);
6869 if (IsCuda || IsHIP) {
6871 CmdArgs.push_back(
"-fgpu-rdc");
6872 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6873 options::OPT_fno_gpu_defer_diag);
6874 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6875 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6877 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6878 CmdArgs.push_back(
"-fgpu-defer-diag");
6883 if (Args.hasArg(options::OPT_nogpulib))
6884 CmdArgs.push_back(
"-nogpulib");
6886 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6888 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
6891 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6893 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
6895 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6900 if (!(IsCudaDevice || IsHIPDevice)) {
6902 auto *PGOArg = Args.getLastArg(
6903 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
6904 options::OPT_fcs_profile_generate,
6905 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
6906 options::OPT_fprofile_use_EQ);
6908 D.
Diag(diag::err_drv_argument_not_allowed_with)
6909 <<
"SampleUse with PGO options";
6911 StringRef fname = A->getValue();
6912 if (!llvm::sys::fs::exists(fname))
6913 D.
Diag(diag::err_drv_no_such_file) << fname;
6915 A->render(Args, CmdArgs);
6917 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6919 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6920 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
6921 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
6924 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6925 options::OPT_fno_unique_internal_linkage_names,
true))
6926 CmdArgs.push_back(
"-funique-internal-linkage-names");
6931 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6932 options::OPT_fno_assume_sane_operator_new);
6934 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
6935 CmdArgs.push_back(
"-fapinotes");
6936 if (Args.hasFlag(options::OPT_fapinotes_modules,
6937 options::OPT_fno_apinotes_modules,
false))
6938 CmdArgs.push_back(
"-fapinotes-modules");
6939 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
6942 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
6944 (Args.hasArg(options::OPT_fgnu_runtime) &&
6945 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
6946 !Args.hasArg(options::OPT_fno_blocks))) {
6947 CmdArgs.push_back(
"-fblocks");
6950 CmdArgs.push_back(
"-fblocks-runtime-optional");
6955 CmdArgs.push_back(
"-fencode-extended-block-signature");
6957 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
6958 options::OPT_fno_coro_aligned_allocation,
false) &&
6960 CmdArgs.push_back(
"-fcoro-aligned-allocation");
6962 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
6963 options::OPT_fno_double_square_bracket_attributes);
6965 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
6966 options::OPT_fno_access_control);
6967 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
6968 options::OPT_fno_elide_constructors);
6974 CmdArgs.push_back(
"-fno-rtti");
6977 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
6978 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
6979 CmdArgs.push_back(
"-fshort-enums");
6985 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
6986 !RawTriple.isOSAIX() && !RawTriple.isOSWindows() &&
6987 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
6988 RawTriple.hasEnvironment())) ||
6990 CmdArgs.push_back(
"-fno-use-cxa-atexit");
6992 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
6993 options::OPT_fno_register_global_dtors_with_atexit,
6994 RawTriple.isOSDarwin() && !KernelOrKext))
6995 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
6997 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
6998 options::OPT_fno_use_line_directives);
7001 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7002 options::OPT_fno_minimize_whitespace,
false)) {
7003 types::ID InputType = Inputs[0].getType();
7004 if (!isDerivedFromC(InputType))
7005 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7007 CmdArgs.push_back(
"-fminimize-whitespace");
7011 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7012 options::OPT_fno_keep_system_includes,
false)) {
7013 types::ID InputType = Inputs[0].getType();
7014 if (!isDerivedFromC(InputType))
7015 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7017 CmdArgs.push_back(
"-fkeep-system-includes");
7021 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7023 CmdArgs.push_back(
"-fms-extensions");
7026 bool IsMSVCCompat = Args.hasFlag(
7027 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7028 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7029 options::OPT_fno_ms_extensions,
true)));
7031 CmdArgs.push_back(
"-fms-compatibility");
7033 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7034 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7038 VersionTuple GNUCVer;
7039 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7042 StringRef Val = A->getValue();
7043 Val = Val.empty() ?
"0" : Val;
7044 bool Invalid = GNUCVer.tryParse(Val);
7045 unsigned Minor = GNUCVer.getMinor().value_or(0);
7046 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7047 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7048 D.
Diag(diag::err_drv_invalid_value)
7049 << A->getAsString(Args) << A->getValue();
7051 }
else if (!IsMSVCCompat) {
7053 GNUCVer = VersionTuple(4, 2, 1);
7055 if (!GNUCVer.empty()) {
7057 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7063 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7065 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7066 if (ImplyVCPPCVer) {
7067 StringRef LanguageStandard;
7068 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7070 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7071 .Case(
"c11",
"-std=c11")
7072 .Case(
"c17",
"-std=c17")
7074 if (LanguageStandard.empty())
7075 D.
Diag(clang::diag::warn_drv_unused_argument)
7076 << StdArg->getAsString(Args);
7078 CmdArgs.push_back(LanguageStandard.data());
7080 if (ImplyVCPPCXXVer) {
7081 StringRef LanguageStandard;
7082 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7084 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7085 .Case(
"c++14",
"-std=c++14")
7086 .Case(
"c++17",
"-std=c++17")
7087 .Case(
"c++20",
"-std=c++20")
7089 .Case(
"c++latest",
"-std=c++26")
7091 if (LanguageStandard.empty())
7092 D.
Diag(clang::diag::warn_drv_unused_argument)
7093 << StdArg->getAsString(Args);
7096 if (LanguageStandard.empty()) {
7097 if (IsMSVC2015Compatible)
7098 LanguageStandard =
"-std=c++14";
7100 LanguageStandard =
"-std=c++11";
7103 CmdArgs.push_back(LanguageStandard.data());
7106 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7107 options::OPT_fno_borland_extensions);
7110 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7112 CmdArgs.push_back(
"-fdeclspec");
7113 else if (Args.hasArg(options::OPT_fno_declspec))
7114 CmdArgs.push_back(
"-fno-declspec");
7118 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7119 options::OPT_fno_threadsafe_statics,
7121 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7122 CmdArgs.push_back(
"-fno-threadsafe-statics");
7125 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7127 CmdArgs.push_back(
"-fno-assumptions");
7131 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7132 options::OPT_fno_gnu_keywords);
7134 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7135 options::OPT_fno_gnu89_inline);
7137 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7138 options::OPT_finline_hint_functions,
7139 options::OPT_fno_inline_functions);
7140 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7141 if (A->getOption().matches(options::OPT_fno_inline))
7142 A->render(Args, CmdArgs);
7143 }
else if (InlineArg) {
7144 InlineArg->render(Args, CmdArgs);
7147 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7152 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"gnu++2a") ||
7153 Std->containsValue(
"c++20") ||
Std->containsValue(
"gnu++20") ||
7154 Std->containsValue(
"c++2b") ||
Std->containsValue(
"gnu++2b") ||
7155 Std->containsValue(
"c++23") ||
Std->containsValue(
"gnu++23") ||
7156 Std->containsValue(
"c++2c") ||
Std->containsValue(
"gnu++2c") ||
7157 Std->containsValue(
"c++26") ||
Std->containsValue(
"gnu++26") ||
7158 Std->containsValue(
"c++latest") ||
Std->containsValue(
"gnu++latest"));
7173 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7174 options::OPT_fno_delayed_template_parsing,
7175 IsWindowsMSVC && !HaveCxx20)) {
7177 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7179 CmdArgs.push_back(
"-fdelayed-template-parsing");
7182 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7183 options::OPT_fno_pch_validate_input_files_content,
false))
7184 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7185 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7186 options::OPT_fno_pch_instantiate_templates,
false))
7187 CmdArgs.push_back(
"-fpch-instantiate-templates");
7188 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7190 CmdArgs.push_back(
"-fmodules-codegen");
7191 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7193 CmdArgs.push_back(
"-fmodules-debuginfo");
7195 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7200 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7201 options::OPT_fno_objc_encode_cxx_class_template_spec,
7203 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7205 if (Args.hasFlag(options::OPT_fapplication_extension,
7206 options::OPT_fno_application_extension,
false))
7207 CmdArgs.push_back(
"-fapplication-extension");
7211 if (!
C.getDriver().IsCLMode())
7212 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7215 Arg *A = Args.getLastArg(
7216 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7217 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7219 const Option &Opt = A->getOption();
7220 if (Opt.matches(options::OPT_fsjlj_exceptions))
7221 CmdArgs.push_back(
"-exception-model=sjlj");
7222 if (Opt.matches(options::OPT_fseh_exceptions))
7223 CmdArgs.push_back(
"-exception-model=seh");
7224 if (Opt.matches(options::OPT_fdwarf_exceptions))
7225 CmdArgs.push_back(
"-exception-model=dwarf");
7226 if (Opt.matches(options::OPT_fwasm_exceptions))
7227 CmdArgs.push_back(
"-exception-model=wasm");
7232 case llvm::ExceptionHandling::DwarfCFI:
7233 CmdArgs.push_back(
"-exception-model=dwarf");
7235 case llvm::ExceptionHandling::SjLj:
7236 CmdArgs.push_back(
"-exception-model=sjlj");
7238 case llvm::ExceptionHandling::WinEH:
7239 CmdArgs.push_back(
"-exception-model=seh");
7245 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7246 options::OPT_fno_assume_sane_operator_new);
7249 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7250 options::OPT_fno_assume_unique_vtables);
7254 Args.getLastArg(options::OPT_frelaxed_template_template_args,
7255 options::OPT_fno_relaxed_template_template_args)) {
7256 if (A->getOption().matches(
7257 options::OPT_fno_relaxed_template_template_args)) {
7258 D.
Diag(diag::warn_drv_deprecated_arg_no_relaxed_template_template_args);
7259 CmdArgs.push_back(
"-fno-relaxed-template-template-args");
7261 D.
Diag(diag::warn_drv_deprecated_arg)
7262 << A->getAsString(Args) <<
false;
7268 Args.addOptInFlag(CmdArgs, options::OPT_fsized_deallocation,
7269 options::OPT_fno_sized_deallocation);
7273 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7274 options::OPT_fno_aligned_allocation,
7275 options::OPT_faligned_new_EQ)) {
7276 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7277 CmdArgs.push_back(
"-fno-aligned-allocation");
7279 CmdArgs.push_back(
"-faligned-allocation");
7284 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7285 options::OPT_faligned_new_EQ))
7287 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7291 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7292 options::OPT_fno_constant_cfstrings,
true) ||
7293 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7294 options::OPT_mno_constant_cfstrings,
true))
7295 CmdArgs.push_back(
"-fno-constant-cfstrings");
7297 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7298 options::OPT_fno_pascal_strings);
7302 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7303 std::string PackStructStr =
"-fpack-struct=";
7304 PackStructStr += A->getValue();
7305 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7306 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7307 options::OPT_fno_pack_struct,
false)) {
7308 CmdArgs.push_back(
"-fpack-struct=1");
7312 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7313 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7314 if (!SkipMaxTypeAlign) {
7315 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7316 MaxTypeAlignStr += A->getValue();
7317 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7319 }
else if (RawTriple.isOSDarwin()) {
7320 if (!SkipMaxTypeAlign) {
7321 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7322 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7326 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7327 CmdArgs.push_back(
"-Qn");
7330 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7334 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7335 options::OPT_funsigned_bitfields,
true))
7336 D.
Diag(diag::warn_drv_clang_unsupported)
7337 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7340 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7341 D.
Diag(diag::err_drv_clang_unsupported)
7342 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7345 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7346 StringRef value = inputCharset->getValue();
7347 if (!value.equals_insensitive(
"utf-8"))
7348 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7353 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7354 StringRef value = execCharset->getValue();
7355 if (!value.equals_insensitive(
"utf-8"))
7356 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7362 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7363 options::OPT_fno_asm_blocks);
7365 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7366 options::OPT_fno_gnu_inline_asm);
7372 OptSpecifier VectorizeAliasOption =
7373 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
7374 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
7375 options::OPT_fno_vectorize, EnableVec))
7376 CmdArgs.push_back(
"-vectorize-loops");
7380 OptSpecifier SLPVectAliasOption =
7381 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
7382 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
7383 options::OPT_fno_slp_vectorize, EnableSLPVec))
7384 CmdArgs.push_back(
"-vectorize-slp");
7388 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7389 Args.AddLastArg(CmdArgs,
7390 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7394 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7395 options::OPT_fno_dollars_in_identifiers)) {
7396 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7397 CmdArgs.push_back(
"-fdollars-in-identifiers");
7399 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7402 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7403 options::OPT_fno_apple_pragma_pack);
7409 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7410 options::OPT_fno_rewrite_imports,
false);
7412 CmdArgs.push_back(
"-frewrite-imports");
7414 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7415 options::OPT_fno_directives_only);
7421 if (Args.hasFlag(options::OPT_frewrite_includes,
7422 options::OPT_fno_rewrite_includes,
false) ||
7423 (
C.isForDiagnostics() && !HaveModules))
7424 CmdArgs.push_back(
"-frewrite-includes");
7427 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7428 options::OPT_traditional_cpp)) {
7429 if (isa<PreprocessJobAction>(JA))
7430 CmdArgs.push_back(
"-traditional-cpp");
7432 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7435 Args.AddLastArg(CmdArgs, options::OPT_dM);
7436 Args.AddLastArg(CmdArgs, options::OPT_dD);
7437 Args.AddLastArg(CmdArgs, options::OPT_dI);
7439 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7442 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7443 CmdArgs.push_back(
"-serialize-diagnostic-file");
7444 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7447 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7448 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7451 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7453 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7456 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7457 CmdArgs.push_back(
"-load");
7458 CmdArgs.push_back(A->getValue());
7470 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7471 auto ArgValue = StringRef(A->getValue());
7472 auto FirstDashIndex = ArgValue.find(
'-');
7473 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7474 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7477 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7478 if (PluginName.empty()) {
7479 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7481 D.
Diag(diag::warn_drv_missing_plugin_arg)
7482 << PluginName << A->getAsString(Args);
7487 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7488 CmdArgs.push_back(Args.MakeArgString(Arg));
7492 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7494 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7499 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7500 CmdArgs.push_back(
"--vfsoverlay");
7501 CmdArgs.push_back(A->getValue());
7505 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7506 options::OPT_fno_safe_buffer_usage_suggestions);
7508 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7509 options::OPT_fno_experimental_late_parse_attributes);
7513 if (!StatsFile.empty()) {
7514 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7516 CmdArgs.push_back(
"-stats-file-append");
7521 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7525 if (
C.getDriver().isSaveTempsEnabled() &&
7526 !isa<PreprocessJobAction>(JA)) {
7527 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7530 CmdArgs.push_back(Arg->getValue());
7532 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7538 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7539 CmdArgs.push_back(
"-disable-llvm-optzns");
7541 A->render(Args, CmdArgs);
7553 if ((
C.getDriver().isSaveTempsEnabled() ||
7555 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7556 isa<CompileJobAction>(JA))
7557 CmdArgs.push_back(
"-disable-llvm-passes");
7559 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7568 auto GRecordSwitches =
7569 Args.hasFlag(options::OPT_grecord_command_line,
7570 options::OPT_gno_record_command_line,
false);
7571 auto FRecordSwitches =
7572 Args.hasFlag(options::OPT_frecord_command_line,
7573 options::OPT_fno_record_command_line,
false);
7574 if (FRecordSwitches && !Triple.isOSBinFormatELF() &&
7575 !Triple.isOSBinFormatXCOFF() && !Triple.isOSBinFormatMachO())
7576 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7577 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
7580 ArgStringList OriginalArgs;
7581 for (
const auto &Arg : Args)
7582 Arg->render(Args, OriginalArgs);
7586 for (
const char *OriginalArg : OriginalArgs) {
7590 Flags += EscapedArg;
7592 auto FlagsArgString = Args.MakeArgString(Flags);
7594 CmdArgs.push_back(
"-dwarf-debug-flags");
7595 CmdArgs.push_back(FlagsArgString);
7597 if (FRecordSwitches) {
7598 CmdArgs.push_back(
"-record-command-line");
7599 CmdArgs.push_back(FlagsArgString);
7606 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7607 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7608 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7609 }
else if (!HostOffloadingInputs.empty()) {
7610 if ((IsCuda || IsHIP) && !IsRDCMode) {
7611 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7612 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7613 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7615 for (
const InputInfo Input : HostOffloadingInputs)
7616 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7622 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7623 options::OPT_fno_cuda_short_ptr,
false))
7624 CmdArgs.push_back(
"-fcuda-short-ptr");
7627 if (IsCuda || IsHIP) {
7629 const Action *SourceAction = &JA;
7631 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7632 SourceAction = SourceAction->
getInputs()[0];
7634 auto CUID = cast<InputAction>(SourceAction)->getId();
7636 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7640 bool UseApproxTranscendentals = Args.hasFlag(
7641 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7642 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7643 options::OPT_fno_gpu_approx_transcendentals,
7644 UseApproxTranscendentals))
7645 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7647 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7648 options::OPT_fno_gpu_approx_transcendentals);
7652 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7653 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7656 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7657 options::OPT_fno_offload_uniform_block);
7659 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7660 options::OPT_fno_offload_implicit_host_device_templates);
7662 if (IsCudaDevice || IsHIPDevice) {
7663 StringRef InlineThresh =
7664 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7665 if (!InlineThresh.empty()) {
7666 std::string ArgStr =
7667 std::string(
"-inline-threshold=") + InlineThresh.str();
7668 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7673 Args.addOptOutFlag(CmdArgs,
7674 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7675 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7682 if (IsOpenMPDevice) {
7683 CmdArgs.push_back(
"-fopenmp-is-target-device");
7684 if (OpenMPDeviceInput) {
7685 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7686 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7690 if (Triple.isAMDGPU()) {
7693 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7694 options::OPT_mno_unsafe_fp_atomics);
7695 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7696 options::OPT_mno_amdgpu_ieee);
7706 std::transform(TCRange.first, TCRange.second, std::back_inserter(Triples),
7707 [](
auto TC) { return TC.second->getTripleString(); });
7708 CmdArgs.push_back(Args.MakeArgString(Targets + llvm::join(Triples,
",")));
7711 bool VirtualFunctionElimination =
7712 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7713 options::OPT_fno_virtual_function_elimination,
false);
7714 if (VirtualFunctionElimination) {
7718 D.
Diag(diag::err_drv_argument_only_allowed_with)
7719 <<
"-fvirtual-function-elimination"
7722 CmdArgs.push_back(
"-fvirtual-function-elimination");
7726 bool WholeProgramVTables = Args.hasFlag(
7727 options::OPT_fwhole_program_vtables,
7728 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7729 if (VirtualFunctionElimination && !WholeProgramVTables) {
7730 D.
Diag(diag::err_drv_argument_not_allowed_with)
7731 <<
"-fno-whole-program-vtables"
7732 <<
"-fvirtual-function-elimination";
7735 if (WholeProgramVTables) {
7745 if ((!IsUsingLTO && !D.
isUsingLTO(!IsDeviceOffloadAction)) ||
7747 D.
Diag(diag::err_drv_argument_only_allowed_with)
7748 <<
"-fwhole-program-vtables"
7749 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7753 CmdArgs.push_back(
"-fwhole-program-vtables");
7756 bool DefaultsSplitLTOUnit =
7757 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7759 (!Triple.isPS4() && UnifiedLTO);
7761 Args.hasFlag(options::OPT_fsplit_lto_unit,
7762 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
7763 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
7764 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
7765 <<
"-fsanitize=cfi";
7767 CmdArgs.push_back(
"-fsplit-lto-unit");
7769 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7770 options::OPT_fno_fat_lto_objects)) {
7771 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
7773 if (!Triple.isOSBinFormatELF()) {
7774 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7777 CmdArgs.push_back(Args.MakeArgString(
7778 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
7779 CmdArgs.push_back(
"-flto-unit");
7780 CmdArgs.push_back(
"-ffat-lto-objects");
7781 A->render(Args, CmdArgs);
7785 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7786 options::OPT_fno_global_isel)) {
7787 CmdArgs.push_back(
"-mllvm");
7788 if (A->getOption().matches(options::OPT_fglobal_isel)) {
7789 CmdArgs.push_back(
"-global-isel=1");
7794 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
7795 bool IsOptLevelSupported =
false;
7797 Arg *A = Args.getLastArg(options::OPT_O_Group);
7798 if (Triple.getArch() == llvm::Triple::aarch64) {
7799 if (!A || A->getOption().matches(options::OPT_O0))
7800 IsOptLevelSupported =
true;
7802 if (!IsArchSupported || !IsOptLevelSupported) {
7803 CmdArgs.push_back(
"-mllvm");
7804 CmdArgs.push_back(
"-global-isel-abort=2");
7806 if (!IsArchSupported)
7807 D.
Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
7809 D.
Diag(diag::warn_drv_global_isel_incomplete_opt);
7812 CmdArgs.push_back(
"-global-isel=0");
7816 if (Args.hasArg(options::OPT_forder_file_instrumentation)) {
7817 CmdArgs.push_back(
"-forder-file-instrumentation");
7822 CmdArgs.push_back(
"-mllvm");
7823 CmdArgs.push_back(
"-enable-order-file-instrumentation");
7827 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7828 options::OPT_fno_force_enable_int128)) {
7829 if (A->getOption().matches(options::OPT_fforce_enable_int128))
7830 CmdArgs.push_back(
"-fforce-enable-int128");
7833 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7834 options::OPT_fno_keep_static_consts);
7835 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7836 options::OPT_fno_keep_persistent_storage_variables);
7837 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7838 options::OPT_fno_complete_member_pointers);
7839 Args.addOptOutFlag(CmdArgs, options::OPT_fcxx_static_destructors,
7840 options::OPT_fno_cxx_static_destructors);
7846 if (Triple.isAArch64() &&
7847 (Args.hasArg(options::OPT_mno_fmv) ||
7848 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
7851 CmdArgs.push_back(
"-target-feature");
7852 CmdArgs.push_back(
"-fmv");
7855 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7862 CmdArgs.push_back(
"-faddrsig");
7864 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
7865 (EH || UnwindTables || AsyncUnwindTables ||
7866 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
7867 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
7869 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7870 std::string Str = A->getAsString(Args);
7872 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7874 CmdArgs.push_back(Args.MakeArgString(Str));
7879 if (Output.
getType() == types::TY_Dependencies) {
7882 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
7883 Output.
getType() == clang::driver::types::TY_IFS) {
7885 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
7886 CmdArgs.push_back(
"-o");
7887 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7889 CmdArgs.push_back(
"-o");
7893 assert(Output.
isNothing() &&
"Invalid output.");
7900 FrontendInputs = ExtractAPIInputs;
7902 FrontendInputs = {};
7904 for (
const InputInfo &Input : FrontendInputs) {
7913 C.addCommand(std::make_unique<CC1Command>(
7917 C.addCommand(std::make_unique<Command>(
7923 if (Output.
getType() == types::TY_Object &&
7924 Args.hasFlag(options::OPT__SLASH_showFilenames,
7925 options::OPT__SLASH_showFilenames_,
false)) {
7926 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
7929 if (Arg *A = Args.getLastArg(options::OPT_pg))
7931 !Args.hasArg(options::OPT_mfentry))
7932 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
7933 << A->getAsString(Args);
7939 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
7943 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
7944 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
7947 Args.ClaimAllArgs(options::OPT_emit_llvm);
7954 :
Tool(
"clang",
"clang frontend", TC), HasBackend(HasIntegratedBackend) {}
7961ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
7963 ArgStringList &cmdArgs,
7964 RewriteKind rewriteKind)
const {
7967 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
7968 options::OPT_fobjc_runtime_EQ);
7973 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
7975 StringRef value = runtimeArg->getValue();
7981 (runtime.
getVersion() >= VersionTuple(2, 0)))
7985 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
7989 runtimeArg->render(args, cmdArgs);
7998 unsigned objcABIVersion = 1;
8000 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
8001 StringRef value = abiArg->getValue();
8004 else if (value ==
"2")
8006 else if (value ==
"3")
8012 bool nonFragileABIIsDefault =
8013 (rewriteKind == RK_NonFragile ||
8014 (rewriteKind == RK_None &&
8016 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
8017 options::OPT_fno_objc_nonfragile_abi,
8018 nonFragileABIIsDefault)) {
8020#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
8021 unsigned nonFragileABIVersion = 1;
8023 unsigned nonFragileABIVersion = 2;
8027 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
8028 StringRef value = abiArg->getValue();
8030 nonFragileABIVersion = 1;
8031 else if (value ==
"2")
8032 nonFragileABIVersion = 2;
8038 objcABIVersion = 1 + nonFragileABIVersion;
8046 bool isNonFragile = objcABIVersion != 1;
8052 switch (rewriteKind) {
8065 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
8077 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
8086 if (llvm::any_of(inputs, [](
const InputInfo &input) {
8090 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
8095 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
8103 bool Asynch =
false;
8104 bool NoUnwindC =
false;
8116 bool isWindowsMSVC) {
8119 std::vector<std::string> EHArgs =
8120 Args.getAllArgValues(options::OPT__SLASH_EH);
8121 for (
const auto &EHVal : EHArgs) {
8122 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
8128 if (!isWindowsMSVC) {
8130 D.
Diag(clang::diag::warn_drv_unused_argument) <<
"/EHa" << EHVal;
8147 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
8153 if (EHArgs.empty() &&
8154 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
8157 EH.NoUnwindC =
true;
8160 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8162 EH.NoUnwindC =
false;
8169void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
8170 ArgStringList &CmdArgs)
const {
8175 if (Arg *ShowIncludes =
8176 Args.getLastArg(options::OPT__SLASH_showIncludes,
8177 options::OPT__SLASH_showIncludes_user)) {
8178 CmdArgs.push_back(
"--show-includes");
8179 if (ShowIncludes->getOption().matches(options::OPT__SLASH_showIncludes))
8180 CmdArgs.push_back(
"-sys-header-deps");
8184 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8186 CmdArgs.push_back(
"-fno-rtti-data");
8190 if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
8192 CmdArgs.push_back(
"-stack-protector");
8200 if (!isNVPTX && (EH.Synch || EH.Asynch)) {
8202 CmdArgs.push_back(
"-fcxx-exceptions");
8203 CmdArgs.push_back(
"-fexceptions");
8205 CmdArgs.push_back(
"-fasync-exceptions");
8207 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
8208 CmdArgs.push_back(
"-fexternc-nounwind");
8211 if (Args.hasArg(options::OPT__SLASH_EP)) {
8212 CmdArgs.push_back(
"-E");
8213 CmdArgs.push_back(
"-P");
8216 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
8217 options::OPT__SLASH_Zc_dllexportInlines,
8219 CmdArgs.push_back(
"-fno-dllexport-inlines");
8222 if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
8223 options::OPT__SLASH_Zc_wchar_t,
false)) {
8224 CmdArgs.push_back(
"-fno-wchar");
8227 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8229 std::vector<std::string> Values =
8230 Args.getAllArgValues(options::OPT__SLASH_arch);
8231 if (!Values.empty()) {
8232 llvm::SmallSet<std::string, 4> SupportedArches;
8233 if (Arch == llvm::Triple::x86)
8234 SupportedArches.insert(
"IA32");
8236 for (
auto &
V : Values)
8237 if (!SupportedArches.contains(
V))
8238 D.
Diag(diag::err_drv_argument_not_allowed_with)
8239 << std::string(
"/arch:").append(
V) <<
"/kernel";
8242 CmdArgs.push_back(
"-fno-rtti");
8243 if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_,
false))
8244 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"/GR"
8248 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
8249 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
8250 if (MostGeneralArg && BestCaseArg)
8251 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
8252 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
8254 if (MostGeneralArg) {
8255 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
8256 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
8257 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
8259 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
8260 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
8261 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
8262 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
8263 << FirstConflict->getAsString(Args)
8264 << SecondConflict->getAsString(Args);
8267 CmdArgs.push_back(
"-fms-memptr-rep=single");
8268 else if (MultipleArg)
8269 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
8271 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
8274 if (Args.hasArg(options::OPT_regcall4))
8275 CmdArgs.push_back(
"-regcall4");
8279 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
8280 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
8281 options::OPT__SLASH_Gregcall)) {
8282 unsigned DCCOptId = CCArg->getOption().getID();
8283 const char *DCCFlag =
nullptr;
8284 bool ArchSupported = !isNVPTX;
8287 case options::OPT__SLASH_Gd:
8288 DCCFlag =
"-fdefault-calling-conv=cdecl";
8290 case options::OPT__SLASH_Gr:
8291 ArchSupported = Arch == llvm::Triple::x86;
8292 DCCFlag =
"-fdefault-calling-conv=fastcall";
8294 case options::OPT__SLASH_Gz:
8295 ArchSupported = Arch == llvm::Triple::x86;
8296 DCCFlag =
"-fdefault-calling-conv=stdcall";
8298 case options::OPT__SLASH_Gv:
8299 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8300 DCCFlag =
"-fdefault-calling-conv=vectorcall";
8302 case options::OPT__SLASH_Gregcall:
8303 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8304 DCCFlag =
"-fdefault-calling-conv=regcall";
8309 if (ArchSupported && DCCFlag)
8310 CmdArgs.push_back(DCCFlag);
8313 if (Args.hasArg(options::OPT__SLASH_Gregcall4))
8314 CmdArgs.push_back(
"-regcall4");
8316 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
8318 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
8319 CmdArgs.push_back(
"-fdiagnostics-format");
8320 CmdArgs.push_back(
"msvc");
8323 if (Args.hasArg(options::OPT__SLASH_kernel))
8324 CmdArgs.push_back(
"-fms-kernel");
8326 for (
const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
8327 StringRef GuardArgs = A->getValue();
8330 if (GuardArgs.equals_insensitive(
"cf")) {
8332 CmdArgs.push_back(
"-cfguard");
8333 }
else if (GuardArgs.equals_insensitive(
"cf,nochecks")) {
8335 CmdArgs.push_back(
"-cfguard-no-checks");
8336 }
else if (GuardArgs.equals_insensitive(
"ehcont")) {
8338 CmdArgs.push_back(
"-ehcontguard");
8339 }
else if (GuardArgs.equals_insensitive(
"cf-") ||
8340 GuardArgs.equals_insensitive(
"ehcont-")) {
8343 D.
Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
8351 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
8358 if (
const char *End = strrchr(Str,
'.'))
8359 return Args.MakeArgString(std::string(Str, End));
8368 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
8370 llvm::sys::path::replace_extension(OutputFilename, llvm::Twine(
'd'));
8371 return Args.MakeArgString(OutputFilename);
8380 ArgStringList &CmdArgs)
const {
8386 CmdArgs.push_back(
"-target-abi");
8387 CmdArgs.push_back(ABIName.data());
8391 ArgStringList &CmdArgs)
const {
8395 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
8396 StringRef
Value = A->getValue();
8398 CmdArgs.push_back(
"-mllvm");
8399 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
8402 << A->getSpelling() <<
Value;
8408 ArgStringList &CmdArgs)
const {
8409 CmdArgs.push_back(
"-target-abi");
8416 ArgStringList &CmdArgs)
const {
8420 CmdArgs.push_back(
"-target-abi");
8421 CmdArgs.push_back(ABIName.data());
8423 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8424 options::OPT_mno_default_build_attributes,
true)) {
8425 CmdArgs.push_back(
"-mllvm");
8426 CmdArgs.push_back(
"-riscv-add-build-attributes");
8432 const ArgList &Args,
8433 const char *LinkingOutput)
const {
8434 ArgStringList CmdArgs;
8436 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
8440 const std::string &TripleStr = Triple.getTriple();
8444 Args.ClaimAllArgs(options::OPT_w);
8446 Args.ClaimAllArgs(options::OPT_emit_llvm);
8453 CmdArgs.push_back(
"-cc1as");
8456 CmdArgs.push_back(
"-triple");
8457 CmdArgs.push_back(Args.MakeArgString(TripleStr));
8463 CmdArgs.push_back(
"-filetype");
8464 CmdArgs.push_back(
"obj");
8468 CmdArgs.push_back(
"-main-file-name");
8472 std::string CPU =
getCPUName(D, Args, Triple,
true);
8474 CmdArgs.push_back(
"-target-cpu");
8475 CmdArgs.push_back(Args.MakeArgString(CPU));
8482 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
8485 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
8488 auto FindSource = [](
const Action *S) ->
const Action * {
8490 assert(!S->getInputs().empty() &&
"unexpected root action!");
8491 S = S->getInputs()[0];
8495 const Action *SourceAction = FindSource(&JA);
8499 bool WantDebug =
false;
8500 Args.ClaimAllArgs(options::OPT_g_Group);
8501 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8502 WantDebug = !A->getOption().matches(options::OPT_g0) &&
8503 !A->getOption().matches(options::OPT_ggdb0);
8505 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
8506 llvm::codegenoptions::NoDebugInfo;
8509 const char *DebugCompilationDir =
8512 if (SourceAction->
getType() == types::TY_Asm ||
8513 SourceAction->
getType() == types::TY_PP_Asm) {
8518 DebugInfoKind = (WantDebug ? llvm::codegenoptions::DebugInfoConstructor
8519 : llvm::codegenoptions::NoDebugInfo);
8526 CmdArgs.push_back(
"-dwarf-debug-producer");
8530 Args.AddAllArgs(CmdArgs, options::OPT_I);
8534 llvm::DebuggerKind::Default);
8540 llvm::Reloc::Model RelocationModel;
8543 std::tie(RelocationModel, PICLevel, IsPIE) =
8548 CmdArgs.push_back(
"-mrelocation-model");
8549 CmdArgs.push_back(RMName);
8555 ArgStringList OriginalArgs;
8556 for (
const auto &Arg : Args)
8557 Arg->render(Args, OriginalArgs);
8562 for (
const char *OriginalArg : OriginalArgs) {
8566 Flags += EscapedArg;
8568 CmdArgs.push_back(
"-dwarf-debug-flags");
8569 CmdArgs.push_back(Args.MakeArgString(Flags));
8579 case llvm::Triple::mips:
8580 case llvm::Triple::mipsel:
8581 case llvm::Triple::mips64:
8582 case llvm::Triple::mips64el:
8586 case llvm::Triple::x86:
8587 case llvm::Triple::x86_64:
8591 case llvm::Triple::arm:
8592 case llvm::Triple::armeb:
8593 case llvm::Triple::thumb:
8594 case llvm::Triple::thumbeb:
8597 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8598 options::OPT_mno_default_build_attributes,
true)) {
8599 CmdArgs.push_back(
"-mllvm");
8600 CmdArgs.push_back(
"-arm-add-build-attributes");
8604 case llvm::Triple::aarch64:
8605 case llvm::Triple::aarch64_32:
8606 case llvm::Triple::aarch64_be:
8607 if (Args.hasArg(options::OPT_mmark_bti_property)) {
8608 CmdArgs.push_back(
"-mllvm");
8609 CmdArgs.push_back(
"-aarch64-mark-bti-property");
8613 case llvm::Triple::loongarch32:
8614 case llvm::Triple::loongarch64:
8618 case llvm::Triple::riscv32:
8619 case llvm::Triple::riscv64:
8623 case llvm::Triple::hexagon:
8624 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8625 options::OPT_mno_default_build_attributes,
true)) {
8626 CmdArgs.push_back(
"-mllvm");
8627 CmdArgs.push_back(
"-hexagon-add-build-attributes");
8637 Args.ClaimAllArgs(options::OPT_W_Group);
8642 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
8644 if (DebugInfoKind > llvm::codegenoptions::NoDebugInfo && Output.
isFilename())
8651 if (SourceAction != FindSource(&J.getSource()))
8653 auto &JArgs = J.getArguments();
8654 for (
unsigned I = 0; I < JArgs.size(); ++I) {
8655 if (StringRef(JArgs[I]).starts_with(
"-object-file-name=") &&
8657 ArgStringList NewArgs(JArgs.begin(), JArgs.begin() + I);
8660 NewArgs.append(JArgs.begin() + I + 1, JArgs.end());
8661 J.replaceArguments(NewArgs);
8667 assert(Output.
isFilename() &&
"Unexpected lipo output.");
8668 CmdArgs.push_back(
"-o");
8674 T.isOSBinFormatELF()) {
8675 CmdArgs.push_back(
"-split-dwarf-output");
8679 if (Triple.isAMDGPU())
8682 assert(Input.
isFilename() &&
"Invalid input.");
8688 C.addCommand(std::make_unique<CC1Command>(
8692 C.addCommand(std::make_unique<Command>(
8702 const llvm::opt::ArgList &TCArgs,
8703 const char *LinkingOutput)
const {
8705 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
8715 ArgStringList CmdArgs;
8718 CmdArgs.push_back(TCArgs.MakeArgString(
8721 assert(JA.
getInputs().size() == Inputs.size() &&
8722 "Not have inputs for all dependence actions??");
8726 Triples +=
"-targets=";
8727 for (
unsigned I = 0; I < Inputs.size(); ++I) {
8736 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
8738 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
8739 assert(CurTC ==
nullptr &&
"Expected one dependence!");
8746 Triples += CurTC->
getTriple().normalize();
8755 StringRef GPUArchName;
8758 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
8759 auto ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
8760 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
8762 GPUArchName = ArchStr.substr(7);
8767 Triples += GPUArchName.str();
8770 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
8774 TCArgs.MakeArgString(Twine(
"-output=") + Output.
getFilename()));
8777 for (
unsigned I = 0; I < Inputs.size(); ++I) {
8783 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
8785 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
8786 assert(CurTC ==
nullptr &&
"Expected one dependence!");
8789 UB +=
C.addTempFile(
8794 CmdArgs.push_back(TCArgs.MakeArgString(UB));
8798 C.addCommand(std::make_unique<Command>(
8801 CmdArgs, std::nullopt, Output));
8806 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
8807 const char *LinkingOutput)
const {
8809 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
8820 ArgStringList CmdArgs;
8822 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
8826 CmdArgs.push_back(TCArgs.MakeArgString(
8831 Triples +=
"-targets=";
8832 auto DepInfo = UA.getDependentActionsInfo();
8833 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
8837 auto &Dep = DepInfo[I];
8840 Triples += Dep.DependentToolChain->getTriple().normalize();
8843 !Dep.DependentBoundArch.empty()) {
8845 Triples += Dep.DependentBoundArch;
8849 StringRef GPUArchName;
8852 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
8853 StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
8854 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
8856 GPUArchName = ArchStr.substr(7);
8861 Triples += GPUArchName.str();
8865 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
8869 TCArgs.MakeArgString(Twine(
"-input=") + Input.
getFilename()));
8872 for (
unsigned I = 0; I < Outputs.size(); ++I) {
8875 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
8876 CmdArgs.push_back(TCArgs.MakeArgString(UB));
8878 CmdArgs.push_back(
"-unbundle");
8879 CmdArgs.push_back(
"-allow-missing-bundles");
8880 if (TCArgs.hasArg(options::OPT_v))
8881 CmdArgs.push_back(
"-verbose");
8884 C.addCommand(std::make_unique<Command>(
8887 CmdArgs, std::nullopt, Outputs));
8893 const llvm::opt::ArgList &Args,
8894 const char *LinkingOutput)
const {
8895 ArgStringList CmdArgs;
8898 assert(Output.
isFilename() &&
"Invalid output.");
8899 CmdArgs.push_back(
"-o");
8906 const ArgList &TCArgs =
8912 : TCArgs.getLastArgValue(options::OPT_march_EQ);
8916 ArgStringList Features;
8920 llvm::copy_if(Features, std::back_inserter(FeatureArgs),
8921 [](StringRef Arg) {
return !Arg.starts_with(
"-target"); });
8924 for (StringRef Feature : llvm::split(Arch.split(
':').second,
':')) {
8925 FeatureArgs.emplace_back(
8926 Args.MakeArgString(Feature.take_back() + Feature.drop_back()));
8933 "file=" +
File.str(),
8935 "arch=" + Arch.str(),
8936 "kind=" + Kind.str(),
8941 for (StringRef Feature : FeatureArgs)
8942 Parts.emplace_back(
"feature=" + Feature.str());
8944 CmdArgs.push_back(Args.MakeArgString(
"--image=" + llvm::join(Parts,
",")));
8947 C.addCommand(std::make_unique<Command>(
8950 CmdArgs, Inputs, Output));
8956 const ArgList &Args,
8957 const char *LinkingOutput)
const {
8960 ArgStringList CmdArgs;
8964 auto TCRange =
C.getOffloadToolChains(Kind);
8965 for (
auto &I : llvm::make_range(TCRange.first, TCRange.second)) {
8969 if (CudaInstallation.
isValid())
8970 CmdArgs.push_back(Args.MakeArgString(
8978 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
8980 if (A->getOption().matches(options::OPT_O4) ||
8981 A->getOption().matches(options::OPT_Ofast))
8983 else if (A->getOption().matches(options::OPT_O)) {
8984 OOpt = A->getValue();
8987 else if (OOpt ==
"s" || OOpt ==
"z")
8989 }
else if (A->getOption().matches(options::OPT_O0))
8992 CmdArgs.push_back(Args.MakeArgString(Twine(
"--opt-level=O") + OOpt));
8996 Args.MakeArgString(
"--host-triple=" + TheTriple.getTriple()));
8997 if (Args.hasArg(options::OPT_v))
8998 CmdArgs.push_back(
"--wrapper-verbose");
9000 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
9001 if (!A->getOption().matches(options::OPT_g0))
9002 CmdArgs.push_back(
"--device-debug");
9007 if (
const Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
9008 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
9009 CmdArgs.push_back(Args.MakeArgString(
9010 Twine(
"--amdhsa-code-object-version=") + A->getValue()));
9013 for (
const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
9014 CmdArgs.push_back(Args.MakeArgString(
"--ptxas-arg=" + A));
9017 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
9018 CmdArgs.push_back(Args.MakeArgString(Twine(
"--offload-opt=-pass-remarks=") +
9020 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
9021 CmdArgs.push_back(Args.MakeArgString(
9022 Twine(
"--offload-opt=-pass-remarks-missed=") + A->getValue()));
9023 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
9024 CmdArgs.push_back(Args.MakeArgString(
9025 Twine(
"--offload-opt=-pass-remarks-analysis=") + A->getValue()));
9026 if (Args.getLastArg(options::OPT_save_temps_EQ))
9027 CmdArgs.push_back(
"--save-temps");
9030 Linker->
ConstructJob(
C, JA, Output, Inputs, Args, LinkingOutput);
9031 const auto &LinkCommand =
C.getJobs().getJobs().back();
9034 for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) {
9035 StringRef Val = A->getValue(0);
9038 Args.MakeArgString(Twine(
"--device-linker=") + A->getValue(1)));
9040 CmdArgs.push_back(Args.MakeArgString(
9041 "--device-linker=" +
9045 Args.ClaimAllArgs(options::OPT_Xoffload_linker);
9048 if (Args.hasFlag(options::OPT_fopenmp_target_jit,
9049 options::OPT_fno_openmp_target_jit,
false))
9050 CmdArgs.push_back(
"--embed-bitcode");
9053 for (Arg *A : Args.filtered(options::OPT_mllvm)) {
9054 CmdArgs.push_back(
"-mllvm");
9055 CmdArgs.push_back(A->getValue());
9060 CmdArgs.push_back(Args.MakeArgString(Twine(
"--linker-path=") +
9061 LinkCommand->getExecutable()));
9062 for (
const char *LinkArg : LinkCommand->getArguments())
9063 CmdArgs.push_back(LinkArg);
9068 Args.MakeArgString(
getToolChain().GetProgramPath(
"clang-linker-wrapper"));
9072 LinkCommand->replaceExecutable(Exec);
9073 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()