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/RISCVISAInfo.h"
58#include "llvm/Support/YAMLParser.h"
59#include "llvm/TargetParser/ARMTargetParserCommon.h"
60#include "llvm/TargetParser/Host.h"
61#include "llvm/TargetParser/LoongArchTargetParser.h"
62#include "llvm/TargetParser/RISCVTargetParser.h"
71 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
72 options::OPT_fminimize_whitespace,
73 options::OPT_fno_minimize_whitespace,
74 options::OPT_fkeep_system_includes,
75 options::OPT_fno_keep_system_includes)) {
76 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
77 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
78 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
79 << A->getBaseArg().getAsString(Args)
80 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
87 if (Args.hasArg(options::OPT_static))
89 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
90 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
117 llvm::function_ref<
void(
const ToolChain &)> Work) {
119 Work(RegularToolChain);
134 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
149 const Arg &A,
size_t &Position) {
150 const char RefinementStepToken =
':';
151 Position = In.find(RefinementStepToken);
152 if (Position != StringRef::npos) {
153 StringRef Option = A.getOption().getName();
154 StringRef RefStep = In.substr(Position + 1);
162 if (RefStep.size() != 1) {
163 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
166 char RefStepChar = RefStep[0];
167 if (RefStepChar <
'0' || RefStepChar >
'9') {
168 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
177 ArgStringList &OutStrings) {
178 StringRef DisabledPrefixIn =
"!";
179 StringRef DisabledPrefixOut =
"!";
180 StringRef EnabledPrefixOut =
"";
181 StringRef Out =
"-mrecip=";
183 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
187 unsigned NumOptions = A->getNumValues();
188 if (NumOptions == 0) {
190 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
195 if (NumOptions == 1) {
196 StringRef Val = A->getValue(0);
200 StringRef ValBase = Val.slice(0, RefStepLoc);
201 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
202 OutStrings.push_back(Args.MakeArgString(Out + Val));
211 llvm::StringMap<bool> OptionStrings;
212 OptionStrings.insert(std::make_pair(
"divd",
false));
213 OptionStrings.insert(std::make_pair(
"divf",
false));
214 OptionStrings.insert(std::make_pair(
"divh",
false));
215 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
216 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
217 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
218 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
219 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
220 OptionStrings.insert(std::make_pair(
"sqrth",
false));
221 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
222 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
223 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
225 for (
unsigned i = 0; i != NumOptions; ++i) {
226 StringRef Val = A->getValue(i);
228 bool IsDisabled = Val.starts_with(DisabledPrefixIn);
237 StringRef ValBase = Val.slice(0, RefStep);
238 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
239 if (OptionIter == OptionStrings.end()) {
241 OptionIter = OptionStrings.find(ValBase.str() +
'f');
242 if (OptionIter == OptionStrings.end()) {
244 D.
Diag(diag::err_drv_unknown_argument) << Val;
250 if (OptionStrings[ValBase.str() +
'd'] ||
251 OptionStrings[ValBase.str() +
'h']) {
252 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
257 if (OptionIter->second ==
true) {
259 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
264 OptionIter->second =
true;
268 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
269 OptionStrings[ValBase.str() +
'd'] =
true;
270 OptionStrings[ValBase.str() +
'h'] =
true;
274 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
275 Out = Args.MakeArgString(Out + Prefix + Val);
276 if (i != NumOptions - 1)
277 Out = Args.MakeArgString(Out +
",");
280 OutStrings.push_back(Args.MakeArgString(Out));
286 ArgStringList &CmdArgs) {
287 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
291 StringRef
Value = A->getValue();
292 if (
Value ==
"none") {
293 CmdArgs.push_back(
"-mprefer-vector-width=none");
296 if (
Value.getAsInteger(10, Width)) {
297 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
300 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
306 const llvm::Triple &Triple) {
313 if (!Triple.isMacOSX())
316 return (!Triple.isMacOSXVersionLT(10, 5) &&
317 (Triple.getArch() == llvm::Triple::x86_64 ||
318 Triple.getArch() == llvm::Triple::arm));
328 ArgStringList &CmdArgs) {
329 const llvm::Triple &Triple = TC.
getTriple();
334 Args.ClaimAllArgs(options::OPT_fexceptions);
335 Args.ClaimAllArgs(options::OPT_fno_exceptions);
336 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
337 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
338 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
339 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
340 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
341 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
346 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
349 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
350 options::OPT_fno_async_exceptions,
false);
352 CmdArgs.push_back(
"-fasync-exceptions");
359 Args.hasFlag(options::OPT_fobjc_exceptions,
360 options::OPT_fno_objc_exceptions,
true)) {
361 CmdArgs.push_back(
"-fobjc-exceptions");
368 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
369 !Triple.isPS() && !Triple.isDriverKit();
370 Arg *ExceptionArg = Args.getLastArg(
371 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
372 options::OPT_fexceptions, options::OPT_fno_exceptions);
374 CXXExceptionsEnabled =
375 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
376 ExceptionArg->getOption().matches(options::OPT_fexceptions);
378 if (CXXExceptionsEnabled) {
379 CmdArgs.push_back(
"-fcxx-exceptions");
388 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
390 Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,
391 options::OPT_fno_assume_nothrow_exception_dtor);
394 CmdArgs.push_back(
"-fexceptions");
410 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
416 ArgStringList &CmdArgs,
417 const llvm::vfs::FileSystem &VFS) {
418 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
419 options::OPT_fdebug_compilation_dir_EQ)) {
420 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
421 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
424 A->render(Args, CmdArgs);
425 }
else if (llvm::ErrorOr<std::string> CWD =
426 VFS.getCurrentWorkingDirectory()) {
427 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
429 StringRef Path(CmdArgs.back());
430 return Path.substr(Path.find(
'=') + 1).data();
434 const char *DebugCompilationDir,
435 const char *OutputFileName) {
437 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
438 if (StringRef(Arg->getValue()).starts_with(
"-object-file-name"))
441 if (Args.hasArg(options::OPT_object_file_name_EQ))
445 if (ObjFileNameForDebug !=
"-" &&
446 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
447 (!DebugCompilationDir ||
448 llvm::sys::path::is_absolute(DebugCompilationDir))) {
450 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
456 llvm::sys::path::Style Style =
457 llvm::sys::path::is_absolute(ObjFileNameForDebug)
458 ? llvm::sys::path::Style::native
459 : llvm::sys::path::Style::windows_backslash;
460 llvm::sys::path::remove_dots(ObjFileNameForDebug,
true,
463 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
468 const ArgList &Args, ArgStringList &CmdArgs) {
469 auto AddOneArg = [&](StringRef Map, StringRef Name) {
470 if (!Map.contains(
'='))
471 D.
Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
473 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
476 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
477 options::OPT_fdebug_prefix_map_EQ)) {
478 AddOneArg(A->getValue(), A->getOption().getName());
482 if (GlobalRemapEntry.empty())
484 AddOneArg(GlobalRemapEntry,
"environment");
489 ArgStringList &CmdArgs) {
490 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
491 options::OPT_fmacro_prefix_map_EQ)) {
492 StringRef Map = A->getValue();
493 if (!Map.contains(
'='))
494 D.
Diag(diag::err_drv_invalid_argument_to_option)
495 << Map << A->getOption().getName();
497 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
504 ArgStringList &CmdArgs) {
505 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
506 options::OPT_fcoverage_prefix_map_EQ)) {
507 StringRef Map = A->getValue();
508 if (!Map.contains(
'='))
509 D.
Diag(diag::err_drv_invalid_argument_to_option)
510 << Map << A->getOption().getName();
512 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
521 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
522 if (A->getOption().matches(options::OPT_O4) ||
523 A->getOption().matches(options::OPT_Ofast))
526 if (A->getOption().matches(options::OPT_O0))
529 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
532 StringRef S(A->getValue());
540 unsigned OptLevel = 0;
541 if (S.getAsInteger(10, OptLevel))
552 ArgStringList &CmdArgs) {
555 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
558 CmdArgs.push_back(
"-x");
559 if (Args.hasArg(options::OPT_rewrite_objc))
565 const char *ClangType;
567 case types::TY_CXXModule:
570 case types::TY_PP_CXXModule:
571 ClangType =
"c++-cpp-output";
577 CmdArgs.push_back(ClangType);
584 ArgStringList &CmdArgs) {
586 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
587 options::OPT_fprofile_generate_EQ,
588 options::OPT_fno_profile_generate);
589 if (PGOGenerateArg &&
590 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
591 PGOGenerateArg =
nullptr;
595 auto *ProfileGenerateArg = Args.getLastArg(
596 options::OPT_fprofile_instr_generate,
597 options::OPT_fprofile_instr_generate_EQ,
598 options::OPT_fno_profile_instr_generate);
599 if (ProfileGenerateArg &&
600 ProfileGenerateArg->getOption().matches(
601 options::OPT_fno_profile_instr_generate))
602 ProfileGenerateArg =
nullptr;
604 if (PGOGenerateArg && ProfileGenerateArg)
605 D.
Diag(diag::err_drv_argument_not_allowed_with)
606 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
610 if (PGOGenerateArg && ProfileUseArg)
611 D.
Diag(diag::err_drv_argument_not_allowed_with)
612 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
614 if (ProfileGenerateArg && ProfileUseArg)
615 D.
Diag(diag::err_drv_argument_not_allowed_with)
616 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
618 if (CSPGOGenerateArg && PGOGenerateArg) {
619 D.
Diag(diag::err_drv_argument_not_allowed_with)
620 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
621 PGOGenerateArg =
nullptr;
626 D.
Diag(diag::err_drv_unsupported_opt_for_target)
627 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
630 if (ProfileGenerateArg) {
631 if (ProfileGenerateArg->getOption().matches(
632 options::OPT_fprofile_instr_generate_EQ))
633 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
634 ProfileGenerateArg->getValue()));
636 CmdArgs.push_back(
"-fprofile-instrument=clang");
637 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
639 CmdArgs.push_back(Args.MakeArgString(
644 Arg *PGOGenArg =
nullptr;
645 if (PGOGenerateArg) {
646 assert(!CSPGOGenerateArg);
647 PGOGenArg = PGOGenerateArg;
648 CmdArgs.push_back(
"-fprofile-instrument=llvm");
650 if (CSPGOGenerateArg) {
651 assert(!PGOGenerateArg);
652 PGOGenArg = CSPGOGenerateArg;
653 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
656 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
658 CmdArgs.push_back(Args.MakeArgString(
661 if (PGOGenArg->getOption().matches(
662 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
663 : options::OPT_fcs_profile_generate_EQ)) {
665 llvm::sys::path::append(Path,
"default_%m.profraw");
667 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
672 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
673 CmdArgs.push_back(Args.MakeArgString(
674 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
675 else if ((ProfileUseArg->getOption().matches(
676 options::OPT_fprofile_use_EQ) ||
677 ProfileUseArg->getOption().matches(
678 options::OPT_fprofile_instr_use))) {
680 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
681 if (Path.empty() || llvm::sys::fs::is_directory(Path))
682 llvm::sys::path::append(Path,
"default.profdata");
684 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
688 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
689 options::OPT_fno_test_coverage,
false) ||
690 Args.hasArg(options::OPT_coverage);
693 if (Args.hasFlag(options::OPT_fcoverage_mapping,
694 options::OPT_fno_coverage_mapping,
false)) {
695 if (!ProfileGenerateArg)
696 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
697 <<
"-fcoverage-mapping"
698 <<
"-fprofile-instr-generate";
700 CmdArgs.push_back(
"-fcoverage-mapping");
703 if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
705 if (!Args.hasFlag(options::OPT_fcoverage_mapping,
706 options::OPT_fno_coverage_mapping,
false))
707 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
709 <<
"-fcoverage-mapping";
711 CmdArgs.push_back(
"-fcoverage-mcdc");
714 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
715 options::OPT_fcoverage_compilation_dir_EQ)) {
716 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
717 CmdArgs.push_back(Args.MakeArgString(
718 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
720 A->render(Args, CmdArgs);
721 }
else if (llvm::ErrorOr<std::string> CWD =
722 D.
getVFS().getCurrentWorkingDirectory()) {
723 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
726 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
727 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
728 if (!Args.hasArg(options::OPT_coverage))
729 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
730 <<
"-fprofile-exclude-files="
733 StringRef
v = Arg->getValue();
735 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
738 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
739 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
740 if (!Args.hasArg(options::OPT_coverage))
741 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
742 <<
"-fprofile-filter-files="
745 StringRef
v = Arg->getValue();
746 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
749 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
750 StringRef Val = A->getValue();
751 if (Val ==
"atomic" || Val ==
"prefer-atomic")
752 CmdArgs.push_back(
"-fprofile-update=atomic");
753 else if (Val !=
"single")
754 D.
Diag(diag::err_drv_unsupported_option_argument)
755 << A->getSpelling() << Val;
758 int FunctionGroups = 1;
759 int SelectedFunctionGroup = 0;
760 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
761 StringRef Val = A->getValue();
762 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
763 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
766 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
767 StringRef Val = A->getValue();
768 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
769 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
770 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
772 if (FunctionGroups != 1)
773 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
774 Twine(FunctionGroups)));
775 if (SelectedFunctionGroup != 0)
776 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
777 Twine(SelectedFunctionGroup)));
783 Arg *FProfileDir =
nullptr;
784 if (Args.hasArg(options::OPT_fprofile_arcs) ||
785 Args.hasArg(options::OPT_coverage))
786 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
790 (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
795 if (EmitCovNotes || EmitCovData) {
797 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
800 CoverageFilename = DumpDir->getValue();
801 CoverageFilename += llvm::sys::path::filename(Output.
getBaseInput());
802 }
else if (Arg *FinalOutput =
803 C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
804 CoverageFilename = FinalOutput->getValue();
805 }
else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o)) {
806 CoverageFilename = FinalOutput->getValue();
808 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
810 if (llvm::sys::path::is_relative(CoverageFilename))
811 (void)D.
getVFS().makeAbsolute(CoverageFilename);
812 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
815 Args.MakeArgString(
"-coverage-notes-file=" + CoverageFilename));
821 CoverageFilename = FProfileDir->getValue();
822 llvm::sys::path::append(CoverageFilename, Gcno);
824 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
826 Args.MakeArgString(
"-coverage-data-file=" + CoverageFilename));
833 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
842 bool RelaxDefault =
true;
844 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
845 RelaxDefault = A->getOption().matches(options::OPT_O0);
848 RelaxDefault =
false;
849 for (
const auto &Act :
C.getActions()) {
857 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
863 llvm::codegenoptions::DebugInfoKind DebugInfoKind,
864 unsigned DwarfVersion,
865 llvm::DebuggerKind DebuggerTuning) {
867 if (DwarfVersion > 0)
869 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
870 switch (DebuggerTuning) {
871 case llvm::DebuggerKind::GDB:
872 CmdArgs.push_back(
"-debugger-tuning=gdb");
874 case llvm::DebuggerKind::LLDB:
875 CmdArgs.push_back(
"-debugger-tuning=lldb");
877 case llvm::DebuggerKind::SCE:
878 CmdArgs.push_back(
"-debugger-tuning=sce");
880 case llvm::DebuggerKind::DBX:
881 CmdArgs.push_back(
"-debugger-tuning=dbx");
890 assert(A &&
"Expected non-nullptr argument.");
893 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
899 ArgStringList &CmdArgs,
902 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
906 StringRef
Value = A->getValue();
907 if (
Value ==
"none") {
908 CmdArgs.push_back(
"--compress-debug-sections=none");
909 }
else if (
Value ==
"zlib") {
910 if (llvm::compression::zlib::isAvailable()) {
912 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
914 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
916 }
else if (
Value ==
"zstd") {
917 if (llvm::compression::zstd::isAvailable()) {
919 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
921 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
924 D.
Diag(diag::err_drv_unsupported_option_argument)
925 << A->getSpelling() <<
Value;
932 ArgStringList &CmdArgs,
933 bool IsCC1As =
false) {
941 CmdArgs.insert(CmdArgs.begin() + 1,
942 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
944 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
947 CmdArgs.insert(CmdArgs.begin() + 1,
948 Args.MakeArgString(Twine(
"-mcode-object-version=") +
954 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MemBuf =
955 D.
getVFS().getBufferForFile(Path);
958 llvm::file_magic Magic = llvm::identify_magic((*MemBuf)->getBuffer());
959 if (Magic == llvm::file_magic::unknown)
963 if (Magic == llvm::file_magic::clang_ast)
966 llvm::object::ObjectFile::createObjectFile(**MemBuf, Magic);
967 return !Obj.takeError();
971 llvm::ErrorOr<llvm::vfs::Status> Status = D.
getVFS().status(Path);
975 if (Status->isDirectory()) {
977 for (llvm::vfs::directory_iterator DI = D.
getVFS().dir_begin(Path, EC), DE;
978 !EC && DI != DE; DI = DI.increment(EC)) {
982 D.
Diag(diag::warn_drv_pch_ignoring_gch_dir) << Path;
988 D.
Diag(diag::warn_drv_pch_ignoring_gch_file) << Path;
993 const Driver &D,
const ArgList &Args,
994 ArgStringList &CmdArgs,
1001 Args.AddLastArg(CmdArgs, options::OPT_C);
1002 Args.AddLastArg(CmdArgs, options::OPT_CC);
1005 Arg *ArgM = Args.getLastArg(options::OPT_MM);
1007 ArgM = Args.getLastArg(options::OPT_M);
1008 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1010 ArgMD = Args.getLastArg(options::OPT_MD);
1014 CmdArgs.push_back(
"-w");
1020 const char *DepFile;
1021 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1022 DepFile = MF->getValue();
1023 C.addFailureResultFile(DepFile, &JA);
1024 }
else if (Output.
getType() == types::TY_Dependencies) {
1026 }
else if (!ArgMD) {
1030 C.addFailureResultFile(DepFile, &JA);
1032 CmdArgs.push_back(
"-dependency-file");
1033 CmdArgs.push_back(DepFile);
1035 bool HasTarget =
false;
1036 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1039 if (A->getOption().matches(options::OPT_MT)) {
1040 A->render(Args, CmdArgs);
1042 CmdArgs.push_back(
"-MT");
1045 CmdArgs.push_back(Args.MakeArgString(Quoted));
1051 const char *DepTarget;
1055 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1056 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1057 DepTarget = OutputOpt->getValue();
1063 llvm::sys::path::replace_extension(
P,
"o");
1064 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1067 CmdArgs.push_back(
"-MT");
1070 CmdArgs.push_back(Args.MakeArgString(Quoted));
1073 if (ArgM->getOption().matches(options::OPT_M) ||
1074 ArgM->getOption().matches(options::OPT_MD))
1075 CmdArgs.push_back(
"-sys-header-deps");
1076 if ((isa<PrecompileJobAction>(JA) &&
1077 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1078 Args.hasArg(options::OPT_fmodule_file_deps))
1079 CmdArgs.push_back(
"-module-file-deps");
1082 if (Args.hasArg(options::OPT_MG)) {
1083 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1084 ArgM->getOption().matches(options::OPT_MMD))
1085 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1086 CmdArgs.push_back(
"-MG");
1089 Args.AddLastArg(CmdArgs, options::OPT_MP);
1090 Args.AddLastArg(CmdArgs, options::OPT_MV);
1103 if (!Args.hasArg(options::OPT_nostdinc) &&
1104 !Args.hasArg(options::OPT_nogpuinc) &&
1105 !Args.hasArg(options::OPT_nobuiltininc)) {
1113 llvm::sys::path::append(
P,
"include");
1114 llvm::sys::path::append(
P,
getToolChain().getTripleString());
1115 CmdArgs.push_back(
"-internal-isystem");
1116 CmdArgs.push_back(Args.MakeArgString(
P));
1121 llvm::sys::path::append(
P,
"include");
1122 llvm::sys::path::append(
P,
"llvm_libc_wrappers");
1123 CmdArgs.push_back(
"-internal-isystem");
1124 CmdArgs.push_back(Args.MakeArgString(
P));
1131 !Args.hasArg(options::OPT_nostdinc) &&
1132 !Args.hasArg(options::OPT_nogpuinc) &&
1135 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1139 llvm::sys::path::append(
P,
"include");
1140 llvm::sys::path::append(
P,
"openmp_wrappers");
1141 CmdArgs.push_back(
"-internal-isystem");
1142 CmdArgs.push_back(Args.MakeArgString(
P));
1145 CmdArgs.push_back(
"-include");
1146 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1156 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1157 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1160 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1163 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1164 options::OPT_fno_pch_instantiate_templates,
true))
1165 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1167 if (YcArg || YuArg) {
1168 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1169 if (!isa<PrecompileJobAction>(JA)) {
1170 CmdArgs.push_back(
"-include-pch");
1172 C, !ThroughHeader.empty()
1174 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1177 if (ThroughHeader.empty()) {
1178 CmdArgs.push_back(Args.MakeArgString(
1179 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1182 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1187 bool RenderedImplicitInclude =
false;
1188 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1189 if (A->getOption().matches(options::OPT_include) &&
1192 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1193 RenderedImplicitInclude =
true;
1195 bool FoundPCH =
false;
1200 llvm::sys::path::replace_extension(
P,
"pch");
1206 llvm::sys::path::replace_extension(
P,
"gch");
1211 if (IsFirstImplicitInclude) {
1213 CmdArgs.push_back(
"-include-pch");
1214 CmdArgs.push_back(Args.MakeArgString(
P));
1218 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1219 << A->getAsString(Args);
1222 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1229 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1232 }
else if (A->getOption().matches(options::OPT_ibuiltininc)) {
1239 A->render(Args, CmdArgs);
1242 Args.addAllArgs(CmdArgs,
1243 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1244 options::OPT_F, options::OPT_index_header_map});
1252 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1253 options::OPT_Xpreprocessor);
1256 if (Arg *A = Args.getLastArg(options::OPT_I_))
1257 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1261 StringRef sysroot =
C.getSysRoot();
1262 if (sysroot !=
"") {
1263 if (!Args.hasArg(options::OPT_isysroot)) {
1264 CmdArgs.push_back(
"-isysroot");
1265 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1282 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1290 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1293 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1302 [&Args, &CmdArgs](
const ToolChain &TC) {
1313 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1314 options::OPT_fno_file_reproducible);
1316 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1317 CmdArgs.push_back(
"-source-date-epoch");
1318 CmdArgs.push_back(Args.MakeArgString(Epoch));
1321 Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,
1322 options::OPT_fno_define_target_os_macros);
1327 switch (Triple.getArch()) {
1331 case llvm::Triple::aarch64:
1332 case llvm::Triple::aarch64_32:
1333 case llvm::Triple::aarch64_be:
1334 case llvm::Triple::arm:
1335 case llvm::Triple::armeb:
1336 case llvm::Triple::thumb:
1337 case llvm::Triple::thumbeb:
1338 if (Triple.isOSDarwin() || Triple.isOSWindows())
1342 case llvm::Triple::ppc:
1343 case llvm::Triple::ppc64:
1344 if (Triple.isOSDarwin())
1348 case llvm::Triple::hexagon:
1349 case llvm::Triple::ppcle:
1350 case llvm::Triple::ppc64le:
1351 case llvm::Triple::riscv32:
1352 case llvm::Triple::riscv64:
1353 case llvm::Triple::systemz:
1354 case llvm::Triple::xcore:
1360 const ArgList &Args) {
1363 if (!Triple.isOSDarwin())
1367 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1371 const llvm::Triple &Triple) {
1376 bool hasExplicitOutputFile =
1377 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1379 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1380 <<
"-foptimization-record-file";
1387 const llvm::Triple &Triple,
1390 StringRef Format =
"yaml";
1391 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1392 Format = A->getValue();
1394 CmdArgs.push_back(
"-opt-record-file");
1396 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1398 CmdArgs.push_back(A->getValue());
1400 bool hasMultipleArchs =
1401 Triple.isOSDarwin() &&
1402 Args.getAllArgValues(options::OPT_arch).size() > 1;
1406 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1407 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1408 F = FinalOutput->getValue();
1410 if (Format !=
"yaml" &&
1411 Triple.isOSDarwin() &&
1425 llvm::sys::path::replace_extension(F,
"");
1427 Triple.normalize());
1437 if (hasMultipleArchs) {
1441 llvm::sys::path::replace_extension(F,
"");
1444 F += Triple.getArchName();
1446 llvm::sys::path::replace_extension(F, OldExtension);
1450 Extension +=
"opt.";
1451 Extension += Format;
1453 llvm::sys::path::replace_extension(F, Extension);
1454 CmdArgs.push_back(Args.MakeArgString(F));
1458 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1459 CmdArgs.push_back(
"-opt-record-passes");
1460 CmdArgs.push_back(A->getValue());
1463 if (!Format.empty()) {
1464 CmdArgs.push_back(
"-opt-record-format");
1465 CmdArgs.push_back(Format.data());
1470 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1471 options::OPT_fno_aapcs_bitfield_width,
true))
1472 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1474 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1475 CmdArgs.push_back(
"-faapcs-bitfield-load");
1479void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1480 const ArgList &Args, ArgStringList &CmdArgs) {
1484 const char *ABIName =
nullptr;
1485 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1486 ABIName = A->getValue();
1488 std::string CPU =
getCPUName(D, Args, Triple,
false);
1489 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1492 CmdArgs.push_back(
"-target-abi");
1493 CmdArgs.push_back(ABIName);
1496void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1497 auto StrictAlignIter =
1498 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1499 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1501 if (StrictAlignIter != CmdArgs.rend() &&
1502 StringRef(*StrictAlignIter) ==
"+strict-align")
1503 CmdArgs.push_back(
"-Wunaligned-access");
1508 ArgStringList &CmdArgs,
bool isAArch64) {
1509 const Arg *A = isAArch64
1510 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1511 options::OPT_mbranch_protection_EQ)
1512 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1518 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1519 D.
Diag(diag::warn_incompatible_branch_protection_option)
1520 << Triple.getArchName();
1522 StringRef
Scope, Key;
1523 bool IndirectBranches, BranchProtectionPAuthLR, GuardedControlStack;
1525 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1526 Scope = A->getValue();
1528 D.
Diag(diag::err_drv_unsupported_option_argument)
1529 << A->getSpelling() <<
Scope;
1531 IndirectBranches =
false;
1532 BranchProtectionPAuthLR =
false;
1533 GuardedControlStack =
false;
1536 llvm::ARM::ParsedBranchProtection PBP;
1537 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg))
1538 D.
Diag(diag::err_drv_unsupported_option_argument)
1539 << A->getSpelling() << DiagMsg;
1540 if (!isAArch64 && PBP.Key ==
"b_key")
1541 D.
Diag(diag::warn_unsupported_branch_protection)
1542 <<
"b-key" << A->getAsString(Args);
1545 BranchProtectionPAuthLR = PBP.BranchProtectionPAuthLR;
1546 IndirectBranches = PBP.BranchTargetEnforcement;
1547 GuardedControlStack = PBP.GuardedControlStack;
1551 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1552 if (!
Scope.equals(
"none"))
1554 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1555 if (BranchProtectionPAuthLR)
1557 Args.MakeArgString(Twine(
"-mbranch-protection-pauth-lr")));
1558 if (IndirectBranches)
1559 CmdArgs.push_back(
"-mbranch-target-enforce");
1560 if (GuardedControlStack)
1561 CmdArgs.push_back(
"-mguarded-control-stack");
1564void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1565 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1566 RenderARMABI(
getToolChain().getDriver(), Triple, Args, CmdArgs);
1573 CmdArgs.push_back(
"-msoft-float");
1574 CmdArgs.push_back(
"-mfloat-abi");
1575 CmdArgs.push_back(
"soft");
1578 CmdArgs.push_back(
"-mfloat-abi");
1579 CmdArgs.push_back(
"soft");
1583 CmdArgs.push_back(
"-mfloat-abi");
1584 CmdArgs.push_back(
"hard");
1588 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1589 options::OPT_mno_global_merge)) {
1590 CmdArgs.push_back(
"-mllvm");
1591 if (A->getOption().matches(options::OPT_mno_global_merge))
1592 CmdArgs.push_back(
"-arm-global-merge=false");
1594 CmdArgs.push_back(
"-arm-global-merge=true");
1597 if (!Args.hasFlag(options::OPT_mimplicit_float,
1598 options::OPT_mno_implicit_float,
true))
1599 CmdArgs.push_back(
"-no-implicit-float");
1601 if (Args.getLastArg(options::OPT_mcmse))
1602 CmdArgs.push_back(
"-mcmse");
1609 AddUnalignedAccessWarning(CmdArgs);
1612void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1613 const ArgList &Args,
bool KernelOrKext,
1614 ArgStringList &CmdArgs)
const {
1625 case llvm::Triple::arm:
1626 case llvm::Triple::armeb:
1627 case llvm::Triple::thumb:
1628 case llvm::Triple::thumbeb:
1630 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1633 case llvm::Triple::aarch64:
1634 case llvm::Triple::aarch64_32:
1635 case llvm::Triple::aarch64_be:
1636 AddAArch64TargetArgs(Args, CmdArgs);
1639 case llvm::Triple::loongarch32:
1640 case llvm::Triple::loongarch64:
1641 AddLoongArchTargetArgs(Args, CmdArgs);
1644 case llvm::Triple::mips:
1645 case llvm::Triple::mipsel:
1646 case llvm::Triple::mips64:
1647 case llvm::Triple::mips64el:
1648 AddMIPSTargetArgs(Args, CmdArgs);
1651 case llvm::Triple::ppc:
1652 case llvm::Triple::ppcle:
1653 case llvm::Triple::ppc64:
1654 case llvm::Triple::ppc64le:
1655 AddPPCTargetArgs(Args, CmdArgs);
1658 case llvm::Triple::riscv32:
1659 case llvm::Triple::riscv64:
1660 AddRISCVTargetArgs(Args, CmdArgs);
1663 case llvm::Triple::sparc:
1664 case llvm::Triple::sparcel:
1665 case llvm::Triple::sparcv9:
1666 AddSparcTargetArgs(Args, CmdArgs);
1669 case llvm::Triple::systemz:
1670 AddSystemZTargetArgs(Args, CmdArgs);
1673 case llvm::Triple::x86:
1674 case llvm::Triple::x86_64:
1675 AddX86TargetArgs(Args, CmdArgs);
1678 case llvm::Triple::lanai:
1679 AddLanaiTargetArgs(Args, CmdArgs);
1682 case llvm::Triple::hexagon:
1683 AddHexagonTargetArgs(Args, CmdArgs);
1686 case llvm::Triple::wasm32:
1687 case llvm::Triple::wasm64:
1688 AddWebAssemblyTargetArgs(Args, CmdArgs);
1691 case llvm::Triple::ve:
1692 AddVETargetArgs(Args, CmdArgs);
1698void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1699 ArgStringList &CmdArgs) {
1700 const char *ABIName =
nullptr;
1701 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1702 ABIName = A->getValue();
1703 else if (Triple.isOSDarwin())
1704 ABIName =
"darwinpcs";
1708 CmdArgs.push_back(
"-target-abi");
1709 CmdArgs.push_back(ABIName);
1713void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1714 ArgStringList &CmdArgs)
const {
1717 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1718 Args.hasArg(options::OPT_mkernel) ||
1719 Args.hasArg(options::OPT_fapple_kext))
1720 CmdArgs.push_back(
"-disable-red-zone");
1722 if (!Args.hasFlag(options::OPT_mimplicit_float,
1723 options::OPT_mno_implicit_float,
true))
1724 CmdArgs.push_back(
"-no-implicit-float");
1726 RenderAArch64ABI(Triple, Args, CmdArgs);
1729 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1730 options::OPT_mno_global_merge)) {
1731 CmdArgs.push_back(
"-mllvm");
1732 if (A->getOption().matches(options::OPT_mno_global_merge))
1733 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1735 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1742 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1743 StringRef Val = A->getValue();
1745 if (Val.equals(
"128") || Val.equals(
"256") || Val.equals(
"512") ||
1746 Val.equals(
"1024") || Val.equals(
"2048") || Val.equals(
"128+") ||
1747 Val.equals(
"256+") || Val.equals(
"512+") || Val.equals(
"1024+") ||
1748 Val.equals(
"2048+")) {
1750 if (!Val.consume_back(
"+")) {
1752 assert(!
Invalid &&
"Failed to parse value");
1754 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1758 assert(!
Invalid &&
"Failed to parse value");
1760 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1762 }
else if (!Val.equals(
"scalable"))
1764 D.
Diag(diag::err_drv_unsupported_option_argument)
1765 << A->getSpelling() << Val;
1770 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1771 CmdArgs.push_back(
"-tune-cpu");
1772 if (strcmp(A->getValue(),
"native") == 0)
1773 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1775 CmdArgs.push_back(A->getValue());
1778 AddUnalignedAccessWarning(CmdArgs);
1780 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
1781 options::OPT_fno_ptrauth_intrinsics);
1784void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1785 ArgStringList &CmdArgs)
const {
1788 CmdArgs.push_back(
"-target-abi");
1794 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1795 std::string TuneCPU = A->getValue();
1797 CmdArgs.push_back(
"-tune-cpu");
1798 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1802void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1803 ArgStringList &CmdArgs)
const {
1810 CmdArgs.push_back(
"-target-abi");
1811 CmdArgs.push_back(ABIName.data());
1816 CmdArgs.push_back(
"-msoft-float");
1817 CmdArgs.push_back(
"-mfloat-abi");
1818 CmdArgs.push_back(
"soft");
1822 CmdArgs.push_back(
"-mfloat-abi");
1823 CmdArgs.push_back(
"hard");
1826 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1827 options::OPT_mno_ldc1_sdc1)) {
1828 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1829 CmdArgs.push_back(
"-mllvm");
1830 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1834 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1835 options::OPT_mno_check_zero_division)) {
1836 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1837 CmdArgs.push_back(
"-mllvm");
1838 CmdArgs.push_back(
"-mno-check-zero-division");
1842 if (Args.getLastArg(options::OPT_mfix4300)) {
1843 CmdArgs.push_back(
"-mllvm");
1844 CmdArgs.push_back(
"-mfix4300");
1847 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1848 StringRef
v = A->getValue();
1849 CmdArgs.push_back(
"-mllvm");
1850 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1854 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1856 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1869 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1871 llvm::Reloc::Model RelocationModel;
1874 std::tie(RelocationModel, PICLevel, IsPIE) =
1877 NoABICalls = NoABICalls ||
1878 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1880 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1882 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1883 CmdArgs.push_back(
"-mllvm");
1884 CmdArgs.push_back(
"-mgpopt");
1886 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1887 options::OPT_mno_local_sdata);
1888 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1889 options::OPT_mno_extern_sdata);
1890 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1891 options::OPT_mno_embedded_data);
1893 CmdArgs.push_back(
"-mllvm");
1894 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1895 CmdArgs.push_back(
"-mlocal-sdata=1");
1897 CmdArgs.push_back(
"-mlocal-sdata=0");
1899 LocalSData->claim();
1903 CmdArgs.push_back(
"-mllvm");
1904 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1905 CmdArgs.push_back(
"-mextern-sdata=1");
1907 CmdArgs.push_back(
"-mextern-sdata=0");
1909 ExternSData->claim();
1913 CmdArgs.push_back(
"-mllvm");
1914 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1915 CmdArgs.push_back(
"-membedded-data=1");
1917 CmdArgs.push_back(
"-membedded-data=0");
1919 EmbeddedData->claim();
1922 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1923 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1928 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1929 StringRef Val = StringRef(A->getValue());
1931 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1932 CmdArgs.push_back(
"-mllvm");
1933 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1935 D.
Diag(diag::err_drv_unsupported_option_argument)
1936 << A->getSpelling() << Val;
1938 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1941 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1942 options::OPT_mno_relax_pic_calls)) {
1943 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1944 CmdArgs.push_back(
"-mllvm");
1945 CmdArgs.push_back(
"-mips-jalr-reloc=0");
1950void Clang::AddPPCTargetArgs(
const ArgList &Args,
1951 ArgStringList &CmdArgs)
const {
1954 if (Args.getLastArg(options::OPT_mtune_EQ)) {
1955 CmdArgs.push_back(
"-tune-cpu");
1957 CmdArgs.push_back(Args.MakeArgString(CPU));
1961 const char *ABIName =
nullptr;
1962 if (T.isOSBinFormatELF()) {
1964 case llvm::Triple::ppc64: {
1965 if (T.isPPC64ELFv2ABI())
1971 case llvm::Triple::ppc64le:
1980 bool VecExtabi =
false;
1981 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
1982 StringRef
V = A->getValue();
1983 if (
V ==
"ieeelongdouble") {
1984 IEEELongDouble =
true;
1986 }
else if (
V ==
"ibmlongdouble") {
1987 IEEELongDouble =
false;
1989 }
else if (
V ==
"vec-default") {
1992 }
else if (
V ==
"vec-extabi") {
1995 }
else if (
V ==
"elfv1") {
1998 }
else if (
V ==
"elfv2") {
2001 }
else if (
V !=
"altivec")
2005 ABIName = A->getValue();
2008 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2011 D.
Diag(diag::err_drv_unsupported_opt_for_target)
2012 <<
"-mabi=vec-extabi" << T.str();
2013 CmdArgs.push_back(
"-mabi=vec-extabi");
2019 CmdArgs.push_back(
"-msoft-float");
2020 CmdArgs.push_back(
"-mfloat-abi");
2021 CmdArgs.push_back(
"soft");
2025 CmdArgs.push_back(
"-mfloat-abi");
2026 CmdArgs.push_back(
"hard");
2030 CmdArgs.push_back(
"-target-abi");
2031 CmdArgs.push_back(ABIName);
2036 ArgStringList &CmdArgs) {
2038 const llvm::Triple &Triple = TC.
getTriple();
2040 const char *SmallDataLimit =
"8";
2042 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2043 options::OPT_fPIC)) {
2045 SmallDataLimit =
"0";
2046 if (Args.hasArg(options::OPT_G)) {
2047 D.
Diag(diag::warn_drv_unsupported_sdata);
2049 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2050 .equals_insensitive(
"large") &&
2051 (Triple.getArch() == llvm::Triple::riscv64)) {
2053 SmallDataLimit =
"0";
2054 if (Args.hasArg(options::OPT_G)) {
2055 D.
Diag(diag::warn_drv_unsupported_sdata);
2057 }
else if (Triple.isAndroid()) {
2059 SmallDataLimit =
"0";
2060 if (Args.hasArg(options::OPT_G)) {
2061 D.
Diag(diag::warn_drv_unsupported_sdata);
2063 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2064 SmallDataLimit = A->getValue();
2067 CmdArgs.push_back(
"-msmall-data-limit");
2068 CmdArgs.push_back(SmallDataLimit);
2071void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2072 ArgStringList &CmdArgs)
const {
2076 CmdArgs.push_back(
"-target-abi");
2077 CmdArgs.push_back(ABIName.data());
2081 if (!Args.hasFlag(options::OPT_mimplicit_float,
2082 options::OPT_mno_implicit_float,
true))
2083 CmdArgs.push_back(
"-no-implicit-float");
2085 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2086 CmdArgs.push_back(
"-tune-cpu");
2087 if (strcmp(A->getValue(),
"native") == 0)
2088 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2090 CmdArgs.push_back(A->getValue());
2094 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2095 StringRef Val = A->getValue();
2099 unsigned MinVLen = 0;
2101 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
2104 if (!errorToBool(ISAInfo.takeError()))
2105 MinVLen = (*ISAInfo)->getMinVLen();
2110 if (Val.equals(
"zvl") && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
2112 }
else if (!Val.getAsInteger(10, Bits)) {
2115 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
2116 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
2122 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
2124 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
2126 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
2127 }
else if (!Val.equals(
"scalable")) {
2129 D.
Diag(diag::err_drv_unsupported_option_argument)
2130 << A->getSpelling() << Val;
2135void Clang::AddSparcTargetArgs(
const ArgList &Args,
2136 ArgStringList &CmdArgs)
const {
2142 CmdArgs.push_back(
"-msoft-float");
2143 CmdArgs.push_back(
"-mfloat-abi");
2144 CmdArgs.push_back(
"soft");
2148 CmdArgs.push_back(
"-mfloat-abi");
2149 CmdArgs.push_back(
"hard");
2152 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2153 StringRef Name = A->getValue();
2154 std::string TuneCPU;
2155 if (Name ==
"native")
2156 TuneCPU = std::string(llvm::sys::getHostCPUName());
2158 TuneCPU = std::string(Name);
2160 CmdArgs.push_back(
"-tune-cpu");
2161 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2165void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2166 ArgStringList &CmdArgs)
const {
2167 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2168 CmdArgs.push_back(
"-tune-cpu");
2169 if (strcmp(A->getValue(),
"native") == 0)
2170 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2172 CmdArgs.push_back(A->getValue());
2176 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2177 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2178 options::OPT_mno_packed_stack,
false);
2182 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2184 D.
Diag(diag::err_drv_unsupported_opt)
2185 <<
"-mpacked-stack -mbackchain -mhard-float";
2188 CmdArgs.push_back(
"-mbackchain");
2190 CmdArgs.push_back(
"-mpacked-stack");
2193 CmdArgs.push_back(
"-msoft-float");
2194 CmdArgs.push_back(
"-mfloat-abi");
2195 CmdArgs.push_back(
"soft");
2199void Clang::AddX86TargetArgs(
const ArgList &Args,
2200 ArgStringList &CmdArgs)
const {
2204 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2205 Args.hasArg(options::OPT_mkernel) ||
2206 Args.hasArg(options::OPT_fapple_kext))
2207 CmdArgs.push_back(
"-disable-red-zone");
2209 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2210 options::OPT_mno_tls_direct_seg_refs,
true))
2211 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2215 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2216 Args.hasArg(options::OPT_fapple_kext));
2217 if (Arg *A = Args.getLastArg(
2218 options::OPT_msoft_float, options::OPT_mno_soft_float,
2219 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2220 const Option &O = A->getOption();
2221 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2222 O.matches(options::OPT_msoft_float));
2224 if (NoImplicitFloat)
2225 CmdArgs.push_back(
"-no-implicit-float");
2227 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2228 StringRef
Value = A->getValue();
2230 CmdArgs.push_back(
"-mllvm");
2231 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2232 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2234 D.
Diag(diag::err_drv_unsupported_option_argument)
2235 << A->getSpelling() <<
Value;
2238 CmdArgs.push_back(
"-mllvm");
2239 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2242 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2243 options::OPT_mno_skip_rax_setup))
2244 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2245 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2248 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2249 CmdArgs.push_back(
"-mfloat-abi");
2250 CmdArgs.push_back(
"soft");
2251 CmdArgs.push_back(
"-mstack-alignment=4");
2257 std::string TuneCPU;
2258 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2260 TuneCPU =
"generic";
2263 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2264 StringRef Name = A->getValue();
2266 if (Name ==
"native") {
2267 Name = llvm::sys::getHostCPUName();
2269 TuneCPU = std::string(Name);
2271 TuneCPU = std::string(Name);
2274 if (!TuneCPU.empty()) {
2275 CmdArgs.push_back(
"-tune-cpu");
2276 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2280void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2281 ArgStringList &CmdArgs)
const {
2282 CmdArgs.push_back(
"-mqdsp6-compat");
2283 CmdArgs.push_back(
"-Wreturn-type");
2286 CmdArgs.push_back(
"-mllvm");
2288 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2291 if (!Args.hasArg(options::OPT_fno_short_enums))
2292 CmdArgs.push_back(
"-fshort-enums");
2293 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2294 CmdArgs.push_back(
"-mllvm");
2295 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2297 CmdArgs.push_back(
"-mllvm");
2298 CmdArgs.push_back(
"-machine-sink-split=0");
2301void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2302 ArgStringList &CmdArgs)
const {
2303 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2304 StringRef CPUName = A->getValue();
2306 CmdArgs.push_back(
"-target-cpu");
2307 CmdArgs.push_back(Args.MakeArgString(CPUName));
2309 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2310 StringRef
Value = A->getValue();
2314 if (
Value.getAsInteger(10, Mregparm)) {
2315 if (Mregparm != 4) {
2317 diag::err_drv_unsupported_option_argument)
2318 << A->getSpelling() <<
Value;
2324void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2325 ArgStringList &CmdArgs)
const {
2327 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2328 options::OPT_fvisibility_ms_compat))
2329 CmdArgs.push_back(
"-fvisibility=hidden");
2332void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2334 CmdArgs.push_back(
"-mfloat-abi");
2335 CmdArgs.push_back(
"hard");
2340 const InputInfo &Input,
const ArgList &Args)
const {
2342 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2345 using llvm::yaml::escape;
2348 if (!CompilationDatabase) {
2350 auto File = std::make_unique<llvm::raw_fd_ostream>(
2352 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2354 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2358 CompilationDatabase = std::move(
File);
2360 auto &CDB = *CompilationDatabase;
2361 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2364 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2365 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2367 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2372 CDB <<
", \"" << escape(Buf) <<
"\"";
2373 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2376 CDB <<
", \"" << escape(Buf) <<
"\"";
2378 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2380 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2381 for (
auto &A: Args) {
2382 auto &O = A->getOption();
2384 if (O.getID() == options::OPT_x)
2387 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2389 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2392 if (O.getKind() == Option::InputClass)
2395 if (O.getID() == options::OPT_o)
2399 A->render(Args, ASL);
2401 CDB <<
", \"" << escape(it) <<
"\"";
2405 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2408void Clang::DumpCompilationDatabaseFragmentToDir(
2410 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2412 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2415 if (CompilationDatabase)
2416 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2419 const auto &
Driver =
C.getDriver();
2421 auto Err = llvm::sys::fs::create_directory(Path,
true);
2423 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2427 llvm::sys::path::append(
2429 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2432 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2433 llvm::sys::fs::OF_Text);
2435 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2438 CompilationDatabase =
2439 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2440 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2450 CmdArgs.push_back(
"-mllvm");
2451 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2455 const ArgList &Args,
2456 ArgStringList &CmdArgs,
2459 CmdArgs.push_back(
"-mrelax-all");
2463 bool DefaultIncrementalLinkerCompatible =
2464 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2465 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2466 options::OPT_mno_incremental_linker_compatible,
2467 DefaultIncrementalLinkerCompatible))
2468 CmdArgs.push_back(
"-mincremental-linker-compatible");
2470 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2472 Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2473 options::OPT_fno_emit_compact_unwind_non_canonical);
2483 bool TakeNextArg =
false;
2485 bool UseRelaxRelocations =
C.getDefaultToolChain().useRelaxRelocations();
2486 bool UseNoExecStack =
false;
2487 const char *MipsTargetFeature =
nullptr;
2488 StringRef ImplicitIt;
2490 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2491 options::OPT_mimplicit_it_EQ)) {
2494 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2495 switch (
C.getDefaultToolChain().getArch()) {
2496 case llvm::Triple::arm:
2497 case llvm::Triple::armeb:
2498 case llvm::Triple::thumb:
2499 case llvm::Triple::thumbeb:
2501 ImplicitIt = A->getValue();
2503 D.
Diag(diag::err_drv_unsupported_option_argument)
2504 << A->getSpelling() << ImplicitIt;
2511 for (StringRef
Value : A->getValues()) {
2513 CmdArgs.push_back(
Value.data());
2514 TakeNextArg =
false;
2518 if (
C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2519 Value ==
"-mbig-obj")
2522 switch (
C.getDefaultToolChain().getArch()) {
2525 case llvm::Triple::wasm32:
2526 case llvm::Triple::wasm64:
2527 if (
Value ==
"--no-type-check") {
2528 CmdArgs.push_back(
"-mno-type-check");
2532 case llvm::Triple::thumb:
2533 case llvm::Triple::thumbeb:
2534 case llvm::Triple::arm:
2535 case llvm::Triple::armeb:
2536 if (
Value.starts_with(
"-mimplicit-it=")) {
2538 ImplicitIt =
Value.split(
"=").second;
2542 if (
Value ==
"-mthumb")
2547 case llvm::Triple::mips:
2548 case llvm::Triple::mipsel:
2549 case llvm::Triple::mips64:
2550 case llvm::Triple::mips64el:
2551 if (
Value ==
"--trap") {
2552 CmdArgs.push_back(
"-target-feature");
2553 CmdArgs.push_back(
"+use-tcc-in-div");
2556 if (
Value ==
"--break") {
2557 CmdArgs.push_back(
"-target-feature");
2558 CmdArgs.push_back(
"-use-tcc-in-div");
2561 if (
Value.starts_with(
"-msoft-float")) {
2562 CmdArgs.push_back(
"-target-feature");
2563 CmdArgs.push_back(
"+soft-float");
2566 if (
Value.starts_with(
"-mhard-float")) {
2567 CmdArgs.push_back(
"-target-feature");
2568 CmdArgs.push_back(
"-soft-float");
2572 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2573 .Case(
"-mips1",
"+mips1")
2574 .Case(
"-mips2",
"+mips2")
2575 .Case(
"-mips3",
"+mips3")
2576 .Case(
"-mips4",
"+mips4")
2577 .Case(
"-mips5",
"+mips5")
2578 .Case(
"-mips32",
"+mips32")
2579 .Case(
"-mips32r2",
"+mips32r2")
2580 .Case(
"-mips32r3",
"+mips32r3")
2581 .Case(
"-mips32r5",
"+mips32r5")
2582 .Case(
"-mips32r6",
"+mips32r6")
2583 .Case(
"-mips64",
"+mips64")
2584 .Case(
"-mips64r2",
"+mips64r2")
2585 .Case(
"-mips64r3",
"+mips64r3")
2586 .Case(
"-mips64r5",
"+mips64r5")
2587 .Case(
"-mips64r6",
"+mips64r6")
2589 if (MipsTargetFeature)
2593 if (
Value ==
"-force_cpusubtype_ALL") {
2595 }
else if (
Value ==
"-L") {
2596 CmdArgs.push_back(
"-msave-temp-labels");
2597 }
else if (
Value ==
"--fatal-warnings") {
2598 CmdArgs.push_back(
"-massembler-fatal-warnings");
2599 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2600 CmdArgs.push_back(
"-massembler-no-warn");
2601 }
else if (
Value ==
"--noexecstack") {
2602 UseNoExecStack =
true;
2603 }
else if (
Value.starts_with(
"-compress-debug-sections") ||
2604 Value.starts_with(
"--compress-debug-sections") ||
2605 Value ==
"-nocompress-debug-sections" ||
2606 Value ==
"--nocompress-debug-sections") {
2607 CmdArgs.push_back(
Value.data());
2608 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2609 Value ==
"--mrelax-relocations=yes") {
2610 UseRelaxRelocations =
true;
2611 }
else if (
Value ==
"-mrelax-relocations=no" ||
2612 Value ==
"--mrelax-relocations=no") {
2613 UseRelaxRelocations =
false;
2614 }
else if (
Value.starts_with(
"-I")) {
2615 CmdArgs.push_back(
Value.data());
2620 }
else if (
Value.starts_with(
"-gdwarf-")) {
2623 if (DwarfVersion == 0) {
2624 CmdArgs.push_back(
Value.data());
2627 llvm::codegenoptions::DebugInfoConstructor,
2628 DwarfVersion, llvm::DebuggerKind::Default);
2630 }
else if (
Value.starts_with(
"-mcpu") ||
Value.starts_with(
"-mfpu") ||
2631 Value.starts_with(
"-mhwdiv") ||
Value.starts_with(
"-march")) {
2633 }
else if (
Value ==
"-defsym") {
2634 if (A->getNumValues() != 2) {
2635 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2638 const char *S = A->getValue(1);
2639 auto Pair = StringRef(S).split(
'=');
2640 auto Sym = Pair.first;
2641 auto SVal = Pair.second;
2643 if (Sym.empty() || SVal.empty()) {
2644 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2648 if (SVal.getAsInteger(0, IVal)) {
2649 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2652 CmdArgs.push_back(
Value.data());
2654 }
else if (
Value ==
"-fdebug-compilation-dir") {
2655 CmdArgs.push_back(
"-fdebug-compilation-dir");
2657 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2661 CmdArgs.push_back(
"-fdebug-compilation-dir");
2662 CmdArgs.push_back(
Value.data());
2663 }
else if (
Value ==
"--version") {
2666 D.
Diag(diag::err_drv_unsupported_option_argument)
2667 << A->getSpelling() <<
Value;
2671 if (ImplicitIt.size())
2673 if (!UseRelaxRelocations)
2674 CmdArgs.push_back(
"-mrelax-relocations=no");
2676 CmdArgs.push_back(
"-mnoexecstack");
2677 if (MipsTargetFeature !=
nullptr) {
2678 CmdArgs.push_back(
"-target-feature");
2679 CmdArgs.push_back(MipsTargetFeature);
2683 if (
C.getDriver().embedBitcodeEnabled() ||
2684 C.getDriver().embedBitcodeMarkerOnly())
2685 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2687 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2688 CmdArgs.push_back(
"-as-secure-log-file");
2689 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2720 if ((str1.compare(str2) != 0) && !str2.empty() && !str1.empty()) {
2721 D.
Diag(clang::diag::warn_drv_overriding_option) << str1 << str2;
2728 if (!ComplexRangeStr.empty())
2729 return "-complex-range=" + ComplexRangeStr;
2730 return ComplexRangeStr;
2734 bool OFastEnabled,
const ArgList &Args,
2735 ArgStringList &CmdArgs,
2742 bool HonorINFs =
true;
2743 bool HonorNaNs =
true;
2744 bool ApproxFunc =
false;
2747 bool AssociativeMath =
false;
2748 bool ReciprocalMath =
false;
2749 bool SignedZeros =
true;
2750 bool TrappingMath =
false;
2751 bool TrappingMathPresent =
false;
2753 bool RoundingFPMath =
false;
2754 bool RoundingMathPresent =
false;
2756 StringRef FPModel =
"";
2758 StringRef FPExceptionBehavior =
"";
2760 StringRef FPEvalMethod =
"";
2761 const llvm::DenormalMode DefaultDenormalFPMath =
2763 const llvm::DenormalMode DefaultDenormalFP32Math =
2766 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
2767 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
2770 StringRef FPContract;
2771 StringRef LastSeenFfpContractOption;
2772 bool SeenUnsafeMathModeOption =
false;
2776 bool StrictFPModel =
false;
2777 StringRef Float16ExcessPrecision =
"";
2778 StringRef BFloat16ExcessPrecision =
"";
2780 std::string ComplexRangeStr =
"";
2781 std::string GccRangeComplexOption =
"";
2784 auto applyFastMath = [&]() {
2788 AssociativeMath =
true;
2789 ReciprocalMath =
true;
2791 SignedZeros =
false;
2792 TrappingMath =
false;
2793 RoundingFPMath =
false;
2794 FPExceptionBehavior =
"";
2796 FPContract =
"fast";
2806 !GccRangeComplexOption.empty()
2807 ? GccRangeComplexOption
2810 SeenUnsafeMathModeOption =
true;
2813 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2814 CmdArgs.push_back(
"-mlimit-float-precision");
2815 CmdArgs.push_back(A->getValue());
2818 for (
const Arg *A : Args) {
2819 auto optID = A->getOption().getID();
2820 bool PreciseFPModel =
false;
2824 case options::OPT_fcx_limited_range:
2825 if (GccRangeComplexOption.empty()) {
2828 "-fcx-limited-range");
2830 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
2833 GccRangeComplexOption =
"-fcx-limited-range";
2836 case options::OPT_fno_cx_limited_range:
2837 if (GccRangeComplexOption.empty()) {
2839 "-fno-cx-limited-range");
2841 if (GccRangeComplexOption.compare(
"-fcx-limited-range") != 0 &&
2842 GccRangeComplexOption.compare(
"-fno-cx-fortran-rules") != 0)
2844 "-fno-cx-limited-range");
2846 GccRangeComplexOption =
"-fno-cx-limited-range";
2849 case options::OPT_fcx_fortran_rules:
2850 if (GccRangeComplexOption.empty())
2852 "-fcx-fortran-rules");
2855 GccRangeComplexOption =
"-fcx-fortran-rules";
2858 case options::OPT_fno_cx_fortran_rules:
2859 if (GccRangeComplexOption.empty()) {
2861 "-fno-cx-fortran-rules");
2863 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
2865 "-fno-cx-fortran-rules");
2867 GccRangeComplexOption =
"-fno-cx-fortran-rules";
2870 case options::OPT_fcomplex_arithmetic_EQ: {
2872 StringRef Val = A->getValue();
2873 if (Val.equals(
"full"))
2875 else if (Val.equals(
"improved"))
2877 else if (Val.equals(
"promoted"))
2879 else if (Val.equals(
"basic"))
2882 D.
Diag(diag::err_drv_unsupported_option_argument)
2883 << A->getSpelling() << Val;
2886 if (!GccRangeComplexOption.empty()) {
2887 if (GccRangeComplexOption.compare(
"-fcx-limited-range") != 0) {
2888 if (GccRangeComplexOption.compare(
"-fcx-fortran-rules") != 0) {
2905 case options::OPT_ffp_model_EQ: {
2912 AssociativeMath =
false;
2913 ReciprocalMath =
false;
2917 DenormalFPMath = llvm::DenormalMode::getIEEE();
2921 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2923 StringRef Val = A->getValue();
2924 if (OFastEnabled && !Val.equals(
"fast")) {
2926 D.
Diag(clang::diag::warn_drv_overriding_option)
2927 << Args.MakeArgString(
"-ffp-model=" + Val) <<
"-Ofast";
2930 StrictFPModel =
false;
2931 PreciseFPModel =
true;
2935 if (!FPModel.empty() && !FPModel.equals(Val))
2936 D.
Diag(clang::diag::warn_drv_overriding_option)
2937 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2938 << Args.MakeArgString(
"-ffp-model=" + Val);
2939 if (Val.equals(
"fast")) {
2942 }
else if (Val.equals(
"precise")) {
2943 optID = options::OPT_ffp_contract;
2946 PreciseFPModel =
true;
2947 }
else if (Val.equals(
"strict")) {
2948 StrictFPModel =
true;
2949 optID = options::OPT_frounding_math;
2950 FPExceptionBehavior =
"strict";
2953 TrappingMath =
true;
2955 D.
Diag(diag::err_drv_unsupported_option_argument)
2956 << A->getSpelling() << Val;
2966 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2967 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2968 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2969 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2970 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2971 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2972 case options::OPT_fmath_errno: MathErrno =
true;
break;
2973 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2974 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2975 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2976 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2977 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2978 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2979 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2980 case options::OPT_ftrapping_math:
2981 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2982 !FPExceptionBehavior.equals(
"strict"))
2984 D.
Diag(clang::diag::warn_drv_overriding_option)
2985 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2986 FPExceptionBehavior)
2987 <<
"-ftrapping-math";
2988 TrappingMath =
true;
2989 TrappingMathPresent =
true;
2990 FPExceptionBehavior =
"strict";
2992 case options::OPT_fno_trapping_math:
2993 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2994 !FPExceptionBehavior.equals(
"ignore"))
2996 D.
Diag(clang::diag::warn_drv_overriding_option)
2997 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2998 FPExceptionBehavior)
2999 <<
"-fno-trapping-math";
3000 TrappingMath =
false;
3001 TrappingMathPresent =
true;
3002 FPExceptionBehavior =
"ignore";
3005 case options::OPT_frounding_math:
3006 RoundingFPMath =
true;
3007 RoundingMathPresent =
true;
3010 case options::OPT_fno_rounding_math:
3011 RoundingFPMath =
false;
3012 RoundingMathPresent =
false;
3015 case options::OPT_fdenormal_fp_math_EQ:
3016 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
3017 DenormalFP32Math = DenormalFPMath;
3018 if (!DenormalFPMath.isValid()) {
3019 D.
Diag(diag::err_drv_invalid_value)
3020 << A->getAsString(Args) << A->getValue();
3024 case options::OPT_fdenormal_fp_math_f32_EQ:
3025 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
3026 if (!DenormalFP32Math.isValid()) {
3027 D.
Diag(diag::err_drv_invalid_value)
3028 << A->getAsString(Args) << A->getValue();
3033 case options::OPT_ffp_contract: {
3034 StringRef Val = A->getValue();
3035 if (PreciseFPModel) {
3040 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off") ||
3041 Val.equals(
"fast-honor-pragmas")) {
3043 LastSeenFfpContractOption = Val;
3045 D.
Diag(diag::err_drv_unsupported_option_argument)
3046 << A->getSpelling() << Val;
3051 case options::OPT_ffp_model_EQ:
3058 case options::OPT_ffp_exception_behavior_EQ: {
3059 StringRef Val = A->getValue();
3060 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
3061 !FPExceptionBehavior.equals(Val))
3063 D.
Diag(clang::diag::warn_drv_overriding_option)
3064 << Args.MakeArgString(
"-ffp-exception-behavior=" +
3065 FPExceptionBehavior)
3066 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
3067 TrappingMath = TrappingMathPresent =
false;
3068 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
3069 FPExceptionBehavior = Val;
3070 else if (Val.equals(
"strict")) {
3071 FPExceptionBehavior = Val;
3072 TrappingMath = TrappingMathPresent =
true;
3074 D.
Diag(diag::err_drv_unsupported_option_argument)
3075 << A->getSpelling() << Val;
3080 case options::OPT_ffp_eval_method_EQ: {
3081 StringRef Val = A->getValue();
3082 if (Val.equals(
"double") || Val.equals(
"extended") ||
3083 Val.equals(
"source"))
3086 D.
Diag(diag::err_drv_unsupported_option_argument)
3087 << A->getSpelling() << Val;
3091 case options::OPT_fexcess_precision_EQ: {
3092 StringRef Val = A->getValue();
3093 const llvm::Triple::ArchType Arch = TC.
getArch();
3094 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
3095 if (Val.equals(
"standard") || Val.equals(
"fast"))
3096 Float16ExcessPrecision = Val;
3100 else if (Val.equals(
"16"))
3101 Float16ExcessPrecision =
"none";
3103 D.
Diag(diag::err_drv_unsupported_option_argument)
3104 << A->getSpelling() << Val;
3106 if (!(Val.equals(
"standard") || Val.equals(
"fast")))
3107 D.
Diag(diag::err_drv_unsupported_option_argument)
3108 << A->getSpelling() << Val;
3110 BFloat16ExcessPrecision = Float16ExcessPrecision;
3113 case options::OPT_ffinite_math_only:
3117 case options::OPT_fno_finite_math_only:
3122 case options::OPT_funsafe_math_optimizations:
3123 AssociativeMath =
true;
3124 ReciprocalMath =
true;
3125 SignedZeros =
false;
3127 TrappingMath =
false;
3128 FPExceptionBehavior =
"";
3129 FPContract =
"fast";
3130 SeenUnsafeMathModeOption =
true;
3132 case options::OPT_fno_unsafe_math_optimizations:
3133 AssociativeMath =
false;
3134 ReciprocalMath =
false;
3137 TrappingMath =
true;
3138 FPExceptionBehavior =
"strict";
3141 DenormalFPMath = llvm::DenormalMode::getIEEE();
3142 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3145 if (LastSeenFfpContractOption !=
"") {
3146 FPContract = LastSeenFfpContractOption;
3147 }
else if (SeenUnsafeMathModeOption)
3152 case options::OPT_Ofast:
3157 case options::OPT_ffast_math: {
3161 case options::OPT_fno_fast_math:
3168 AssociativeMath =
false;
3169 ReciprocalMath =
false;
3173 DenormalFPMath = DefaultDenormalFPMath;
3174 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3177 if (LastSeenFfpContractOption !=
"") {
3178 FPContract = LastSeenFfpContractOption;
3179 }
else if (SeenUnsafeMathModeOption)
3184 if (StrictFPModel) {
3187 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3188 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3189 DenormalFPMath == llvm::DenormalMode::getIEEE() &&
3190 DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
3191 FPContract.equals(
"off"))
3195 StrictFPModel =
false;
3197 auto RHS = (A->getNumValues() == 0)
3199 : Args.MakeArgString(A->getSpelling() + A->getValue());
3200 if (RHS !=
"-ffp-model=strict")
3201 D.
Diag(clang::diag::warn_drv_overriding_option)
3202 <<
"-ffp-model=strict" << RHS;
3211 CmdArgs.push_back(
"-menable-no-infs");
3214 CmdArgs.push_back(
"-menable-no-nans");
3217 CmdArgs.push_back(
"-fapprox-func");
3220 CmdArgs.push_back(
"-fmath-errno");
3222 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3224 CmdArgs.push_back(
"-funsafe-math-optimizations");
3227 CmdArgs.push_back(
"-fno-signed-zeros");
3229 if (AssociativeMath && !SignedZeros && !TrappingMath)
3230 CmdArgs.push_back(
"-mreassociate");
3233 CmdArgs.push_back(
"-freciprocal-math");
3237 assert(FPExceptionBehavior.equals(
"strict"));
3241 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3243 llvm::raw_svector_ostream ArgStr(DenormFlag);
3244 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3245 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3249 if (DenormalFP32Math != DenormalFPMath) {
3251 llvm::raw_svector_ostream ArgStr(DenormFlag);
3252 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3253 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3256 if (!FPContract.empty())
3257 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3259 if (!RoundingFPMath)
3260 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3262 if (RoundingFPMath && RoundingMathPresent)
3263 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3265 if (!FPExceptionBehavior.empty())
3266 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3267 FPExceptionBehavior));
3269 if (!FPEvalMethod.empty())
3270 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3272 if (!Float16ExcessPrecision.empty())
3273 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3274 Float16ExcessPrecision));
3275 if (!BFloat16ExcessPrecision.empty())
3276 CmdArgs.push_back(Args.MakeArgString(
"-fbfloat16-excess-precision=" +
3277 BFloat16ExcessPrecision));
3284 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3285 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3286 CmdArgs.push_back(
"-ffast-math");
3287 if (FPModel.equals(
"fast")) {
3288 if (FPContract.equals(
"fast"))
3291 else if (FPContract.empty())
3293 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3295 D.
Diag(clang::diag::warn_drv_overriding_option)
3296 <<
"-ffp-model=fast"
3297 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3302 if (!HonorINFs && !HonorNaNs)
3303 CmdArgs.push_back(
"-ffinite-math-only");
3305 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3306 CmdArgs.push_back(
"-mfpmath");
3307 CmdArgs.push_back(A->getValue());
3311 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3312 options::OPT_fstrict_float_cast_overflow,
false))
3313 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3317 if (!ComplexRangeStr.empty()) {
3318 CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
3319 if (Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))
3320 CmdArgs.push_back(Args.MakeArgString(
"-fcomplex-arithmetic=" +
3323 if (Args.hasArg(options::OPT_fcx_limited_range))
3324 CmdArgs.push_back(
"-fcx-limited-range");
3325 if (Args.hasArg(options::OPT_fcx_fortran_rules))
3326 CmdArgs.push_back(
"-fcx-fortran-rules");
3327 if (Args.hasArg(options::OPT_fno_cx_limited_range))
3328 CmdArgs.push_back(
"-fno-cx-limited-range");
3329 if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
3330 CmdArgs.push_back(
"-fno-cx-fortran-rules");
3334 const llvm::Triple &Triple,
3337 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3338 CmdArgs.push_back(
"-analyzer-checker=core");
3339 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3341 if (!Triple.isWindowsMSVCEnvironment()) {
3342 CmdArgs.push_back(
"-analyzer-checker=unix");
3345 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3346 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3347 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3348 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3349 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3350 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3354 if (Triple.isPS()) {
3355 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3356 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3359 if (Triple.isOSDarwin()) {
3360 CmdArgs.push_back(
"-analyzer-checker=osx");
3362 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3364 else if (Triple.isOSFuchsia())
3365 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3367 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3370 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3372 if (!Triple.isPS()) {
3373 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3374 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3375 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3376 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3377 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3378 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3382 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3383 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3387 CmdArgs.push_back(
"-analyzer-output");
3388 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3389 CmdArgs.push_back(A->getValue());
3391 CmdArgs.push_back(
"plist");
3396 CmdArgs.push_back(
"-w");
3399 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3406 if (std::isdigit(S[0]))
3409 return llvm::all_of(S, [](
char C) {
return std::isalnum(
C) ||
C ==
'_'; });
3413 const ArgList &Args, ArgStringList &CmdArgs,
3414 bool KernelOrKext) {
3419 if (EffectiveTriple.isNVPTX())
3427 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3428 options::OPT_fstack_protector_all,
3429 options::OPT_fstack_protector_strong,
3430 options::OPT_fstack_protector)) {
3431 if (A->getOption().matches(options::OPT_fstack_protector))
3432 StackProtectorLevel =
3434 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3436 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3440 D.
Diag(diag::warn_drv_unsupported_option_for_target)
3441 << A->getSpelling() << EffectiveTriple.getTriple();
3442 StackProtectorLevel = DefaultStackProtectorLevel;
3445 StackProtectorLevel = DefaultStackProtectorLevel;
3448 if (StackProtectorLevel) {
3449 CmdArgs.push_back(
"-stack-protector");
3450 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3454 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3455 StringRef Str(A->getValue());
3456 if (Str.starts_with(
"ssp-buffer-size=")) {
3457 if (StackProtectorLevel) {
3458 CmdArgs.push_back(
"-stack-protector-buffer-size");
3460 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3466 const std::string &TripleStr = EffectiveTriple.getTriple();
3467 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3468 StringRef
Value = A->getValue();
3469 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3470 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3471 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3472 << A->getAsString(Args) << TripleStr;
3473 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3474 EffectiveTriple.isThumb()) &&
3476 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3477 << A->getOption().getName() <<
Value <<
"tls global";
3480 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3482 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3483 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3484 << A->getAsString(Args);
3489 D.
Diag(diag::err_target_unsupported_tp_hard)
3490 << EffectiveTriple.getArchName();
3494 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3495 StringRef
Value = A->getValue();
3496 if (
Value !=
"cp15") {
3497 D.
Diag(diag::err_drv_argument_not_allowed_with)
3498 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3502 CmdArgs.push_back(
"-target-feature");
3503 CmdArgs.push_back(
"+read-tp-tpidruro");
3505 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3506 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3507 << A->getOption().getName() <<
Value <<
"sysreg global";
3510 A->render(Args, CmdArgs);
3513 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3514 StringRef
Value = A->getValue();
3515 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3516 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3517 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3518 << A->getAsString(Args) << TripleStr;
3520 if (
Value.getAsInteger(10, Offset)) {
3521 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3524 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3525 (Offset < 0 || Offset > 0xfffff)) {
3526 D.
Diag(diag::err_drv_invalid_int_value)
3527 << A->getOption().getName() <<
Value;
3530 A->render(Args, CmdArgs);
3533 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3534 StringRef
Value = A->getValue();
3535 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3536 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3537 << A->getAsString(Args) << TripleStr;
3538 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3539 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3540 << A->getOption().getName() <<
Value <<
"fs gs";
3543 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3544 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3547 A->render(Args, CmdArgs);
3550 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3551 StringRef
Value = A->getValue();
3553 D.
Diag(diag::err_drv_argument_only_allowed_with)
3554 << A->getOption().getName() <<
"legal symbol name";
3557 A->render(Args, CmdArgs);
3562 ArgStringList &CmdArgs) {
3565 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3568 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3569 !EffectiveTriple.isPPC64() && !EffectiveTriple.isAArch64())
3572 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3573 options::OPT_fno_stack_clash_protection);
3578 const ArgList &Args,
3579 ArgStringList &CmdArgs) {
3581 StringRef TrivialAutoVarInit =
"";
3583 for (
const Arg *A : Args) {
3584 switch (A->getOption().getID()) {
3587 case options::OPT_ftrivial_auto_var_init: {
3589 StringRef Val = A->getValue();
3590 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3591 TrivialAutoVarInit = Val;
3593 D.
Diag(diag::err_drv_unsupported_option_argument)
3594 << A->getSpelling() << Val;
3600 if (TrivialAutoVarInit.empty())
3601 switch (DefaultTrivialAutoVarInit) {
3605 TrivialAutoVarInit =
"pattern";
3608 TrivialAutoVarInit =
"zero";
3612 if (!TrivialAutoVarInit.empty()) {
3614 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3618 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3619 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3621 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3623 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3625 StringRef Val = A->getValue();
3626 if (std::stoi(Val.str()) <= 0)
3627 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3629 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3632 if (Arg *A = Args.getLastArg(options::OPT_ftrivial_auto_var_init_max_size)) {
3633 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3635 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3637 D.
Diag(diag::err_drv_trivial_auto_var_init_max_size_missing_dependency);
3639 StringRef Val = A->getValue();
3640 if (std::stoi(Val.str()) <= 0)
3641 D.
Diag(diag::err_drv_trivial_auto_var_init_max_size_invalid_value);
3643 Args.MakeArgString(
"-ftrivial-auto-var-init-max-size=" + Val));
3651 const unsigned ForwardedArguments[] = {
3652 options::OPT_cl_opt_disable,
3653 options::OPT_cl_strict_aliasing,
3654 options::OPT_cl_single_precision_constant,
3655 options::OPT_cl_finite_math_only,
3656 options::OPT_cl_kernel_arg_info,
3657 options::OPT_cl_unsafe_math_optimizations,
3658 options::OPT_cl_fast_relaxed_math,
3659 options::OPT_cl_mad_enable,
3660 options::OPT_cl_no_signed_zeros,
3661 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3662 options::OPT_cl_uniform_work_group_size
3665 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3666 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3667 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3668 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3669 std::string CLExtStr = std::string(
"-cl-ext=") + A->getValue();
3670 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3673 for (
const auto &Arg : ForwardedArguments)
3674 if (
const auto *A = Args.getLastArg(Arg))
3675 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3680 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3681 CmdArgs.push_back(
"-finclude-default-header");
3682 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3688 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3693 options::OPT_emit_llvm,
3694 options::OPT_emit_obj,
3695 options::OPT_disable_llvm_passes,
3696 options::OPT_fnative_half_type,
3697 options::OPT_hlsl_entrypoint};
3700 for (
const auto &Arg : ForwardedArguments)
3701 if (
const auto *A = Args.getLastArg(Arg))
3702 A->renderAsInput(Args, CmdArgs);
3704 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3705 !Args.hasArg(options::OPT_nostdinc))
3706 CmdArgs.push_back(
"-finclude-default-header");
3710 ArgStringList &CmdArgs,
types::ID InputType) {
3711 if (!Args.hasArg(options::OPT_fopenacc))
3714 CmdArgs.push_back(
"-fopenacc");
3716 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override)) {
3717 StringRef
Value = A->getValue();
3719 if (!
Value.getAsInteger(10, Version))
3720 A->renderAsInput(Args, CmdArgs);
3722 D.
Diag(diag::err_drv_clang_unsupported) <<
Value;
3727 ArgStringList &CmdArgs) {
3728 bool ARCMTEnabled =
false;
3729 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3730 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3731 options::OPT_ccc_arcmt_modify,
3732 options::OPT_ccc_arcmt_migrate)) {
3733 ARCMTEnabled =
true;
3734 switch (A->getOption().getID()) {
3735 default: llvm_unreachable(
"missed a case");
3736 case options::OPT_ccc_arcmt_check:
3737 CmdArgs.push_back(
"-arcmt-action=check");
3739 case options::OPT_ccc_arcmt_modify:
3740 CmdArgs.push_back(
"-arcmt-action=modify");
3742 case options::OPT_ccc_arcmt_migrate:
3743 CmdArgs.push_back(
"-arcmt-action=migrate");
3744 CmdArgs.push_back(
"-mt-migrate-directory");
3745 CmdArgs.push_back(A->getValue());
3747 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3748 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3753 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3754 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3755 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3758 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3760 D.
Diag(diag::err_drv_argument_not_allowed_with)
3761 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3763 CmdArgs.push_back(
"-mt-migrate-directory");
3764 CmdArgs.push_back(A->getValue());
3766 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3767 options::OPT_objcmt_migrate_subscripting,
3768 options::OPT_objcmt_migrate_property)) {
3770 CmdArgs.push_back(
"-objcmt-migrate-literals");
3771 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3772 CmdArgs.push_back(
"-objcmt-migrate-property");
3774 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3775 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3776 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3779 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3780 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3781 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3782 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3783 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3784 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3785 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3786 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3787 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3788 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3789 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3790 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3791 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3792 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3793 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3794 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3799 const ArgList &Args, ArgStringList &CmdArgs) {
3802 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3803 !Args.hasArg(options::OPT_mkernel));
3805 CmdArgs.push_back(
"-fno-builtin");
3808 if (Args.hasArg(options::OPT_ffreestanding))
3809 UseBuiltins =
false;
3812 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3818 A->render(Args, CmdArgs);
3824 if (TC.
getArch() == llvm::Triple::le32)
3825 CmdArgs.push_back(
"-fno-math-builtin");
3829 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
3832 return Path.getSingleStringRef() !=
"";
3834 if (llvm::sys::path::cache_directory(
Result)) {
3835 llvm::sys::path::append(
Result,
"clang");
3836 llvm::sys::path::append(
Result,
"ModuleCache");
3843 const ArgList &Args,
const InputInfo &Input,
3844 const InputInfo &Output,
bool HaveStd20,
3845 ArgStringList &CmdArgs) {
3847 bool HaveStdCXXModules = IsCXX && HaveStd20;
3848 bool HaveModules = HaveStdCXXModules;
3853 bool HaveClangModules =
false;
3854 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3855 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3856 options::OPT_fno_cxx_modules,
true);
3857 if (AllowedInCXX || !IsCXX) {
3858 CmdArgs.push_back(
"-fmodules");
3859 HaveClangModules =
true;
3863 HaveModules |= HaveClangModules;
3867 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3868 options::OPT_fno_implicit_module_maps, HaveClangModules))
3869 CmdArgs.push_back(
"-fimplicit-module-maps");
3872 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3873 options::OPT_fno_modules_decluse);
3877 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3878 options::OPT_fno_modules_strict_decluse,
false))
3879 CmdArgs.push_back(
"-fmodules-strict-decluse");
3882 bool ImplicitModules =
false;
3883 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3884 options::OPT_fno_implicit_modules, HaveClangModules)) {
3886 CmdArgs.push_back(
"-fno-implicit-modules");
3887 }
else if (HaveModules) {
3888 ImplicitModules =
true;
3892 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3893 Path = A->getValue();
3895 bool HasPath =
true;
3896 if (
C.isForDiagnostics()) {
3900 llvm::sys::path::replace_extension(Path,
".cache");
3901 llvm::sys::path::append(Path,
"modules");
3902 }
else if (Path.empty()) {
3910 const char Arg[] =
"-fmodules-cache-path=";
3911 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3912 CmdArgs.push_back(Args.MakeArgString(Path));
3917 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3918 options::OPT_fno_prebuilt_implicit_modules,
false))
3919 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3920 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3921 options::OPT_fno_modules_validate_input_files_content,
3923 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3928 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3932 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3936 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3938 llvm::sys::path::append(BuiltinModuleMap,
"include");
3939 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3940 if (llvm::sys::fs::exists(BuiltinModuleMap))
3942 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3949 if (HaveModules || Input.
getType() == clang::driver::types::TY_ModuleFile) {
3950 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3953 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3954 CmdArgs.push_back(Args.MakeArgString(
3955 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3959 Args.ClaimAllArgs(options::OPT_fmodule_file);
3963 if (HaveClangModules &&
C.isForDiagnostics()) {
3965 llvm::sys::path::replace_extension(VFSDir,
".cache");
3967 C.addTempFile(Args.MakeArgString(VFSDir));
3969 llvm::sys::path::append(VFSDir,
"vfs");
3970 CmdArgs.push_back(
"-module-dependency-dir");
3971 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3974 if (HaveClangModules)
3975 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3978 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3979 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3980 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3982 if (HaveClangModules) {
3983 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3985 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3986 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3987 D.
Diag(diag::err_drv_argument_not_allowed_with)
3988 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3990 llvm::sys::fs::file_status Status;
3991 if (llvm::sys::fs::status(A->getValue(), Status))
3992 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3993 CmdArgs.push_back(Args.MakeArgString(
3994 "-fbuild-session-timestamp=" +
3995 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3996 Status.getLastModificationTime().time_since_epoch())
4000 if (Args.getLastArg(
4001 options::OPT_fmodules_validate_once_per_build_session)) {
4002 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4003 options::OPT_fbuild_session_file))
4004 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4006 Args.AddLastArg(CmdArgs,
4007 options::OPT_fmodules_validate_once_per_build_session);
4010 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
4011 options::OPT_fno_modules_validate_system_headers,
4013 CmdArgs.push_back(
"-fmodules-validate-system-headers");
4015 Args.AddLastArg(CmdArgs,
4016 options::OPT_fmodules_disable_diagnostic_validation);
4018 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
4019 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
4020 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
4021 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
4022 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
4023 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
4028 CmdArgs.push_back(
"-fskip-odr-check-in-gmf");
4031 Args.ClaimAllArgs(options::OPT_fmodule_output);
4032 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
4038 ArgStringList &CmdArgs) {
4040 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
4041 options::OPT_fno_signed_char,
4042 options::OPT_funsigned_char,
4043 options::OPT_fno_unsigned_char)) {
4044 if (A->getOption().matches(options::OPT_funsigned_char) ||
4045 A->getOption().matches(options::OPT_fno_signed_char)) {
4046 CmdArgs.push_back(
"-fno-signed-char");
4049 CmdArgs.push_back(
"-fno-signed-char");
4053 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
4055 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4056 options::OPT_fno_short_wchar)) {
4057 if (A->getOption().matches(options::OPT_fshort_wchar)) {
4058 CmdArgs.push_back(
"-fwchar-type=short");
4059 CmdArgs.push_back(
"-fno-signed-wchar");
4061 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
4062 CmdArgs.push_back(
"-fwchar-type=int");
4064 (IsARM && !(T.isOSWindows() || T.isOSNetBSD() || T.isOSOpenBSD())))
4065 CmdArgs.push_back(
"-fno-signed-wchar");
4067 CmdArgs.push_back(
"-fsigned-wchar");
4069 }
else if (T.isOSzOS())
4070 CmdArgs.push_back(
"-fno-signed-wchar");
4074 const llvm::Triple &T,
const ArgList &Args,
4076 const InputInfo &Input, ArgStringList &CmdArgs) {
4077 const llvm::Triple::ArchType Arch = TC.
getArch();
4083 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4084 options::OPT_fno_objc_legacy_dispatch,
4087 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
4089 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
4095 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
4097 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
4104 CmdArgs.push_back(
"-fobjc-arc");
4111 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
4113 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
4118 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4119 options::OPT_fno_objc_arc_exceptions,
4121 CmdArgs.push_back(
"-fobjc-arc-exceptions");
4126 if (Args.hasArg(options::OPT_fno_objc_arc)) {
4127 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4128 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4134 auto *Arg = Args.getLastArg(
4135 options::OPT_fobjc_convert_messages_to_runtime_calls,
4136 options::OPT_fno_objc_convert_messages_to_runtime_calls);
4138 Arg->getOption().matches(
4139 options::OPT_fno_objc_convert_messages_to_runtime_calls))
4140 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
4145 if (InferCovariantReturns)
4146 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4151 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4155 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4156 D.
Diag(diag::err_objc_weak_unsupported);
4158 WeakArg->render(Args, CmdArgs);
4162 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4163 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
4167 ArgStringList &CmdArgs) {
4168 bool CaretDefault =
true;
4169 bool ColumnDefault =
true;
4171 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4172 options::OPT__SLASH_diagnostics_column,
4173 options::OPT__SLASH_diagnostics_caret)) {
4174 switch (A->getOption().getID()) {
4175 case options::OPT__SLASH_diagnostics_caret:
4176 CaretDefault =
true;
4177 ColumnDefault =
true;
4179 case options::OPT__SLASH_diagnostics_column:
4180 CaretDefault =
false;
4181 ColumnDefault =
true;
4183 case options::OPT__SLASH_diagnostics_classic:
4184 CaretDefault =
false;
4185 ColumnDefault =
false;
4191 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4192 options::OPT_fno_caret_diagnostics, CaretDefault))
4193 CmdArgs.push_back(
"-fno-caret-diagnostics");
4195 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4196 options::OPT_fno_diagnostics_fixit_info);
4197 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4198 options::OPT_fno_diagnostics_show_option);
4201 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4202 CmdArgs.push_back(
"-fdiagnostics-show-category");
4203 CmdArgs.push_back(A->getValue());
4206 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4207 options::OPT_fno_diagnostics_show_hotness);
4210 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4212 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4213 CmdArgs.push_back(Args.MakeArgString(Opt));
4217 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4219 std::string(
"-fdiagnostics-misexpect-tolerance=") + A->getValue();
4220 CmdArgs.push_back(Args.MakeArgString(Opt));
4223 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4224 CmdArgs.push_back(
"-fdiagnostics-format");
4225 CmdArgs.push_back(A->getValue());
4226 if (StringRef(A->getValue()) ==
"sarif" ||
4227 StringRef(A->getValue()) ==
"SARIF")
4228 D.
Diag(diag::warn_drv_sarif_format_unstable);
4231 if (
const Arg *A = Args.getLastArg(
4232 options::OPT_fdiagnostics_show_note_include_stack,
4233 options::OPT_fno_diagnostics_show_note_include_stack)) {
4234 const Option &O = A->getOption();
4235 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4236 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4238 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4245 Args.getLastArg(options::OPT_fcolor_diagnostics,
4246 options::OPT_fno_color_diagnostics);
4247 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4248 StringRef
Value(A->getValue());
4250 D.
Diag(diag::err_drv_invalid_argument_to_option)
4251 <<
Value << A->getOption().getName();
4255 CmdArgs.push_back(
"-fcolor-diagnostics");
4257 if (Args.hasArg(options::OPT_fansi_escape_codes))
4258 CmdArgs.push_back(
"-fansi-escape-codes");
4260 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4261 options::OPT_fno_show_source_location);
4263 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4264 options::OPT_fno_diagnostics_show_line_numbers);
4266 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4267 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4269 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4271 CmdArgs.push_back(
"-fno-show-column");
4273 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4274 options::OPT_fno_spell_checking);
4278 const ArgList &Args, Arg *&Arg) {
4279 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4280 options::OPT_gno_split_dwarf);
4281 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4284 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4287 StringRef
Value = Arg->getValue();
4288 if (
Value ==
"split")
4290 if (
Value ==
"single")
4293 D.
Diag(diag::err_drv_unsupported_option_argument)
4294 << Arg->getSpelling() << Arg->getValue();
4299 const ArgList &Args, ArgStringList &CmdArgs,
4300 unsigned DwarfVersion) {
4301 auto *DwarfFormatArg =
4302 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4303 if (!DwarfFormatArg)
4306 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4307 if (DwarfVersion < 3)
4308 D.
Diag(diag::err_drv_argument_only_allowed_with)
4309 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4310 else if (!T.isArch64Bit())
4311 D.
Diag(diag::err_drv_argument_only_allowed_with)
4312 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4313 else if (!T.isOSBinFormatELF())
4314 D.
Diag(diag::err_drv_argument_only_allowed_with)
4315 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4318 DwarfFormatArg->render(Args, CmdArgs);
4323 const ArgList &Args,
bool IRInput, ArgStringList &CmdArgs,
4325 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
4327 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4328 options::OPT_fno_debug_info_for_profiling,
false) &&
4330 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4331 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4344 bool SplitDWARFInlining =
4345 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4346 options::OPT_fno_split_dwarf_inlining,
false);
4351 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4357 SplitDWARFInlining =
false;
4360 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4361 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4365 A->getOption().matches(options::OPT_gN_Group)) {
4371 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
4372 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
4373 (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
4374 SplitDWARFInlining))
4380 bool HasDebuggerTuning =
false;
4382 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4383 HasDebuggerTuning =
true;
4385 if (A->getOption().matches(options::OPT_glldb))
4386 DebuggerTuning = llvm::DebuggerKind::LLDB;
4387 else if (A->getOption().matches(options::OPT_gsce))
4388 DebuggerTuning = llvm::DebuggerKind::SCE;
4389 else if (A->getOption().matches(options::OPT_gdbx))
4390 DebuggerTuning = llvm::DebuggerKind::DBX;
4392 DebuggerTuning = llvm::DebuggerKind::GDB;
4397 bool EmitDwarf =
false;
4401 bool EmitCodeView =
false;
4402 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4407 if (!EmitCodeView && !EmitDwarf &&
4408 DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
4410 case llvm::codegenoptions::DIF_CodeView:
4411 EmitCodeView =
true;
4413 case llvm::codegenoptions::DIF_DWARF:
4419 unsigned RequestedDWARFVersion = 0;
4420 unsigned EffectiveDWARFVersion = 0;
4425 EffectiveDWARFVersion =
4428 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4432 if (RequestedDWARFVersion == 0 &&
4433 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
4434 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
4438 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4440 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4441 DebuggerTuning == llvm::DebuggerKind::DBX))
4442 CmdArgs.push_back(
"-gstrict-dwarf");
4445 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4453 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4455 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4457 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4458 DebuggerTuning != llvm::DebuggerKind::DBX)))
4459 CmdArgs.push_back(
"-gno-column-info");
4462 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4467 if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
4468 DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
4469 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4470 CmdArgs.push_back(
"-dwarf-ext-refs");
4471 CmdArgs.push_back(
"-fmodule-format=obj");
4476 if (T.isOSBinFormatELF() && SplitDWARFInlining)
4477 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4484 bool NeedFullDebug = Args.hasFlag(
4485 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4486 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4488 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4491 if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
4492 DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
4493 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4494 options::OPT_feliminate_unused_debug_types,
false))
4495 DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
4496 else if (NeedFullDebug)
4497 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
4500 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4506 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4507 if (RequestedDWARFVersion < 5)
4508 D.
Diag(diag::err_drv_argument_only_allowed_with)
4509 << A->getAsString(Args) <<
"-gdwarf-5";
4510 else if (EffectiveDWARFVersion < 5)
4513 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4515 << EffectiveDWARFVersion;
4517 CmdArgs.push_back(
"-gembed-source");
4521 CmdArgs.push_back(
"-gcodeview");
4523 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4524 options::OPT_gno_codeview_ghash);
4526 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4527 options::OPT_gno_codeview_command_line);
4530 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4531 options::OPT_gno_inline_line_tables);
4535 DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
4536 DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
4544 T.isOSAIX() && !HasDebuggerTuning
4545 ? llvm::DebuggerKind::Default
4549 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4553 CmdArgs.push_back(
"-debug-info-macro");
4556 const auto *PubnamesArg =
4557 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4558 options::OPT_gpubnames, options::OPT_gno_pubnames);
4561 const bool OptionSet =
4563 (PubnamesArg->getOption().matches(options::OPT_gpubnames) ||
4564 PubnamesArg->getOption().matches(options::OPT_ggnu_pubnames)));
4565 if ((DebuggerTuning != llvm::DebuggerKind::LLDB || OptionSet) &&
4567 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4568 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames))))
4569 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4570 options::OPT_gpubnames)
4572 :
"-ggnu-pubnames");
4574 const auto *SimpleTemplateNamesArg =
4575 Args.getLastArg(options::OPT_gsimple_template_names,
4576 options::OPT_gno_simple_template_names);
4577 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4578 if (SimpleTemplateNamesArg &&
4580 const auto &Opt = SimpleTemplateNamesArg->getOption();
4581 if (Opt.matches(options::OPT_gsimple_template_names)) {
4582 ForwardTemplateParams =
true;
4583 CmdArgs.push_back(
"-gsimple-template-names=simple");
4587 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4588 StringRef
v = A->getValue();
4589 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4592 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4593 options::OPT_fno_debug_ranges_base_address);
4598 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4599 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4602 CmdArgs.push_back(
"-mllvm");
4603 CmdArgs.push_back(
"-generate-arange-section");
4606 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4607 options::OPT_fno_force_dwarf_frame);
4609 if (Args.hasFlag(options::OPT_fdebug_types_section,
4610 options::OPT_fno_debug_types_section,
false)) {
4611 if (!(T.isOSBinFormatELF() || T.isOSBinFormatWasm())) {
4612 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4613 << Args.getLastArg(options::OPT_fdebug_types_section)
4617 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4619 CmdArgs.push_back(
"-mllvm");
4620 CmdArgs.push_back(
"-generate-type-units");
4627 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4628 options::OPT_fno_dwarf_directory_asm,
4630 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4634 if (ForwardTemplateParams)
4635 CmdArgs.push_back(
"-debug-forward-template-params");
4639 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4640 CmdArgs.push_back(
"-dwarf-explicit-import");
4646 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
4648 if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
4649 CmdArgs.push_back(
"-fjmc");
4651 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"/JMC"
4654 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
4657 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
4662 const char *DebugCompilationDir =
4674 ArgStringList &CmdArgs) {
4675 unsigned RTOptionID = options::OPT__SLASH_MT;
4677 if (Args.hasArg(options::OPT__SLASH_LDd))
4680 RTOptionID = options::OPT__SLASH_MTd;
4682 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4683 RTOptionID = A->getOption().getID();
4685 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4686 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4687 .Case(
"static", options::OPT__SLASH_MT)
4688 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4689 .Case(
"dll", options::OPT__SLASH_MD)
4690 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4691 .Default(options::OPT__SLASH_MT);
4694 StringRef FlagForCRT;
4695 switch (RTOptionID) {
4696 case options::OPT__SLASH_MD:
4697 if (Args.hasArg(options::OPT__SLASH_LDd))
4698 CmdArgs.push_back(
"-D_DEBUG");
4699 CmdArgs.push_back(
"-D_MT");
4700 CmdArgs.push_back(
"-D_DLL");
4701 FlagForCRT =
"--dependent-lib=msvcrt";
4703 case options::OPT__SLASH_MDd:
4704 CmdArgs.push_back(
"-D_DEBUG");
4705 CmdArgs.push_back(
"-D_MT");
4706 CmdArgs.push_back(
"-D_DLL");
4707 FlagForCRT =
"--dependent-lib=msvcrtd";
4709 case options::OPT__SLASH_MT:
4710 if (Args.hasArg(options::OPT__SLASH_LDd))
4711 CmdArgs.push_back(
"-D_DEBUG");
4712 CmdArgs.push_back(
"-D_MT");
4713 CmdArgs.push_back(
"-flto-visibility-public-std");
4714 FlagForCRT =
"--dependent-lib=libcmt";
4716 case options::OPT__SLASH_MTd:
4717 CmdArgs.push_back(
"-D_DEBUG");
4718 CmdArgs.push_back(
"-D_MT");
4719 CmdArgs.push_back(
"-flto-visibility-public-std");
4720 FlagForCRT =
"--dependent-lib=libcmtd";
4723 llvm_unreachable(
"Unexpected option ID.");
4726 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4727 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4729 CmdArgs.push_back(FlagForCRT.data());
4734 CmdArgs.push_back(
"--dependent-lib=oldnames");
4740 const ArgList &Args,
const char *LinkingOutput)
const {
4742 const llvm::Triple &RawTriple = TC.
getTriple();
4744 const std::string &TripleStr = Triple.getTriple();
4747 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4749 ArgStringList CmdArgs;
4751 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4763 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4766 bool IsHostOffloadingAction =
4769 Args.hasFlag(options::OPT_offload_new_driver,
4770 options::OPT_no_offload_new_driver,
false));
4773 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4774 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4775 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4779 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4783 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4787 const InputInfo *CudaDeviceInput =
nullptr;
4788 const InputInfo *OpenMPDeviceInput =
nullptr;
4790 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4792 }
else if (IsExtractAPI) {
4793 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4794 if (I.getType() != ExpectedInputType) {
4795 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4799 ExtractAPIInputs.push_back(I);
4800 }
else if (IsHostOffloadingAction) {
4801 HostOffloadingInputs.push_back(I);
4802 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4803 CudaDeviceInput = &I;
4804 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4805 OpenMPDeviceInput = &I;
4807 llvm_unreachable(
"unexpectedly given multiple inputs");
4811 const llvm::Triple *AuxTriple =
4813 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4814 bool IsIAMCU = RawTriple.isOSIAMCU();
4819 if (IsCuda || IsHIP)
4820 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4824 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4829 CmdArgs.push_back(
"-cc1");
4832 CmdArgs.push_back(
"-triple");
4833 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4835 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4836 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4837 Args.ClaimAllArgs(options::OPT_MJ);
4838 }
else if (
const Arg *GenCDBFragment =
4839 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4840 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4841 TripleStr, Output, Input, Args);
4842 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4845 if (IsCuda || IsHIP) {
4848 std::string NormalizedTriple;
4866 assert(CTC &&
"Expected valid CUDA Toolchain.");
4868 CmdArgs.push_back(Args.MakeArgString(
4869 Twine(
"-target-sdk-version=") +
4877 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4880 CmdArgs.push_back(
"-aux-triple");
4881 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4886 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4887 CmdArgs.push_back(Args.MakeArgString(
4889 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4892 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4898 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
4901 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4902 CmdArgs.push_back(
"-fsycl-is-device");
4904 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4905 A->render(Args, CmdArgs);
4908 CmdArgs.push_back(
"-sycl-std=2020");
4912 if (IsOpenMPDevice) {
4914 std::string NormalizedTriple =
4918 CmdArgs.push_back(
"-aux-triple");
4919 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4922 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4923 Triple.getArch() == llvm::Triple::thumb)) {
4924 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4925 unsigned Version = 0;
4927 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
4928 if (Failure || Version < 7)
4929 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4939 if (Triple.isSPIR() || Triple.isSPIRV())
4940 CmdArgs.push_back(
"-Wspir-compat");
4943 RewriteKind rewriteKind = RK_None;
4945 bool UnifiedLTO =
false;
4947 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
4948 options::OPT_fno_unified_lto, Triple.isPS());
4950 CmdArgs.push_back(
"-funified-lto");
4960 if (!isa<AssembleJobAction>(JA)) {
4964 Args.ClaimAllArgs(options::OPT_mrelax_all);
4965 Args.ClaimAllArgs(options::OPT_mno_relax_all);
4966 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4967 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4968 switch (
C.getDefaultToolChain().getArch()) {
4969 case llvm::Triple::arm:
4970 case llvm::Triple::armeb:
4971 case llvm::Triple::thumb:
4972 case llvm::Triple::thumbeb:
4973 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4979 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4980 Args.ClaimAllArgs(options::OPT_Xassembler);
4981 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
4984 if (isa<AnalyzeJobAction>(JA)) {
4985 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
4986 CmdArgs.push_back(
"-analyze");
4987 }
else if (isa<MigrateJobAction>(JA)) {
4988 CmdArgs.push_back(
"-migrate");
4989 }
else if (isa<PreprocessJobAction>(JA)) {
4990 if (Output.
getType() == types::TY_Dependencies)
4991 CmdArgs.push_back(
"-Eonly");
4993 CmdArgs.push_back(
"-E");
4994 if (Args.hasArg(options::OPT_rewrite_objc) &&
4995 !Args.hasArg(options::OPT_g_Group))
4996 CmdArgs.push_back(
"-P");
4997 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
4998 CmdArgs.push_back(
"-fdirectives-only");
5000 }
else if (isa<AssembleJobAction>(JA)) {
5001 CmdArgs.push_back(
"-emit-obj");
5006 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5007 }
else if (isa<PrecompileJobAction>(JA)) {
5008 if (JA.
getType() == types::TY_Nothing)
5009 CmdArgs.push_back(
"-fsyntax-only");
5010 else if (JA.
getType() == types::TY_ModuleFile)
5011 CmdArgs.push_back(
"-emit-module-interface");
5012 else if (JA.
getType() == types::TY_HeaderUnit)
5013 CmdArgs.push_back(
"-emit-header-unit");
5015 CmdArgs.push_back(
"-emit-pch");
5016 }
else if (isa<VerifyPCHJobAction>(JA)) {
5017 CmdArgs.push_back(
"-verify-pch");
5018 }
else if (isa<ExtractAPIJobAction>(JA)) {
5019 assert(JA.
getType() == types::TY_API_INFO &&
5020 "Extract API actions must generate a API information.");
5021 CmdArgs.push_back(
"-extract-api");
5022 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5023 ProductNameArg->render(Args, CmdArgs);
5024 if (Arg *ExtractAPIIgnoresFileArg =
5025 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5026 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5028 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
5029 "Invalid action for clang tool.");
5030 if (JA.
getType() == types::TY_Nothing) {
5031 CmdArgs.push_back(
"-fsyntax-only");
5032 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5033 JA.
getType() == types::TY_LTO_IR) {
5034 CmdArgs.push_back(
"-emit-llvm");
5035 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5036 JA.
getType() == types::TY_LTO_BC) {
5038 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5039 Args.hasArg(options::OPT_emit_llvm)) {
5040 CmdArgs.push_back(
"-emit-llvm");
5042 CmdArgs.push_back(
"-emit-llvm-bc");
5044 }
else if (JA.
getType() == types::TY_IFS ||
5045 JA.
getType() == types::TY_IFS_CPP) {
5047 Args.hasArg(options::OPT_interface_stub_version_EQ)
5048 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5050 CmdArgs.push_back(
"-emit-interface-stubs");
5052 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5053 }
else if (JA.
getType() == types::TY_PP_Asm) {
5054 CmdArgs.push_back(
"-S");
5055 }
else if (JA.
getType() == types::TY_AST) {
5056 CmdArgs.push_back(
"-emit-pch");
5057 }
else if (JA.
getType() == types::TY_ModuleFile) {
5058 CmdArgs.push_back(
"-module-file-info");
5059 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5060 CmdArgs.push_back(
"-rewrite-objc");
5061 rewriteKind = RK_NonFragile;
5062 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5063 CmdArgs.push_back(
"-rewrite-objc");
5064 rewriteKind = RK_Fragile;
5066 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5073 if (JA.
getType() == types::TY_LLVM_BC)
5074 CmdArgs.push_back(
"-emit-llvm-uselists");
5078 !Args.hasFlag(options::OPT_offload_new_driver,
5079 options::OPT_no_offload_new_driver,
false) &&
5080 !Triple.isAMDGPU()) {
5081 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5082 << Args.getLastArg(options::OPT_foffload_lto,
5083 options::OPT_foffload_lto_EQ)
5085 << Triple.getTriple();
5086 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5088 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5089 << Args.getLastArg(options::OPT_foffload_lto,
5090 options::OPT_foffload_lto_EQ)
5095 CmdArgs.push_back(Args.MakeArgString(
5096 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5099 if (!RawTriple.isPS4() ||
5101 CmdArgs.push_back(
"-flto-unit");
5106 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5108 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5110 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5111 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5115 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5116 options::OPT_mno_regnames);
5118 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5119 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5121 if (Args.getLastArg(options::OPT_save_temps_EQ))
5122 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5124 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5125 options::OPT_fmemory_profile_EQ,
5126 options::OPT_fno_memory_profile);
5128 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5129 MemProfArg->render(Args, CmdArgs);
5131 if (
auto *MemProfUseArg =
5132 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5134 D.
Diag(diag::err_drv_argument_not_allowed_with)
5135 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5136 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5137 options::OPT_fprofile_generate_EQ))
5138 D.
Diag(diag::err_drv_argument_not_allowed_with)
5139 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5140 MemProfUseArg->render(Args, CmdArgs);
5145 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5146 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
5148 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5150 CmdArgs.push_back(
"-disable-llvm-passes");
5157 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5158 options::OPT_mkernel,
5159 options::OPT_fapple_kext,
5160 options::OPT_ffunction_sections,
5161 options::OPT_fno_function_sections,
5162 options::OPT_fdata_sections,
5163 options::OPT_fno_data_sections,
5164 options::OPT_fbasic_block_sections_EQ,
5165 options::OPT_funique_internal_linkage_names,
5166 options::OPT_fno_unique_internal_linkage_names,
5167 options::OPT_funique_section_names,
5168 options::OPT_fno_unique_section_names,
5169 options::OPT_funique_basic_block_section_names,
5170 options::OPT_fno_unique_basic_block_section_names,
5171 options::OPT_mrestrict_it,
5172 options::OPT_mno_restrict_it,
5173 options::OPT_mstackrealign,
5174 options::OPT_mno_stackrealign,
5175 options::OPT_mstack_alignment,
5176 options::OPT_mcmodel_EQ,
5177 options::OPT_mlong_calls,
5178 options::OPT_mno_long_calls,
5179 options::OPT_ggnu_pubnames,
5180 options::OPT_gdwarf_aranges,
5181 options::OPT_fdebug_types_section,
5182 options::OPT_fno_debug_types_section,
5183 options::OPT_fdwarf_directory_asm,
5184 options::OPT_fno_dwarf_directory_asm,
5185 options::OPT_mrelax_all,
5186 options::OPT_mno_relax_all,
5187 options::OPT_ftrap_function_EQ,
5188 options::OPT_ffixed_r9,
5189 options::OPT_mfix_cortex_a53_835769,
5190 options::OPT_mno_fix_cortex_a53_835769,
5191 options::OPT_ffixed_x18,
5192 options::OPT_mglobal_merge,
5193 options::OPT_mno_global_merge,
5194 options::OPT_mred_zone,
5195 options::OPT_mno_red_zone,
5196 options::OPT_Wa_COMMA,
5197 options::OPT_Xassembler,
5200 for (
const auto &A : Args)
5201 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5202 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5205 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5206 options::OPT_fno_optimize_sibling_calls);
5214 case llvm::Triple::arm:
5215 case llvm::Triple::armeb:
5216 case llvm::Triple::thumbeb:
5217 RenderARMABI(D, Triple, Args, CmdArgs);
5219 case llvm::Triple::aarch64:
5220 case llvm::Triple::aarch64_32:
5221 case llvm::Triple::aarch64_be:
5222 RenderAArch64ABI(Triple, Args, CmdArgs);
5227 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5228 if (A->getOption().matches(options::OPT_O4)) {
5229 CmdArgs.push_back(
"-O3");
5230 D.
Diag(diag::warn_O4_is_O3);
5232 A->render(Args, CmdArgs);
5237 if (Output.
getType() == types::TY_Dependencies) {
5240 CmdArgs.push_back(
"-o");
5243 assert(Output.
isNothing() &&
"Input output.");
5246 for (
const auto &II : Inputs) {
5248 if (II.isFilename())
5249 CmdArgs.push_back(II.getFilename());
5251 II.getInputArg().renderAsInput(Args, CmdArgs);
5254 C.addCommand(std::make_unique<Command>(
5260 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5261 CmdArgs.push_back(
"-fembed-bitcode=marker");
5266 if (!
C.isForDiagnostics())
5267 CmdArgs.push_back(
"-disable-free");
5268 CmdArgs.push_back(
"-clear-ast-before-backend");
5271 const bool IsAssertBuild =
false;
5273 const bool IsAssertBuild =
true;
5277 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5278 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5279 CmdArgs.push_back(
"-disable-llvm-verifier");
5283 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5284 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5285 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5287 return types::isLLVMIR(II.getType());
5289 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5291 CmdArgs.push_back(
"-discard-value-names");
5296 CmdArgs.push_back(
"-main-file-name");
5301 if (Args.hasArg(options::OPT_static))
5302 CmdArgs.push_back(
"-static-define");
5304 if (Args.hasArg(options::OPT_municode))
5305 CmdArgs.push_back(
"-DUNICODE");
5307 if (isa<AnalyzeJobAction>(JA))
5310 if (isa<AnalyzeJobAction>(JA) ||
5311 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5312 CmdArgs.push_back(
"-setup-static-analyzer");
5317 bool FoundAnalyzerConfig =
false;
5318 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5319 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5320 FoundAnalyzerConfig =
true;
5323 if (!FoundAnalyzerConfig)
5324 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5325 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5326 FoundAnalyzerConfig =
true;
5329 if (FoundAnalyzerConfig)
5330 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5335 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5336 if (FunctionAlignment) {
5337 CmdArgs.push_back(
"-function-alignment");
5338 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5343 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5345 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5347 << A->getAsString(Args) << A->getValue();
5349 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5350 << A->getAsString(Args) << A->getValue();
5353 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5354 Twine(std::min(
Value, 65536u))));
5357 if (Triple.isOSzOS()) {
5366 auto findMacroDefinition = [&](
const std::string &Macro) {
5367 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5368 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5369 return M == Macro || M.find(Macro +
'=') != std::string::npos;
5374 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5375 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5377 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5378 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5381 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5382 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5386 llvm::Reloc::Model RelocationModel;
5389 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5390 Arg *LastPICDataRelArg =
5391 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5392 options::OPT_mpic_data_is_text_relative);
5393 bool NoPICDataIsTextRelative =
false;
5394 if (LastPICDataRelArg) {
5395 if (LastPICDataRelArg->getOption().matches(
5396 options::OPT_mno_pic_data_is_text_relative)) {
5397 NoPICDataIsTextRelative =
true;
5399 D.
Diag(diag::err_drv_argument_only_allowed_with)
5400 <<
"-mno-pic-data-is-text-relative"
5403 if (!Triple.isSystemZ())
5404 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5405 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5406 :
"-mpic-data-is-text-relative")
5410 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5411 RelocationModel == llvm::Reloc::ROPI_RWPI;
5412 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5413 RelocationModel == llvm::Reloc::ROPI_RWPI;
5415 if (Args.hasArg(options::OPT_mcmse) &&
5416 !Args.hasArg(options::OPT_fallow_unsupported)) {
5418 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5420 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5424 !Args.hasArg(options::OPT_fallow_unsupported))
5425 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5429 CmdArgs.push_back(
"-mrelocation-model");
5430 CmdArgs.push_back(RMName);
5433 CmdArgs.push_back(
"-pic-level");
5434 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5436 CmdArgs.push_back(
"-pic-is-pie");
5437 if (NoPICDataIsTextRelative)
5438 CmdArgs.push_back(
"-mcmodel=medium");
5441 if (RelocationModel == llvm::Reloc::ROPI ||
5442 RelocationModel == llvm::Reloc::ROPI_RWPI)
5443 CmdArgs.push_back(
"-fropi");
5444 if (RelocationModel == llvm::Reloc::RWPI ||
5445 RelocationModel == llvm::Reloc::ROPI_RWPI)
5446 CmdArgs.push_back(
"-frwpi");
5448 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5449 CmdArgs.push_back(
"-meabi");
5450 CmdArgs.push_back(A->getValue());
5464 if (Triple.isOSBinFormatELF()) {
5465 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5466 options::OPT_fno_semantic_interposition);
5467 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5469 bool SupportsLocalAlias =
5470 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5472 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5473 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5474 A->render(Args, CmdArgs);
5475 else if (!SupportsLocalAlias)
5476 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5482 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5484 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5485 << A->getValue() << A->getAsString(Args);
5486 Model = A->getValue();
5489 if (Model !=
"posix") {
5490 CmdArgs.push_back(
"-mthread-model");
5491 CmdArgs.push_back(Args.MakeArgString(Model));
5495 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5496 StringRef Name = A->getValue();
5497 if (Name ==
"SVML") {
5498 if (Triple.getArch() != llvm::Triple::x86 &&
5499 Triple.getArch() != llvm::Triple::x86_64)
5500 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5501 << Name << Triple.getArchName();
5502 }
else if (Name ==
"LIBMVEC-X86") {
5503 if (Triple.getArch() != llvm::Triple::x86 &&
5504 Triple.getArch() != llvm::Triple::x86_64)
5505 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5506 << Name << Triple.getArchName();
5507 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5508 if (Triple.getArch() != llvm::Triple::aarch64 &&
5509 Triple.getArch() != llvm::Triple::aarch64_be)
5510 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5511 << Name << Triple.getArchName();
5513 A->render(Args, CmdArgs);
5516 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5517 options::OPT_fno_merge_all_constants,
false))
5518 CmdArgs.push_back(
"-fmerge-all-constants");
5520 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5521 options::OPT_fno_delete_null_pointer_checks);
5525 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5526 if (!Triple.isOSAIX() || Triple.isPPC32())
5527 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5528 << A->getSpelling() << RawTriple.str();
5529 CmdArgs.push_back(
"-mabi=quadword-atomics");
5532 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5535 if (Triple.isOSAIX())
5536 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5537 << A->getSpelling() << RawTriple.str();
5540 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5541 StringRef
V = A->getValue(), V1 =
V;
5543 if (V1.consumeInteger(10, Size) || !V1.empty())
5544 D.
Diag(diag::err_drv_invalid_argument_to_option)
5545 <<
V << A->getOption().getName();
5547 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5550 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5551 options::OPT_fno_jump_tables);
5552 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5553 options::OPT_fno_profile_sample_accurate);
5554 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5555 options::OPT_fno_preserve_as_comments);
5557 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5558 CmdArgs.push_back(
"-mregparm");
5559 CmdArgs.push_back(A->getValue());
5562 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5563 options::OPT_msvr4_struct_return)) {
5565 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5566 << A->getSpelling() << RawTriple.str();
5567 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5568 CmdArgs.push_back(
"-maix-struct-return");
5570 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5571 CmdArgs.push_back(
"-msvr4-struct-return");
5575 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5576 options::OPT_freg_struct_return)) {
5577 if (TC.
getArch() != llvm::Triple::x86) {
5578 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5579 << A->getSpelling() << RawTriple.str();
5580 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5581 CmdArgs.push_back(
"-fpcc-struct-return");
5583 assert(A->getOption().matches(options::OPT_freg_struct_return));
5584 CmdArgs.push_back(
"-freg-struct-return");
5588 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5589 if (Triple.getArch() == llvm::Triple::m68k)
5590 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5592 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5595 if (Args.hasArg(options::OPT_fenable_matrix)) {
5597 CmdArgs.push_back(
"-fenable-matrix");
5598 CmdArgs.push_back(
"-mllvm");
5599 CmdArgs.push_back(
"-enable-matrix");
5604 const char *FPKeepKindStr =
nullptr;
5605 switch (FPKeepKind) {
5607 FPKeepKindStr =
"-mframe-pointer=none";
5610 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5613 FPKeepKindStr =
"-mframe-pointer=all";
5616 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5617 CmdArgs.push_back(FPKeepKindStr);
5619 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5620 options::OPT_fno_zero_initialized_in_bss);
5625 OptSpecifier StrictAliasingAliasOption =
5626 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5629 bool TBAAOnByDefault = !D.
IsCLMode();
5630 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5631 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5632 CmdArgs.push_back(
"-relaxed-aliasing");
5633 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5634 options::OPT_fno_struct_path_tbaa,
true))
5635 CmdArgs.push_back(
"-no-struct-path-tbaa");
5636 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5637 options::OPT_fno_strict_enums);
5638 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5639 options::OPT_fno_strict_return);
5640 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5641 options::OPT_fno_allow_editor_placeholders);
5642 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5643 options::OPT_fno_strict_vtable_pointers);
5644 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5645 options::OPT_fno_force_emit_vtables);
5646 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5647 options::OPT_fno_optimize_sibling_calls);
5648 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5649 options::OPT_fno_escaping_block_tail_calls);
5651 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5652 options::OPT_fno_fine_grained_bitfield_accesses);
5654 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5655 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5657 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5658 options::OPT_fno_experimental_omit_vtable_rtti);
5661 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5662 options::OPT_fno_split_stack);
5665 if (Args.hasFlag(options::OPT_fprotect_parens,
5666 options::OPT_fno_protect_parens,
false))
5667 CmdArgs.push_back(
"-fprotect-parens");
5671 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5672 const llvm::Triple::ArchType Arch = TC.
getArch();
5673 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5674 StringRef
V = A->getValue();
5676 CmdArgs.push_back(
"-fextend-arguments=64");
5678 D.
Diag(diag::err_drv_invalid_argument_to_option)
5679 << A->getValue() << A->getOption().getName();
5681 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5682 << A->getOption().getName() << TripleStr;
5685 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5686 if (TC.
getArch() == llvm::Triple::avr)
5687 A->render(Args, CmdArgs);
5689 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5690 << A->getAsString(Args) << TripleStr;
5693 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5695 A->render(Args, CmdArgs);
5697 (A->getOption().getID() != options::OPT_mlong_double_80))
5698 A->render(Args, CmdArgs);
5700 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5701 << A->getAsString(Args) << TripleStr;
5707 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5708 IsIntegratedAssemblerDefault))
5709 CmdArgs.push_back(
"-fno-verbose-asm");
5713 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5714 StringRef
V = A->getValue();
5717 A->render(Args, CmdArgs);
5718 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5719 (
V.empty() || (
V.consume_front(
".") &&
5720 !
V.consumeInteger(10, Num) &&
V.empty())))
5721 A->render(Args, CmdArgs);
5723 D.
Diag(diag::err_drv_invalid_argument_to_option)
5724 << A->getValue() << A->getOption().getName();
5730 CmdArgs.push_back(
"-no-integrated-as");
5732 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5733 CmdArgs.push_back(
"-mdebug-pass");
5734 CmdArgs.push_back(
"Structure");
5736 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5737 CmdArgs.push_back(
"-mdebug-pass");
5738 CmdArgs.push_back(
"Arguments");
5744 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5745 CmdArgs.push_back(
"-mconstructor-aliases");
5749 if (KernelOrKext && RawTriple.isOSDarwin())
5750 CmdArgs.push_back(
"-fforbid-guard-variables");
5752 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5753 Triple.isWindowsGNUEnvironment())) {
5754 CmdArgs.push_back(
"-mms-bitfields");
5757 if (Triple.isWindowsGNUEnvironment()) {
5758 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5759 options::OPT_fno_auto_import);
5762 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5764 CmdArgs.push_back(
"-fms-volatile");
5769 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5770 options::OPT_fno_direct_access_external_data)) {
5771 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5773 A->render(Args, CmdArgs);
5774 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
5777 CmdArgs.push_back(
"-fno-direct-access-external-data");
5780 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5781 CmdArgs.push_back(
"-fno-plt");
5788 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5791 CmdArgs.push_back(
"-ffreestanding");
5793 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5800 bool IsAsyncUnwindTablesDefault =
5802 bool IsSyncUnwindTablesDefault =
5805 bool AsyncUnwindTables = Args.hasFlag(
5806 options::OPT_fasynchronous_unwind_tables,
5807 options::OPT_fno_asynchronous_unwind_tables,
5808 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5811 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5812 IsSyncUnwindTablesDefault && !Freestanding);
5813 if (AsyncUnwindTables)
5814 CmdArgs.push_back(
"-funwind-tables=2");
5815 else if (UnwindTables)
5816 CmdArgs.push_back(
"-funwind-tables=1");
5820 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5821 (IsCudaDevice || IsHIPDevice)) {
5822 const ArgList &HostArgs =
5824 std::string HostCPU =
5826 if (!HostCPU.empty()) {
5827 CmdArgs.push_back(
"-aux-target-cpu");
5828 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5836 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5837 StringRef CM = A->getValue();
5839 if (Triple.isOSAIX() && CM ==
"medium")
5841 if (Triple.isAArch64(64)) {
5842 Ok = CM ==
"tiny" || CM ==
"small" || CM ==
"large";
5843 if (CM ==
"large" && RelocationModel != llvm::Reloc::Static)
5844 D.
Diag(diag::err_drv_argument_only_allowed_with)
5845 << A->getAsString(Args) <<
"-fno-pic";
5846 }
else if (Triple.isLoongArch()) {
5847 if (CM ==
"extreme" &&
5848 Args.hasFlagNoClaim(options::OPT_fplt, options::OPT_fno_plt,
false))
5849 D.
Diag(diag::err_drv_argument_not_allowed_with)
5850 << A->getAsString(Args) <<
"-fplt";
5851 Ok = CM ==
"normal" || CM ==
"medium" || CM ==
"extreme";
5854 CM = llvm::StringSwitch<StringRef>(CM)
5855 .Case(
"normal",
"small")
5856 .Case(
"extreme",
"large")
5858 }
else if (Triple.isPPC64() || Triple.isOSAIX()) {
5859 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
5860 }
else if (Triple.isRISCV()) {
5863 else if (CM ==
"medany")
5865 Ok = CM ==
"small" || CM ==
"medium";
5866 }
else if (Triple.getArch() == llvm::Triple::x86_64) {
5867 Ok = llvm::is_contained({
"small",
"kernel",
"medium",
"large",
"tiny"},
5869 }
else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {
5873 }
else if (Triple.isSPARC64()) {
5876 else if (CM ==
"medmid")
5878 else if (CM ==
"medany")
5880 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
5883 CmdArgs.push_back(Args.MakeArgString(
"-mcmodel=" + CM));
5885 D.
Diag(diag::err_drv_unsupported_option_argument_for_target)
5886 << A->getSpelling() << CM << TripleStr;
5890 if (Triple.getArch() == llvm::Triple::x86_64) {
5891 bool IsMediumCM =
false;
5892 bool IsLargeCM =
false;
5893 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5894 IsMediumCM = StringRef(A->getValue()) ==
"medium";
5895 IsLargeCM = StringRef(A->getValue()) ==
"large";
5897 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {
5898 if (!IsMediumCM && !IsLargeCM) {
5899 D.
Diag(diag::warn_drv_large_data_threshold_invalid_code_model)
5900 << A->getOption().getRenderName();
5902 A->render(Args, CmdArgs);
5904 }
else if (IsMediumCM) {
5905 CmdArgs.push_back(
"-mlarge-data-threshold=65536");
5906 }
else if (IsLargeCM) {
5907 CmdArgs.push_back(
"-mlarge-data-threshold=0");
5911 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5912 StringRef
Value = A->getValue();
5913 unsigned TLSSize = 0;
5914 Value.getAsInteger(10, TLSSize);
5915 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5916 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5917 << A->getOption().getName() << TripleStr;
5918 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5919 D.
Diag(diag::err_drv_invalid_int_value)
5920 << A->getOption().getName() <<
Value;
5921 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5925 CmdArgs.push_back(
"-enable-tlsdesc");
5928 std::string CPU =
getCPUName(D, Args, Triple,
false);
5930 CmdArgs.push_back(
"-target-cpu");
5931 CmdArgs.push_back(Args.MakeArgString(CPU));
5934 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5939 AddClangCLArgs(Args, InputType, CmdArgs);
5941 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
5942 llvm::codegenoptions::NoDebugInfo;
5945 CmdArgs, Output, DebugInfoKind, DwarfFission);
5953 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5954 isa<BackendJobAction>(JA));
5956 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
5957 CmdArgs.push_back(
"-split-dwarf-file");
5958 CmdArgs.push_back(SplitDWARFOut);
5960 CmdArgs.push_back(
"-split-dwarf-output");
5961 CmdArgs.push_back(SplitDWARFOut);
5966 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5967 CmdArgs.push_back(
"-target-linker-version");
5968 CmdArgs.push_back(A->getValue());
5973 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
5975 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
5976 TC.
getArch() == llvm::Triple::x86) {
5977 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
5978 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
5979 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
5980 << Unsupported->getOption().getName();
5983 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
5984 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5985 << Unsupported->getOption().getName()
5986 <<
"please use -maltivec and include altivec.h explicitly";
5987 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
5988 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5989 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
5992 Args.AddAllArgs(CmdArgs, options::OPT_v);
5994 if (Args.getLastArg(options::OPT_H)) {
5995 CmdArgs.push_back(
"-H");
5996 CmdArgs.push_back(
"-sys-header-deps");
5998 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6001 CmdArgs.push_back(
"-header-include-file");
6005 CmdArgs.push_back(
"-sys-header-deps");
6006 CmdArgs.push_back(Args.MakeArgString(
6007 "-header-include-format=" +
6010 Args.MakeArgString(
"-header-include-filtering=" +
6014 Args.AddLastArg(CmdArgs, options::OPT_P);
6015 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6018 CmdArgs.push_back(
"-diagnostic-log-file");
6027 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6031 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6032 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6033 CmdArgs.push_back(
"-mllvm");
6034 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6039 if (Args.hasFlag(options::OPT_ffunction_sections,
6040 options::OPT_fno_function_sections, UseSeparateSections)) {
6041 CmdArgs.push_back(
"-ffunction-sections");
6044 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6045 options::OPT_fno_basic_block_address_map)) {
6046 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6047 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6048 A->render(Args, CmdArgs);
6050 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6051 << A->getAsString(Args) << TripleStr;
6055 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6056 StringRef Val = A->getValue();
6057 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6058 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
6059 !Val.starts_with(
"list="))
6060 D.
Diag(diag::err_drv_invalid_value)
6061 << A->getAsString(Args) << A->getValue();
6063 A->render(Args, CmdArgs);
6064 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6067 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6068 D.
Diag(diag::err_drv_invalid_value)
6069 << A->getAsString(Args) << A->getValue();
6071 A->render(Args, CmdArgs);
6072 }
else if (Triple.isNVPTX()) {
6075 }
else if (Val !=
"none") {
6078 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6079 << A->getAsString(Args) << TripleStr;
6083 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6084 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6085 UseSeparateSections || HasDefaultDataSections)) {
6086 CmdArgs.push_back(
"-fdata-sections");
6089 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6090 options::OPT_fno_unique_section_names);
6091 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6092 options::OPT_fno_unique_internal_linkage_names);
6093 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6094 options::OPT_fno_unique_basic_block_section_names);
6095 Args.addOptInFlag(CmdArgs, options::OPT_fconvergent_functions,
6096 options::OPT_fno_convergent_functions);
6098 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6099 options::OPT_fno_split_machine_functions)) {
6100 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6102 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6103 A->render(Args, CmdArgs);
6105 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6106 << A->getAsString(Args) << TripleStr;
6110 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6111 options::OPT_finstrument_functions_after_inlining,
6112 options::OPT_finstrument_function_entry_bare);
6117 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
6120 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6123 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
6124 CmdArgs.push_back(
"-mllvm");
6125 CmdArgs.push_back(
"-sample-profile-use-profi");
6129 if (RawTriple.isPS() &&
6130 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6136 if (Args.hasArg(options::OPT_nostdinc)) {
6137 CmdArgs.push_back(
"-nostdsysteminc");
6138 CmdArgs.push_back(
"-nobuiltininc");
6140 if (Args.hasArg(options::OPT_nostdlibinc))
6141 CmdArgs.push_back(
"-nostdsysteminc");
6142 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6143 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6147 CmdArgs.push_back(
"-resource-dir");
6150 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6159 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6165 Args.ClaimAllArgs(options::OPT_D);
6168 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
6169 if (A->getOption().matches(options::OPT_O4)) {
6170 CmdArgs.push_back(
"-O3");
6171 D.
Diag(diag::warn_O4_is_O3);
6173 A->render(Args, CmdArgs);
6179 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6180 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6185 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6186 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6192 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6195 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6197 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6198 unsigned WarningNumber;
6199 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6200 D.
Diag(diag::err_drv_invalid_int_value)
6201 << A->getAsString(Args) << A->getValue();
6206 CmdArgs.push_back(Args.MakeArgString(
6211 A->render(Args, CmdArgs);
6214 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6216 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6217 CmdArgs.push_back(
"-pedantic");
6218 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6219 Args.AddLastArg(CmdArgs, options::OPT_w);
6221 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6222 options::OPT_fno_fixed_point);
6224 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6225 A->render(Args, CmdArgs);
6227 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6228 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6230 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6231 options::OPT_fno_experimental_omit_vtable_rtti);
6233 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6234 A->render(Args, CmdArgs);
6241 bool ImplyVCPPCVer =
false;
6242 bool ImplyVCPPCXXVer =
false;
6243 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6245 if (
Std->getOption().matches(options::OPT_ansi))
6247 CmdArgs.push_back(
"-std=c++98");
6249 CmdArgs.push_back(
"-std=c89");
6251 Std->render(Args, CmdArgs);
6254 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6255 options::OPT_ftrigraphs,
6256 options::OPT_fno_trigraphs))
6258 A->render(Args, CmdArgs);
6267 if (!Args.hasArg(options::OPT__SLASH_std)) {
6268 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6271 ImplyVCPPCVer =
true;
6273 else if (IsWindowsMSVC)
6274 ImplyVCPPCXXVer =
true;
6276 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6277 options::OPT_fno_trigraphs);
6293 Args.getLastArg(options::OPT_Wwrite_strings,
6294 options::OPT_Wno_write_strings, options::OPT_w);
6296 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6297 CmdArgs.push_back(
"-fconst-strings");
6304 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6306 CmdArgs.push_back(
"-fdeprecated-macro");
6310 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6311 if (
Asm->getOption().matches(options::OPT_fasm))
6312 CmdArgs.push_back(
"-fgnu-keywords");
6314 CmdArgs.push_back(
"-fno-gnu-keywords");
6318 CmdArgs.push_back(
"-fno-autolink");
6320 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6321 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6322 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6323 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6325 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6327 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6328 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6330 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6331 CmdArgs.push_back(
"-fbracket-depth");
6332 CmdArgs.push_back(A->getValue());
6335 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6336 options::OPT_Wlarge_by_value_copy_def)) {
6337 if (A->getNumValues()) {
6338 StringRef
bytes = A->getValue();
6339 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6341 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6344 if (Args.hasArg(options::OPT_relocatable_pch))
6345 CmdArgs.push_back(
"-relocatable-pch");
6347 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6348 static const char *kCFABIs[] = {
6349 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6352 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6353 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6355 A->render(Args, CmdArgs);
6358 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6359 CmdArgs.push_back(
"-fconstant-string-class");
6360 CmdArgs.push_back(A->getValue());
6363 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6364 CmdArgs.push_back(
"-ftabstop");
6365 CmdArgs.push_back(A->getValue());
6368 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6369 options::OPT_fno_stack_size_section);
6371 if (Args.hasArg(options::OPT_fstack_usage)) {
6372 CmdArgs.push_back(
"-stack-usage-file");
6374 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6376 llvm::sys::path::replace_extension(OutputFilename,
"su");
6377 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6383 CmdArgs.push_back(
"-ferror-limit");
6384 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6385 CmdArgs.push_back(A->getValue());
6387 CmdArgs.push_back(
"19");
6389 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6390 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6391 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6392 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6393 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6396 unsigned MessageLength = 0;
6397 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6398 StringRef
V(A->getValue());
6399 if (
V.getAsInteger(0, MessageLength))
6400 D.
Diag(diag::err_drv_invalid_argument_to_option)
6401 <<
V << A->getOption().getName();
6405 MessageLength = llvm::sys::Process::StandardErrColumns();
6407 if (MessageLength != 0)
6409 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6411 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6413 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6415 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6416 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6417 Twine(A->getValue(0))));
6420 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6421 options::OPT_fvisibility_ms_compat)) {
6422 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6423 A->render(Args, CmdArgs);
6425 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6426 CmdArgs.push_back(
"-fvisibility=hidden");
6427 CmdArgs.push_back(
"-ftype-visibility=default");
6429 }
else if (IsOpenMPDevice) {
6433 CmdArgs.push_back(
"-fvisibility=protected");
6437 if (!RawTriple.isPS()) {
6439 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6440 options::OPT_fno_visibility_from_dllstorageclass)) {
6441 if (A->getOption().matches(
6442 options::OPT_fvisibility_from_dllstorageclass)) {
6443 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6444 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6445 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6446 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6447 Args.AddLastArg(CmdArgs,
6448 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6453 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6454 options::OPT_fno_visibility_inlines_hidden,
false))
6455 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6457 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6458 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6463 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6464 D.
Diag(diag::warn_drv_deprecated_arg)
6465 << A->getAsString(Args)
6466 <<
"-fvisibility-global-new-delete=force-hidden";
6470 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6471 options::OPT_fvisibility_global_new_delete_hidden)) {
6472 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6473 A->render(Args, CmdArgs);
6475 assert(A->getOption().matches(
6476 options::OPT_fvisibility_global_new_delete_hidden));
6477 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6481 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6483 if (Args.hasFlag(options::OPT_fnew_infallible,
6484 options::OPT_fno_new_infallible,
false))
6485 CmdArgs.push_back(
"-fnew-infallible");
6487 if (Args.hasFlag(options::OPT_fno_operator_names,
6488 options::OPT_foperator_names,
false))
6489 CmdArgs.push_back(
"-fno-operator-names");
6492 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6493 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6494 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6495 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6497 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6498 Triple.hasDefaultEmulatedTLS()))
6499 CmdArgs.push_back(
"-femulated-tls");
6501 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6502 options::OPT_fno_check_new);
6504 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6508 if (!Triple.isX86() && !Triple.isAArch64())
6509 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6510 << A->getAsString(Args) << TripleStr;
6514 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
6515 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6517 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6518 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6522 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6523 options::OPT_fno_openmp,
false) &&
6530 CmdArgs.push_back(
"-fopenmp");
6535 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6536 options::OPT_fnoopenmp_use_tls,
true))
6537 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6538 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6539 options::OPT_fno_openmp_simd);
6540 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6541 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6542 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6543 options::OPT_fno_openmp_extensions,
true))
6544 CmdArgs.push_back(
"-fno-openmp-extensions");
6545 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6546 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6547 Args.AddAllArgs(CmdArgs,
6548 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6549 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6550 options::OPT_fno_openmp_optimistic_collapse,
6552 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6556 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6557 options::OPT_fno_openmp_cuda_mode,
false))
6558 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6561 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6562 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6563 options::OPT_fno_openmp_target_debug,
false))
6564 CmdArgs.push_back(
"-fopenmp-target-debug");
6568 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6569 options::OPT_fno_openmp_assume_teams_oversubscription,
6571 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6572 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6573 options::OPT_fno_openmp_assume_threads_oversubscription,
6575 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6576 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6577 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6578 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6579 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6580 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6581 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6582 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6583 CmdArgs.push_back(
"-fopenmp-force-usm");
6595 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6596 options::OPT_fno_openmp_simd);
6597 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6598 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6599 options::OPT_fno_openmp_extensions);
6603 if (Args.hasFlag(options::OPT_offload_new_driver,
6604 options::OPT_no_offload_new_driver,
false))
6605 CmdArgs.push_back(
"--offload-new-driver");
6607 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
6610 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6613 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6615 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" +
Filename));
6620 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6621 StringRef S0 = A->getValue(), S = S0;
6622 unsigned Size, Offset = 0;
6623 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6625 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6626 << A->getAsString(Args) << TripleStr;
6627 else if (S.consumeInteger(10, Size) ||
6628 (!S.empty() && (!S.consume_front(
",") ||
6629 S.consumeInteger(10, Offset) || !S.empty())))
6630 D.
Diag(diag::err_drv_invalid_argument_to_option)
6631 << S0 << A->getOption().getName();
6632 else if (Size < Offset)
6633 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6635 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6636 CmdArgs.push_back(Args.MakeArgString(
6637 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6641 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6644 Args.AddLastArg(CmdArgs, options::OPT_pg);
6646 llvm::Triple::ArchType Arch = TC.
getArch();
6647 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6648 if (Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6649 A->render(Args, CmdArgs);
6651 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6652 << A->getAsString(Args) << TripleStr;
6654 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6655 if (Arch == llvm::Triple::systemz)
6656 A->render(Args, CmdArgs);
6658 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6659 << A->getAsString(Args) << TripleStr;
6661 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6662 if (Arch == llvm::Triple::systemz)
6663 A->render(Args, CmdArgs);
6665 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6666 << A->getAsString(Args) << TripleStr;
6670 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6672 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6673 << A->getAsString(Args) << TripleStr;
6676 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6678 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6679 << A->getAsString(Args) << TripleStr;
6682 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6683 if (A->getOption().matches(options::OPT_p)) {
6685 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6686 CmdArgs.push_back(
"-pg");
6692 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6693 options::OPT_mxcoff_build_id_EQ)) {
6694 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6695 << A->getSpelling() << TripleStr;
6699 if (Args.getLastArg(options::OPT_fapple_kext) ||
6700 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6701 CmdArgs.push_back(
"-fapple-kext");
6703 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6704 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6705 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6706 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6707 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6708 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6709 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6710 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6711 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6712 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6714 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
6715 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
6716 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6719 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6720 CmdArgs.push_back(
"-ftrapv-handler");
6721 CmdArgs.push_back(A->getValue());
6724 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6728 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
6729 if (A->getOption().matches(options::OPT_fwrapv))
6730 CmdArgs.push_back(
"-fwrapv");
6731 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
6732 options::OPT_fno_strict_overflow)) {
6733 if (A->getOption().matches(options::OPT_fno_strict_overflow))
6734 CmdArgs.push_back(
"-fwrapv");
6737 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6738 options::OPT_fno_finite_loops);
6740 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6741 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6742 options::OPT_fno_unroll_loops);
6744 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6746 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6748 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6749 options::OPT_mno_speculative_load_hardening);
6755 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6757 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6758 options::OPT_mno_stackrealign);
6760 if (Args.hasArg(options::OPT_mstack_alignment)) {
6761 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
6762 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
6765 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6766 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6769 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6771 CmdArgs.push_back(
"-mstack-probe-size=0");
6774 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6775 options::OPT_mno_stack_arg_probe);
6777 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6778 options::OPT_mno_restrict_it)) {
6779 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6780 CmdArgs.push_back(
"-mllvm");
6781 CmdArgs.push_back(
"-arm-restrict-it");
6783 CmdArgs.push_back(
"-mllvm");
6784 CmdArgs.push_back(
"-arm-default-it");
6798 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6799 options::OPT_fno_hip_new_launch_api,
true))
6800 CmdArgs.push_back(
"-fhip-new-launch-api");
6801 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6802 options::OPT_fno_gpu_allow_device_init);
6803 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6804 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6805 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6806 options::OPT_fno_hip_kernel_arg_name);
6809 if (IsCuda || IsHIP) {
6811 CmdArgs.push_back(
"-fgpu-rdc");
6812 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6813 options::OPT_fno_gpu_defer_diag);
6814 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6815 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6817 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6818 CmdArgs.push_back(
"-fgpu-defer-diag");
6823 if (Args.hasArg(options::OPT_nogpulib))
6824 CmdArgs.push_back(
"-nogpulib");
6826 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6828 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
6831 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6833 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
6835 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6840 if (!(IsCudaDevice || IsHIPDevice)) {
6842 auto *PGOArg = Args.getLastArg(
6843 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
6844 options::OPT_fcs_profile_generate,
6845 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
6846 options::OPT_fprofile_use_EQ);
6848 D.
Diag(diag::err_drv_argument_not_allowed_with)
6849 <<
"SampleUse with PGO options";
6851 StringRef fname = A->getValue();
6852 if (!llvm::sys::fs::exists(fname))
6853 D.
Diag(diag::err_drv_no_such_file) << fname;
6855 A->render(Args, CmdArgs);
6857 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6859 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6860 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
6861 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
6864 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6865 options::OPT_fno_unique_internal_linkage_names,
true))
6866 CmdArgs.push_back(
"-funique-internal-linkage-names");
6871 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6872 options::OPT_fno_assume_sane_operator_new);
6874 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
6875 CmdArgs.push_back(
"-fapinotes");
6876 if (Args.hasFlag(options::OPT_fapinotes_modules,
6877 options::OPT_fno_apinotes_modules,
false))
6878 CmdArgs.push_back(
"-fapinotes-modules");
6879 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
6882 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
6884 (Args.hasArg(options::OPT_fgnu_runtime) &&
6885 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
6886 !Args.hasArg(options::OPT_fno_blocks))) {
6887 CmdArgs.push_back(
"-fblocks");
6890 CmdArgs.push_back(
"-fblocks-runtime-optional");
6895 CmdArgs.push_back(
"-fencode-extended-block-signature");
6897 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
6898 options::OPT_fno_coro_aligned_allocation,
false) &&
6900 CmdArgs.push_back(
"-fcoro-aligned-allocation");
6902 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
6903 options::OPT_fno_double_square_bracket_attributes);
6905 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
6906 options::OPT_fno_access_control);
6907 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
6908 options::OPT_fno_elide_constructors);
6914 CmdArgs.push_back(
"-fno-rtti");
6917 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
6918 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
6919 CmdArgs.push_back(
"-fshort-enums");
6925 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
6926 !RawTriple.isOSAIX() && !RawTriple.isOSWindows() &&
6927 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
6928 RawTriple.hasEnvironment())) ||
6930 CmdArgs.push_back(
"-fno-use-cxa-atexit");
6932 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
6933 options::OPT_fno_register_global_dtors_with_atexit,
6934 RawTriple.isOSDarwin() && !KernelOrKext))
6935 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
6937 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
6938 options::OPT_fno_use_line_directives);
6941 if (Args.hasFlag(options::OPT_fminimize_whitespace,
6942 options::OPT_fno_minimize_whitespace,
false)) {
6943 types::ID InputType = Inputs[0].getType();
6944 if (!isDerivedFromC(InputType))
6945 D.
Diag(diag::err_drv_opt_unsupported_input_type)
6947 CmdArgs.push_back(
"-fminimize-whitespace");
6951 if (Args.hasFlag(options::OPT_fkeep_system_includes,
6952 options::OPT_fno_keep_system_includes,
false)) {
6953 types::ID InputType = Inputs[0].getType();
6954 if (!isDerivedFromC(InputType))
6955 D.
Diag(diag::err_drv_opt_unsupported_input_type)
6957 CmdArgs.push_back(
"-fkeep-system-includes");
6961 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
6963 CmdArgs.push_back(
"-fms-extensions");
6966 bool IsMSVCCompat = Args.hasFlag(
6967 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
6968 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
6969 options::OPT_fno_ms_extensions,
true)));
6971 CmdArgs.push_back(
"-fms-compatibility");
6973 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
6974 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
6978 VersionTuple GNUCVer;
6979 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
6982 StringRef Val = A->getValue();
6983 Val = Val.empty() ?
"0" : Val;
6984 bool Invalid = GNUCVer.tryParse(Val);
6985 unsigned Minor = GNUCVer.getMinor().value_or(0);
6986 unsigned Patch = GNUCVer.getSubminor().value_or(0);
6987 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
6988 D.
Diag(diag::err_drv_invalid_value)
6989 << A->getAsString(Args) << A->getValue();
6991 }
else if (!IsMSVCCompat) {
6993 GNUCVer = VersionTuple(4, 2, 1);
6995 if (!GNUCVer.empty()) {
6997 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7003 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7005 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7006 if (ImplyVCPPCVer) {
7007 StringRef LanguageStandard;
7008 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7010 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7011 .Case(
"c11",
"-std=c11")
7012 .Case(
"c17",
"-std=c17")
7014 if (LanguageStandard.empty())
7015 D.
Diag(clang::diag::warn_drv_unused_argument)
7016 << StdArg->getAsString(Args);
7018 CmdArgs.push_back(LanguageStandard.data());
7020 if (ImplyVCPPCXXVer) {
7021 StringRef LanguageStandard;
7022 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7024 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7025 .Case(
"c++14",
"-std=c++14")
7026 .Case(
"c++17",
"-std=c++17")
7027 .Case(
"c++20",
"-std=c++20")
7029 .Case(
"c++latest",
"-std=c++26")
7031 if (LanguageStandard.empty())
7032 D.
Diag(clang::diag::warn_drv_unused_argument)
7033 << StdArg->getAsString(Args);
7036 if (LanguageStandard.empty()) {
7037 if (IsMSVC2015Compatible)
7038 LanguageStandard =
"-std=c++14";
7040 LanguageStandard =
"-std=c++11";
7043 CmdArgs.push_back(LanguageStandard.data());
7046 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7047 options::OPT_fno_borland_extensions);
7050 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7052 CmdArgs.push_back(
"-fdeclspec");
7053 else if (Args.hasArg(options::OPT_fno_declspec))
7054 CmdArgs.push_back(
"-fno-declspec");
7058 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7059 options::OPT_fno_threadsafe_statics,
7061 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7062 CmdArgs.push_back(
"-fno-threadsafe-statics");
7065 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7067 CmdArgs.push_back(
"-fno-assumptions");
7071 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7072 options::OPT_fno_gnu_keywords);
7074 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7075 options::OPT_fno_gnu89_inline);
7077 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7078 options::OPT_finline_hint_functions,
7079 options::OPT_fno_inline_functions);
7080 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7081 if (A->getOption().matches(options::OPT_fno_inline))
7082 A->render(Args, CmdArgs);
7083 }
else if (InlineArg) {
7084 InlineArg->render(Args, CmdArgs);
7087 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7092 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"gnu++2a") ||
7093 Std->containsValue(
"c++20") ||
Std->containsValue(
"gnu++20") ||
7094 Std->containsValue(
"c++2b") ||
Std->containsValue(
"gnu++2b") ||
7095 Std->containsValue(
"c++23") ||
Std->containsValue(
"gnu++23") ||
7096 Std->containsValue(
"c++2c") ||
Std->containsValue(
"gnu++2c") ||
7097 Std->containsValue(
"c++26") ||
Std->containsValue(
"gnu++26") ||
7098 Std->containsValue(
"c++latest") ||
Std->containsValue(
"gnu++latest"));
7113 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7114 options::OPT_fno_delayed_template_parsing,
7115 IsWindowsMSVC && !HaveCxx20)) {
7117 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7119 CmdArgs.push_back(
"-fdelayed-template-parsing");
7122 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7123 options::OPT_fno_pch_validate_input_files_content,
false))
7124 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7125 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7126 options::OPT_fno_pch_instantiate_templates,
false))
7127 CmdArgs.push_back(
"-fpch-instantiate-templates");
7128 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7130 CmdArgs.push_back(
"-fmodules-codegen");
7131 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7133 CmdArgs.push_back(
"-fmodules-debuginfo");
7135 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7140 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7141 options::OPT_fno_objc_encode_cxx_class_template_spec,
7143 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7145 if (Args.hasFlag(options::OPT_fapplication_extension,
7146 options::OPT_fno_application_extension,
false))
7147 CmdArgs.push_back(
"-fapplication-extension");
7151 if (!
C.getDriver().IsCLMode())
7152 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7155 Arg *A = Args.getLastArg(
7156 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7157 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7159 const Option &Opt = A->getOption();
7160 if (Opt.matches(options::OPT_fsjlj_exceptions))
7161 CmdArgs.push_back(
"-exception-model=sjlj");
7162 if (Opt.matches(options::OPT_fseh_exceptions))
7163 CmdArgs.push_back(
"-exception-model=seh");
7164 if (Opt.matches(options::OPT_fdwarf_exceptions))
7165 CmdArgs.push_back(
"-exception-model=dwarf");
7166 if (Opt.matches(options::OPT_fwasm_exceptions))
7167 CmdArgs.push_back(
"-exception-model=wasm");
7172 case llvm::ExceptionHandling::DwarfCFI:
7173 CmdArgs.push_back(
"-exception-model=dwarf");
7175 case llvm::ExceptionHandling::SjLj:
7176 CmdArgs.push_back(
"-exception-model=sjlj");
7178 case llvm::ExceptionHandling::WinEH:
7179 CmdArgs.push_back(
"-exception-model=seh");
7185 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7186 options::OPT_fno_assume_sane_operator_new);
7189 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7190 options::OPT_fno_assume_unique_vtables);
7195 Args.addOptInFlag(CmdArgs, options::OPT_frelaxed_template_template_args,
7196 options::OPT_fno_relaxed_template_template_args);
7200 Args.addOptInFlag(CmdArgs, options::OPT_fsized_deallocation,
7201 options::OPT_fno_sized_deallocation);
7205 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7206 options::OPT_fno_aligned_allocation,
7207 options::OPT_faligned_new_EQ)) {
7208 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7209 CmdArgs.push_back(
"-fno-aligned-allocation");
7211 CmdArgs.push_back(
"-faligned-allocation");
7216 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7217 options::OPT_faligned_new_EQ))
7219 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7223 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7224 options::OPT_fno_constant_cfstrings,
true) ||
7225 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7226 options::OPT_mno_constant_cfstrings,
true))
7227 CmdArgs.push_back(
"-fno-constant-cfstrings");
7229 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7230 options::OPT_fno_pascal_strings);
7234 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7235 std::string PackStructStr =
"-fpack-struct=";
7236 PackStructStr += A->getValue();
7237 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7238 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7239 options::OPT_fno_pack_struct,
false)) {
7240 CmdArgs.push_back(
"-fpack-struct=1");
7244 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7245 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7246 if (!SkipMaxTypeAlign) {
7247 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7248 MaxTypeAlignStr += A->getValue();
7249 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7251 }
else if (RawTriple.isOSDarwin()) {
7252 if (!SkipMaxTypeAlign) {
7253 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7254 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7258 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7259 CmdArgs.push_back(
"-Qn");
7262 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7266 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7267 options::OPT_funsigned_bitfields,
true))
7268 D.
Diag(diag::warn_drv_clang_unsupported)
7269 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7272 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7273 D.
Diag(diag::err_drv_clang_unsupported)
7274 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7277 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7278 StringRef value = inputCharset->getValue();
7279 if (!value.equals_insensitive(
"utf-8"))
7280 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7285 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7286 StringRef value = execCharset->getValue();
7287 if (!value.equals_insensitive(
"utf-8"))
7288 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7294 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7295 options::OPT_fno_asm_blocks);
7297 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7298 options::OPT_fno_gnu_inline_asm);
7304 OptSpecifier VectorizeAliasOption =
7305 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
7306 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
7307 options::OPT_fno_vectorize, EnableVec))
7308 CmdArgs.push_back(
"-vectorize-loops");
7312 OptSpecifier SLPVectAliasOption =
7313 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
7314 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
7315 options::OPT_fno_slp_vectorize, EnableSLPVec))
7316 CmdArgs.push_back(
"-vectorize-slp");
7320 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7321 Args.AddLastArg(CmdArgs,
7322 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7326 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7327 options::OPT_fno_dollars_in_identifiers)) {
7328 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7329 CmdArgs.push_back(
"-fdollars-in-identifiers");
7331 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7334 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7335 options::OPT_fno_apple_pragma_pack);
7341 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7342 options::OPT_fno_rewrite_imports,
false);
7344 CmdArgs.push_back(
"-frewrite-imports");
7346 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7347 options::OPT_fno_directives_only);
7353 if (Args.hasFlag(options::OPT_frewrite_includes,
7354 options::OPT_fno_rewrite_includes,
false) ||
7355 (
C.isForDiagnostics() && !HaveModules))
7356 CmdArgs.push_back(
"-frewrite-includes");
7359 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7360 options::OPT_traditional_cpp)) {
7361 if (isa<PreprocessJobAction>(JA))
7362 CmdArgs.push_back(
"-traditional-cpp");
7364 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7367 Args.AddLastArg(CmdArgs, options::OPT_dM);
7368 Args.AddLastArg(CmdArgs, options::OPT_dD);
7369 Args.AddLastArg(CmdArgs, options::OPT_dI);
7371 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7374 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7375 CmdArgs.push_back(
"-serialize-diagnostic-file");
7376 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7379 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7380 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7383 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7385 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7388 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7389 CmdArgs.push_back(
"-load");
7390 CmdArgs.push_back(A->getValue());
7402 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7403 auto ArgValue = StringRef(A->getValue());
7404 auto FirstDashIndex = ArgValue.find(
'-');
7405 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7406 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7409 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7410 if (PluginName.empty()) {
7411 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7413 D.
Diag(diag::warn_drv_missing_plugin_arg)
7414 << PluginName << A->getAsString(Args);
7419 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7420 CmdArgs.push_back(Args.MakeArgString(Arg));
7424 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7426 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7431 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7432 CmdArgs.push_back(
"--vfsoverlay");
7433 CmdArgs.push_back(A->getValue());
7437 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7438 options::OPT_fno_safe_buffer_usage_suggestions);
7442 if (!StatsFile.empty()) {
7443 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7445 CmdArgs.push_back(
"-stats-file-append");
7450 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7454 if (
C.getDriver().isSaveTempsEnabled() &&
7455 !isa<PreprocessJobAction>(JA)) {
7456 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7459 CmdArgs.push_back(Arg->getValue());
7461 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7467 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7468 CmdArgs.push_back(
"-disable-llvm-optzns");
7470 A->render(Args, CmdArgs);
7482 if ((
C.getDriver().isSaveTempsEnabled() ||
7484 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7485 isa<CompileJobAction>(JA))
7486 CmdArgs.push_back(
"-disable-llvm-passes");
7488 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7497 auto GRecordSwitches =
7498 Args.hasFlag(options::OPT_grecord_command_line,
7499 options::OPT_gno_record_command_line,
false);
7500 auto FRecordSwitches =
7501 Args.hasFlag(options::OPT_frecord_command_line,
7502 options::OPT_fno_record_command_line,
false);
7503 if (FRecordSwitches && !Triple.isOSBinFormatELF() &&
7504 !Triple.isOSBinFormatXCOFF() && !Triple.isOSBinFormatMachO())
7505 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7506 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
7509 ArgStringList OriginalArgs;
7510 for (
const auto &Arg : Args)
7511 Arg->render(Args, OriginalArgs);
7515 for (
const char *OriginalArg : OriginalArgs) {
7519 Flags += EscapedArg;
7521 auto FlagsArgString = Args.MakeArgString(Flags);
7523 CmdArgs.push_back(
"-dwarf-debug-flags");
7524 CmdArgs.push_back(FlagsArgString);
7526 if (FRecordSwitches) {
7527 CmdArgs.push_back(
"-record-command-line");
7528 CmdArgs.push_back(FlagsArgString);
7535 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7536 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7537 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7538 }
else if (!HostOffloadingInputs.empty()) {
7539 if ((IsCuda || IsHIP) && !IsRDCMode) {
7540 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7541 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7542 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7544 for (
const InputInfo Input : HostOffloadingInputs)
7545 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7551 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7552 options::OPT_fno_cuda_short_ptr,
false))
7553 CmdArgs.push_back(
"-fcuda-short-ptr");
7556 if (IsCuda || IsHIP) {
7558 const Action *SourceAction = &JA;
7560 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7561 SourceAction = SourceAction->
getInputs()[0];
7563 auto CUID = cast<InputAction>(SourceAction)->getId();
7565 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7569 bool UseApproxTranscendentals = Args.hasFlag(
7570 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7571 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7572 options::OPT_fno_gpu_approx_transcendentals,
7573 UseApproxTranscendentals))
7574 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7576 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7577 options::OPT_fno_gpu_approx_transcendentals);
7581 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7582 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7585 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7586 options::OPT_fno_offload_uniform_block);
7588 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7589 options::OPT_fno_offload_implicit_host_device_templates);
7591 if (IsCudaDevice || IsHIPDevice) {
7592 StringRef InlineThresh =
7593 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7594 if (!InlineThresh.empty()) {
7595 std::string ArgStr =
7596 std::string(
"-inline-threshold=") + InlineThresh.str();
7597 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7602 Args.addOptOutFlag(CmdArgs,
7603 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7604 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7611 if (IsOpenMPDevice) {
7612 CmdArgs.push_back(
"-fopenmp-is-target-device");
7613 if (OpenMPDeviceInput) {
7614 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7615 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7619 if (Triple.isAMDGPU()) {
7622 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7623 options::OPT_mno_unsafe_fp_atomics);
7624 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7625 options::OPT_mno_amdgpu_ieee);
7635 std::transform(TCRange.first, TCRange.second, std::back_inserter(Triples),
7636 [](
auto TC) { return TC.second->getTripleString(); });
7637 CmdArgs.push_back(Args.MakeArgString(Targets + llvm::join(Triples,
",")));
7640 bool VirtualFunctionElimination =
7641 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7642 options::OPT_fno_virtual_function_elimination,
false);
7643 if (VirtualFunctionElimination) {
7647 D.
Diag(diag::err_drv_argument_only_allowed_with)
7648 <<
"-fvirtual-function-elimination"
7651 CmdArgs.push_back(
"-fvirtual-function-elimination");
7655 bool WholeProgramVTables = Args.hasFlag(
7656 options::OPT_fwhole_program_vtables,
7657 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7658 if (VirtualFunctionElimination && !WholeProgramVTables) {
7659 D.
Diag(diag::err_drv_argument_not_allowed_with)
7660 <<
"-fno-whole-program-vtables"
7661 <<
"-fvirtual-function-elimination";
7664 if (WholeProgramVTables) {
7674 if ((!IsUsingLTO && !D.
isUsingLTO(!IsDeviceOffloadAction)) ||
7676 D.
Diag(diag::err_drv_argument_only_allowed_with)
7677 <<
"-fwhole-program-vtables"
7678 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7682 CmdArgs.push_back(
"-fwhole-program-vtables");
7685 bool DefaultsSplitLTOUnit =
7686 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7688 (!Triple.isPS4() && UnifiedLTO);
7690 Args.hasFlag(options::OPT_fsplit_lto_unit,
7691 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
7692 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
7693 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
7694 <<
"-fsanitize=cfi";
7696 CmdArgs.push_back(
"-fsplit-lto-unit");
7698 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7699 options::OPT_fno_fat_lto_objects)) {
7700 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
7702 if (!Triple.isOSBinFormatELF()) {
7703 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7706 CmdArgs.push_back(Args.MakeArgString(
7707 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
7708 CmdArgs.push_back(
"-flto-unit");
7709 CmdArgs.push_back(
"-ffat-lto-objects");
7710 A->render(Args, CmdArgs);
7714 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7715 options::OPT_fno_global_isel)) {
7716 CmdArgs.push_back(
"-mllvm");
7717 if (A->getOption().matches(options::OPT_fglobal_isel)) {
7718 CmdArgs.push_back(
"-global-isel=1");
7723 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
7724 bool IsOptLevelSupported =
false;
7726 Arg *A = Args.getLastArg(options::OPT_O_Group);
7727 if (Triple.getArch() == llvm::Triple::aarch64) {
7728 if (!A || A->getOption().matches(options::OPT_O0))
7729 IsOptLevelSupported =
true;
7731 if (!IsArchSupported || !IsOptLevelSupported) {
7732 CmdArgs.push_back(
"-mllvm");
7733 CmdArgs.push_back(
"-global-isel-abort=2");
7735 if (!IsArchSupported)
7736 D.
Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
7738 D.
Diag(diag::warn_drv_global_isel_incomplete_opt);
7741 CmdArgs.push_back(
"-global-isel=0");
7745 if (Args.hasArg(options::OPT_forder_file_instrumentation)) {
7746 CmdArgs.push_back(
"-forder-file-instrumentation");
7751 CmdArgs.push_back(
"-mllvm");
7752 CmdArgs.push_back(
"-enable-order-file-instrumentation");
7756 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7757 options::OPT_fno_force_enable_int128)) {
7758 if (A->getOption().matches(options::OPT_fforce_enable_int128))
7759 CmdArgs.push_back(
"-fforce-enable-int128");
7762 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7763 options::OPT_fno_keep_static_consts);
7764 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7765 options::OPT_fno_keep_persistent_storage_variables);
7766 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7767 options::OPT_fno_complete_member_pointers);
7768 Args.addOptOutFlag(CmdArgs, options::OPT_fcxx_static_destructors,
7769 options::OPT_fno_cxx_static_destructors);
7775 if (Triple.isAArch64() &&
7776 (Args.hasArg(options::OPT_mno_fmv) ||
7777 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
7780 CmdArgs.push_back(
"-target-feature");
7781 CmdArgs.push_back(
"-fmv");
7784 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7791 CmdArgs.push_back(
"-faddrsig");
7793 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
7794 (EH || UnwindTables || AsyncUnwindTables ||
7795 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
7796 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
7798 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7799 std::string Str = A->getAsString(Args);
7801 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7803 CmdArgs.push_back(Args.MakeArgString(Str));
7808 if (Output.
getType() == types::TY_Dependencies) {
7811 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
7812 Output.
getType() == clang::driver::types::TY_IFS) {
7814 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
7815 CmdArgs.push_back(
"-o");
7816 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7818 CmdArgs.push_back(
"-o");
7822 assert(Output.
isNothing() &&
"Invalid output.");
7829 FrontendInputs = ExtractAPIInputs;
7831 FrontendInputs = {};
7833 for (
const InputInfo &Input : FrontendInputs) {
7842 C.addCommand(std::make_unique<CC1Command>(
7846 C.addCommand(std::make_unique<Command>(
7852 if (Output.
getType() == types::TY_Object &&
7853 Args.hasFlag(options::OPT__SLASH_showFilenames,
7854 options::OPT__SLASH_showFilenames_,
false)) {
7855 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
7858 if (Arg *A = Args.getLastArg(options::OPT_pg))
7860 !Args.hasArg(options::OPT_mfentry))
7861 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
7862 << A->getAsString(Args);
7868 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
7872 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
7873 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
7876 Args.ClaimAllArgs(options::OPT_emit_llvm);
7883 :
Tool(
"clang",
"clang frontend", TC), HasBackend(HasIntegratedBackend) {}
7890ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
7892 ArgStringList &cmdArgs,
7893 RewriteKind rewriteKind)
const {
7896 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
7897 options::OPT_fobjc_runtime_EQ);
7902 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
7904 StringRef value = runtimeArg->getValue();
7910 (runtime.
getVersion() >= VersionTuple(2, 0)))
7914 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
7918 runtimeArg->render(args, cmdArgs);
7927 unsigned objcABIVersion = 1;
7929 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
7930 StringRef value = abiArg->getValue();
7933 else if (value ==
"2")
7935 else if (value ==
"3")
7941 bool nonFragileABIIsDefault =
7942 (rewriteKind == RK_NonFragile ||
7943 (rewriteKind == RK_None &&
7945 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
7946 options::OPT_fno_objc_nonfragile_abi,
7947 nonFragileABIIsDefault)) {
7949#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
7950 unsigned nonFragileABIVersion = 1;
7952 unsigned nonFragileABIVersion = 2;
7956 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
7957 StringRef value = abiArg->getValue();
7959 nonFragileABIVersion = 1;
7960 else if (value ==
"2")
7961 nonFragileABIVersion = 2;
7967 objcABIVersion = 1 + nonFragileABIVersion;
7975 bool isNonFragile = objcABIVersion != 1;
7981 switch (rewriteKind) {
7994 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
8006 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
8015 if (llvm::any_of(inputs, [](
const InputInfo &input) {
8019 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
8024 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
8032 bool Asynch =
false;
8033 bool NoUnwindC =
false;
8047 std::vector<std::string> EHArgs =
8048 Args.getAllArgValues(options::OPT__SLASH_EH);
8049 for (
auto EHVal : EHArgs) {
8050 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
8068 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
8074 if (EHArgs.empty() &&
8075 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
8078 EH.NoUnwindC =
true;
8081 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8083 EH.NoUnwindC =
false;
8090void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
8091 ArgStringList &CmdArgs)
const {
8096 if (Arg *ShowIncludes =
8097 Args.getLastArg(options::OPT__SLASH_showIncludes,
8098 options::OPT__SLASH_showIncludes_user)) {
8099 CmdArgs.push_back(
"--show-includes");
8100 if (ShowIncludes->getOption().matches(options::OPT__SLASH_showIncludes))
8101 CmdArgs.push_back(
"-sys-header-deps");
8105 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8107 CmdArgs.push_back(
"-fno-rtti-data");
8111 if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
8113 CmdArgs.push_back(
"-stack-protector");
8120 if (!isNVPTX && (EH.Synch || EH.Asynch)) {
8122 CmdArgs.push_back(
"-fcxx-exceptions");
8123 CmdArgs.push_back(
"-fexceptions");
8125 CmdArgs.push_back(
"-fasync-exceptions");
8127 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
8128 CmdArgs.push_back(
"-fexternc-nounwind");
8131 if (Args.hasArg(options::OPT__SLASH_EP)) {
8132 CmdArgs.push_back(
"-E");
8133 CmdArgs.push_back(
"-P");
8136 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
8137 options::OPT__SLASH_Zc_dllexportInlines,
8139 CmdArgs.push_back(
"-fno-dllexport-inlines");
8142 if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
8143 options::OPT__SLASH_Zc_wchar_t,
false)) {
8144 CmdArgs.push_back(
"-fno-wchar");
8147 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8149 std::vector<std::string> Values =
8150 Args.getAllArgValues(options::OPT__SLASH_arch);
8151 if (!Values.empty()) {
8152 llvm::SmallSet<std::string, 4> SupportedArches;
8153 if (Arch == llvm::Triple::x86)
8154 SupportedArches.insert(
"IA32");
8156 for (
auto &
V : Values)
8157 if (!SupportedArches.contains(
V))
8158 D.
Diag(diag::err_drv_argument_not_allowed_with)
8159 << std::string(
"/arch:").append(
V) <<
"/kernel";
8162 CmdArgs.push_back(
"-fno-rtti");
8163 if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_,
false))
8164 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"/GR"
8168 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
8169 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
8170 if (MostGeneralArg && BestCaseArg)
8171 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
8172 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
8174 if (MostGeneralArg) {
8175 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
8176 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
8177 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
8179 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
8180 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
8181 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
8182 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
8183 << FirstConflict->getAsString(Args)
8184 << SecondConflict->getAsString(Args);
8187 CmdArgs.push_back(
"-fms-memptr-rep=single");
8188 else if (MultipleArg)
8189 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
8191 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
8194 if (Args.hasArg(options::OPT_regcall4))
8195 CmdArgs.push_back(
"-regcall4");
8199 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
8200 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
8201 options::OPT__SLASH_Gregcall)) {
8202 unsigned DCCOptId = CCArg->getOption().getID();
8203 const char *DCCFlag =
nullptr;
8204 bool ArchSupported = !isNVPTX;
8207 case options::OPT__SLASH_Gd:
8208 DCCFlag =
"-fdefault-calling-conv=cdecl";
8210 case options::OPT__SLASH_Gr:
8211 ArchSupported = Arch == llvm::Triple::x86;
8212 DCCFlag =
"-fdefault-calling-conv=fastcall";
8214 case options::OPT__SLASH_Gz:
8215 ArchSupported = Arch == llvm::Triple::x86;
8216 DCCFlag =
"-fdefault-calling-conv=stdcall";
8218 case options::OPT__SLASH_Gv:
8219 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8220 DCCFlag =
"-fdefault-calling-conv=vectorcall";
8222 case options::OPT__SLASH_Gregcall:
8223 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8224 DCCFlag =
"-fdefault-calling-conv=regcall";
8229 if (ArchSupported && DCCFlag)
8230 CmdArgs.push_back(DCCFlag);
8233 if (Args.hasArg(options::OPT__SLASH_Gregcall4))
8234 CmdArgs.push_back(
"-regcall4");
8236 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
8238 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
8239 CmdArgs.push_back(
"-fdiagnostics-format");
8240 CmdArgs.push_back(
"msvc");
8243 if (Args.hasArg(options::OPT__SLASH_kernel))
8244 CmdArgs.push_back(
"-fms-kernel");
8246 for (
const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
8247 StringRef GuardArgs = A->getValue();
8250 if (GuardArgs.equals_insensitive(
"cf")) {
8252 CmdArgs.push_back(
"-cfguard");
8253 }
else if (GuardArgs.equals_insensitive(
"cf,nochecks")) {
8255 CmdArgs.push_back(
"-cfguard-no-checks");
8256 }
else if (GuardArgs.equals_insensitive(
"ehcont")) {
8258 CmdArgs.push_back(
"-ehcontguard");
8259 }
else if (GuardArgs.equals_insensitive(
"cf-") ||
8260 GuardArgs.equals_insensitive(
"ehcont-")) {
8263 D.
Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
8271 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
8278 if (
const char *End = strrchr(Str,
'.'))
8279 return Args.MakeArgString(std::string(Str, End));
8288 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
8290 llvm::sys::path::replace_extension(OutputFilename, llvm::Twine(
'd'));
8291 return Args.MakeArgString(OutputFilename);
8300 ArgStringList &CmdArgs)
const {
8306 CmdArgs.push_back(
"-target-abi");
8307 CmdArgs.push_back(ABIName.data());
8311 ArgStringList &CmdArgs)
const {
8315 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
8316 StringRef
Value = A->getValue();
8318 CmdArgs.push_back(
"-mllvm");
8319 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
8322 << A->getSpelling() <<
Value;
8328 ArgStringList &CmdArgs)
const {
8329 CmdArgs.push_back(
"-target-abi");
8336 ArgStringList &CmdArgs)
const {
8340 CmdArgs.push_back(
"-target-abi");
8341 CmdArgs.push_back(ABIName.data());
8343 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8344 options::OPT_mno_default_build_attributes,
true)) {
8345 CmdArgs.push_back(
"-mllvm");
8346 CmdArgs.push_back(
"-riscv-add-build-attributes");
8352 const ArgList &Args,
8353 const char *LinkingOutput)
const {
8354 ArgStringList CmdArgs;
8356 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
8360 const std::string &TripleStr = Triple.getTriple();
8364 Args.ClaimAllArgs(options::OPT_w);
8366 Args.ClaimAllArgs(options::OPT_emit_llvm);
8373 CmdArgs.push_back(
"-cc1as");
8376 CmdArgs.push_back(
"-triple");
8377 CmdArgs.push_back(Args.MakeArgString(TripleStr));
8383 CmdArgs.push_back(
"-filetype");
8384 CmdArgs.push_back(
"obj");
8388 CmdArgs.push_back(
"-main-file-name");
8392 std::string CPU =
getCPUName(D, Args, Triple,
true);
8394 CmdArgs.push_back(
"-target-cpu");
8395 CmdArgs.push_back(Args.MakeArgString(CPU));
8402 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
8405 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
8408 auto FindSource = [](
const Action *S) ->
const Action * {
8410 assert(!S->getInputs().empty() &&
"unexpected root action!");
8411 S = S->getInputs()[0];
8415 const Action *SourceAction = FindSource(&JA);
8419 bool WantDebug =
false;
8420 Args.ClaimAllArgs(options::OPT_g_Group);
8421 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8422 WantDebug = !A->getOption().matches(options::OPT_g0) &&
8423 !A->getOption().matches(options::OPT_ggdb0);
8425 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
8426 llvm::codegenoptions::NoDebugInfo;
8429 const char *DebugCompilationDir =
8432 if (SourceAction->
getType() == types::TY_Asm ||
8433 SourceAction->
getType() == types::TY_PP_Asm) {
8438 DebugInfoKind = (WantDebug ? llvm::codegenoptions::DebugInfoConstructor
8439 : llvm::codegenoptions::NoDebugInfo);
8446 CmdArgs.push_back(
"-dwarf-debug-producer");
8450 Args.AddAllArgs(CmdArgs, options::OPT_I);
8454 llvm::DebuggerKind::Default);
8460 llvm::Reloc::Model RelocationModel;
8463 std::tie(RelocationModel, PICLevel, IsPIE) =
8468 CmdArgs.push_back(
"-mrelocation-model");
8469 CmdArgs.push_back(RMName);
8475 ArgStringList OriginalArgs;
8476 for (
const auto &Arg : Args)
8477 Arg->render(Args, OriginalArgs);
8482 for (
const char *OriginalArg : OriginalArgs) {
8486 Flags += EscapedArg;
8488 CmdArgs.push_back(
"-dwarf-debug-flags");
8489 CmdArgs.push_back(Args.MakeArgString(Flags));
8499 case llvm::Triple::mips:
8500 case llvm::Triple::mipsel:
8501 case llvm::Triple::mips64:
8502 case llvm::Triple::mips64el:
8506 case llvm::Triple::x86:
8507 case llvm::Triple::x86_64:
8511 case llvm::Triple::arm:
8512 case llvm::Triple::armeb:
8513 case llvm::Triple::thumb:
8514 case llvm::Triple::thumbeb:
8517 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8518 options::OPT_mno_default_build_attributes,
true)) {
8519 CmdArgs.push_back(
"-mllvm");
8520 CmdArgs.push_back(
"-arm-add-build-attributes");
8524 case llvm::Triple::aarch64:
8525 case llvm::Triple::aarch64_32:
8526 case llvm::Triple::aarch64_be:
8527 if (Args.hasArg(options::OPT_mmark_bti_property)) {
8528 CmdArgs.push_back(
"-mllvm");
8529 CmdArgs.push_back(
"-aarch64-mark-bti-property");
8533 case llvm::Triple::loongarch32:
8534 case llvm::Triple::loongarch64:
8538 case llvm::Triple::riscv32:
8539 case llvm::Triple::riscv64:
8543 case llvm::Triple::hexagon:
8544 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8545 options::OPT_mno_default_build_attributes,
true)) {
8546 CmdArgs.push_back(
"-mllvm");
8547 CmdArgs.push_back(
"-hexagon-add-build-attributes");
8557 Args.ClaimAllArgs(options::OPT_W_Group);
8562 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
8564 if (DebugInfoKind > llvm::codegenoptions::NoDebugInfo && Output.
isFilename())
8571 if (SourceAction != FindSource(&J.getSource()))
8573 auto &JArgs = J.getArguments();
8574 for (
unsigned I = 0; I < JArgs.size(); ++I) {
8575 if (StringRef(JArgs[I]).starts_with(
"-object-file-name=") &&
8577 ArgStringList NewArgs(JArgs.begin(), JArgs.begin() + I);
8580 NewArgs.append(JArgs.begin() + I + 1, JArgs.end());
8581 J.replaceArguments(NewArgs);
8587 assert(Output.
isFilename() &&
"Unexpected lipo output.");
8588 CmdArgs.push_back(
"-o");
8594 T.isOSBinFormatELF()) {
8595 CmdArgs.push_back(
"-split-dwarf-output");
8599 if (Triple.isAMDGPU())
8602 assert(Input.
isFilename() &&
"Invalid input.");
8608 C.addCommand(std::make_unique<CC1Command>(
8612 C.addCommand(std::make_unique<Command>(
8622 const llvm::opt::ArgList &TCArgs,
8623 const char *LinkingOutput)
const {
8625 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
8635 ArgStringList CmdArgs;
8638 CmdArgs.push_back(TCArgs.MakeArgString(
8641 assert(JA.
getInputs().size() == Inputs.size() &&
8642 "Not have inputs for all dependence actions??");
8646 Triples +=
"-targets=";
8647 for (
unsigned I = 0; I < Inputs.size(); ++I) {
8656 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
8658 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
8659 assert(CurTC ==
nullptr &&
"Expected one dependence!");
8666 Triples += CurTC->
getTriple().normalize();
8675 StringRef GPUArchName;
8678 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
8679 auto ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
8680 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
8682 GPUArchName = ArchStr.substr(7);
8687 Triples += GPUArchName.str();
8690 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
8694 TCArgs.MakeArgString(Twine(
"-output=") + Output.
getFilename()));
8697 for (
unsigned I = 0; I < Inputs.size(); ++I) {
8703 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
8705 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
8706 assert(CurTC ==
nullptr &&
"Expected one dependence!");
8709 UB +=
C.addTempFile(
8714 CmdArgs.push_back(TCArgs.MakeArgString(UB));
8718 C.addCommand(std::make_unique<Command>(
8721 CmdArgs, std::nullopt, Output));
8726 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
8727 const char *LinkingOutput)
const {
8729 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
8740 ArgStringList CmdArgs;
8742 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
8746 CmdArgs.push_back(TCArgs.MakeArgString(
8751 Triples +=
"-targets=";
8752 auto DepInfo = UA.getDependentActionsInfo();
8753 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
8757 auto &Dep = DepInfo[I];
8760 Triples += Dep.DependentToolChain->getTriple().normalize();
8763 !Dep.DependentBoundArch.empty()) {
8765 Triples += Dep.DependentBoundArch;
8769 StringRef GPUArchName;
8772 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
8773 StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
8774 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
8776 GPUArchName = ArchStr.substr(7);
8781 Triples += GPUArchName.str();
8785 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
8789 TCArgs.MakeArgString(Twine(
"-input=") + Input.
getFilename()));
8792 for (
unsigned I = 0; I < Outputs.size(); ++I) {
8795 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
8796 CmdArgs.push_back(TCArgs.MakeArgString(UB));
8798 CmdArgs.push_back(
"-unbundle");
8799 CmdArgs.push_back(
"-allow-missing-bundles");
8800 if (TCArgs.hasArg(options::OPT_v))
8801 CmdArgs.push_back(
"-verbose");
8804 C.addCommand(std::make_unique<Command>(
8807 CmdArgs, std::nullopt, Outputs));
8813 const llvm::opt::ArgList &Args,
8814 const char *LinkingOutput)
const {
8815 ArgStringList CmdArgs;
8818 assert(Output.
isFilename() &&
"Invalid output.");
8819 CmdArgs.push_back(
"-o");
8826 const ArgList &TCArgs =
8832 : TCArgs.getLastArgValue(options::OPT_march_EQ);
8836 ArgStringList Features;
8840 llvm::copy_if(Features, std::back_inserter(FeatureArgs),
8841 [](StringRef Arg) {
return !Arg.starts_with(
"-target"); });
8844 for (StringRef Feature : llvm::split(Arch.split(
':').second,
':')) {
8845 FeatureArgs.emplace_back(
8846 Args.MakeArgString(Feature.take_back() + Feature.drop_back()));
8853 "file=" +
File.str(),
8855 "arch=" + Arch.str(),
8856 "kind=" + Kind.str(),
8861 for (StringRef Feature : FeatureArgs)
8862 Parts.emplace_back(
"feature=" + Feature.str());
8864 CmdArgs.push_back(Args.MakeArgString(
"--image=" + llvm::join(Parts,
",")));
8867 C.addCommand(std::make_unique<Command>(
8870 CmdArgs, Inputs, Output));
8876 const ArgList &Args,
8877 const char *LinkingOutput)
const {
8880 ArgStringList CmdArgs;
8884 auto TCRange =
C.getOffloadToolChains(Kind);
8885 for (
auto &I : llvm::make_range(TCRange.first, TCRange.second)) {
8889 if (CudaInstallation.
isValid())
8890 CmdArgs.push_back(Args.MakeArgString(
8898 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
8900 if (A->getOption().matches(options::OPT_O4) ||
8901 A->getOption().matches(options::OPT_Ofast))
8903 else if (A->getOption().matches(options::OPT_O)) {
8904 OOpt = A->getValue();
8907 else if (OOpt ==
"s" || OOpt ==
"z")
8909 }
else if (A->getOption().matches(options::OPT_O0))
8912 CmdArgs.push_back(Args.MakeArgString(Twine(
"--opt-level=O") + OOpt));
8916 Args.MakeArgString(
"--host-triple=" + TheTriple.getTriple()));
8917 if (Args.hasArg(options::OPT_v))
8918 CmdArgs.push_back(
"--wrapper-verbose");
8920 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
8921 if (!A->getOption().matches(options::OPT_g0))
8922 CmdArgs.push_back(
"--device-debug");
8927 if (
const Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
8928 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
8929 CmdArgs.push_back(Args.MakeArgString(
8930 Twine(
"--amdhsa-code-object-version=") + A->getValue()));
8933 for (
const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
8934 CmdArgs.push_back(Args.MakeArgString(
"--ptxas-arg=" + A));
8937 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
8938 CmdArgs.push_back(Args.MakeArgString(Twine(
"--offload-opt=-pass-remarks=") +
8940 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
8941 CmdArgs.push_back(Args.MakeArgString(
8942 Twine(
"--offload-opt=-pass-remarks-missed=") + A->getValue()));
8943 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
8944 CmdArgs.push_back(Args.MakeArgString(
8945 Twine(
"--offload-opt=-pass-remarks-analysis=") + A->getValue()));
8946 if (Args.getLastArg(options::OPT_save_temps_EQ))
8947 CmdArgs.push_back(
"--save-temps");
8950 Linker->
ConstructJob(
C, JA, Output, Inputs, Args, LinkingOutput);
8951 const auto &LinkCommand =
C.getJobs().getJobs().back();
8954 for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) {
8955 StringRef Val = A->getValue(0);
8958 Args.MakeArgString(Twine(
"--device-linker=") + A->getValue(1)));
8960 CmdArgs.push_back(Args.MakeArgString(
8961 "--device-linker=" +
8965 Args.ClaimAllArgs(options::OPT_Xoffload_linker);
8968 if (Args.hasFlag(options::OPT_fopenmp_target_jit,
8969 options::OPT_fno_openmp_target_jit,
false))
8970 CmdArgs.push_back(
"--embed-bitcode");
8973 for (Arg *A : Args.filtered(options::OPT_mllvm)) {
8974 CmdArgs.push_back(
"-mllvm");
8975 CmdArgs.push_back(A->getValue());
8980 CmdArgs.push_back(Args.MakeArgString(Twine(
"--linker-path=") +
8981 LinkCommand->getExecutable()));
8982 for (
const char *LinkArg : LinkCommand->getArguments())
8983 CmdArgs.push_back(LinkArg);
8988 Args.MakeArgString(
getToolChain().GetProgramPath(
"clang-linker-wrapper"));
8992 LinkCommand->replaceExecutable(Exec);
8993 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 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 EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args)
/EH controls whether to run destructor cleanups when exceptions are thrown.
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 bool gchProbe(const Driver &D, StringRef Path)
static bool UseRelaxAll(Compilation &C, const ArgList &Args)
Check if -relax-all should be passed to the internal assembler.
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 void ProcessVSRuntimeLibrary(const ArgList &Args, ArgStringList &CmdArgs)
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 bool ContainsCompileAction(const Action *A)
Check whether the given input tree contains any compilation actions.
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)
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()