36#include "clang/Config/config.h"
45#include "llvm/ADT/ScopeExit.h"
46#include "llvm/ADT/SmallSet.h"
47#include "llvm/ADT/StringExtras.h"
48#include "llvm/BinaryFormat/Magic.h"
49#include "llvm/Config/llvm-config.h"
50#include "llvm/Frontend/Debug/Options.h"
51#include "llvm/Object/ObjectFile.h"
52#include "llvm/Option/ArgList.h"
53#include "llvm/Support/CodeGen.h"
54#include "llvm/Support/Compiler.h"
55#include "llvm/Support/Compression.h"
56#include "llvm/Support/Error.h"
57#include "llvm/Support/FileSystem.h"
58#include "llvm/Support/Path.h"
59#include "llvm/Support/Process.h"
60#include "llvm/Support/YAMLParser.h"
61#include "llvm/TargetParser/AArch64TargetParser.h"
62#include "llvm/TargetParser/ARMTargetParserCommon.h"
63#include "llvm/TargetParser/Host.h"
64#include "llvm/TargetParser/LoongArchTargetParser.h"
65#include "llvm/TargetParser/PPCTargetParser.h"
66#include "llvm/TargetParser/RISCVISAInfo.h"
67#include "llvm/TargetParser/RISCVTargetParser.h"
76 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
77 options::OPT_fminimize_whitespace,
78 options::OPT_fno_minimize_whitespace,
79 options::OPT_fkeep_system_includes,
80 options::OPT_fno_keep_system_includes)) {
81 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
82 !Args.hasArg(options::OPT__SLASH_EP) && !
D.CCCIsCPP()) {
83 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
84 << A->getBaseArg().getAsString(Args)
85 << (
D.IsCLMode() ?
"/E, /P or /EP" :
"-E");
92 if (Args.hasArg(options::OPT_static))
94 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
95 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
104 llvm::function_ref<
void(
const ToolChain &)> Work) {
106 Work(RegularToolChain);
121 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
128 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
143 const Arg &A,
size_t &Position) {
144 const char RefinementStepToken =
':';
145 Position = In.find(RefinementStepToken);
146 if (Position != StringRef::npos) {
147 StringRef Option = A.getOption().getName();
148 StringRef RefStep = In.substr(Position + 1);
156 if (RefStep.size() != 1) {
157 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
160 char RefStepChar = RefStep[0];
161 if (RefStepChar <
'0' || RefStepChar >
'9') {
162 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
171 ArgStringList &OutStrings) {
172 StringRef DisabledPrefixIn =
"!";
173 StringRef DisabledPrefixOut =
"!";
174 StringRef EnabledPrefixOut =
"";
175 StringRef Out =
"-mrecip=";
177 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
181 unsigned NumOptions = A->getNumValues();
182 if (NumOptions == 0) {
184 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
189 if (NumOptions == 1) {
190 StringRef Val = A->getValue(0);
194 StringRef ValBase = Val.slice(0, RefStepLoc);
195 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
196 OutStrings.push_back(Args.MakeArgString(Out + Val));
205 llvm::StringMap<bool> OptionStrings;
206 OptionStrings.insert(std::make_pair(
"divd",
false));
207 OptionStrings.insert(std::make_pair(
"divf",
false));
208 OptionStrings.insert(std::make_pair(
"divh",
false));
209 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
210 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
211 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
212 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
213 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
214 OptionStrings.insert(std::make_pair(
"sqrth",
false));
215 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
216 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
217 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
219 for (
unsigned i = 0; i != NumOptions; ++i) {
220 StringRef Val = A->getValue(i);
222 bool IsDisabled = Val.starts_with(DisabledPrefixIn);
231 StringRef ValBase = Val.slice(0, RefStep);
232 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
233 if (OptionIter == OptionStrings.end()) {
235 OptionIter = OptionStrings.find(ValBase.str() +
'f');
236 if (OptionIter == OptionStrings.end()) {
238 D.Diag(diag::err_drv_unknown_argument) << Val;
244 if (OptionStrings[ValBase.str() +
'd'] ||
245 OptionStrings[ValBase.str() +
'h']) {
246 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
251 if (OptionIter->second ==
true) {
253 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
258 OptionIter->second =
true;
262 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
263 OptionStrings[ValBase.str() +
'd'] =
true;
264 OptionStrings[ValBase.str() +
'h'] =
true;
268 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
269 Out = Args.MakeArgString(Out + Prefix + Val);
270 if (i != NumOptions - 1)
271 Out = Args.MakeArgString(Out +
",");
274 OutStrings.push_back(Args.MakeArgString(Out));
280 ArgStringList &CmdArgs) {
281 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
285 StringRef
Value = A->getValue();
286 if (
Value ==
"none") {
287 CmdArgs.push_back(
"-mprefer-vector-width=none");
290 if (
Value.getAsInteger(10, Width)) {
291 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
294 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
300 const llvm::Triple &Triple) {
307 if (!Triple.isMacOSX())
310 return (!Triple.isMacOSXVersionLT(10, 5) &&
311 (Triple.getArch() == llvm::Triple::x86_64 ||
312 Triple.getArch() == llvm::Triple::arm));
322 ArgStringList &CmdArgs) {
323 const llvm::Triple &Triple = TC.
getTriple();
328 Args.ClaimAllArgs(options::OPT_fexceptions);
329 Args.ClaimAllArgs(options::OPT_fno_exceptions);
330 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
331 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
332 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
333 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
334 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
335 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
340 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
344 if (Triple.isWindowsMSVCEnvironment()) {
345 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
346 options::OPT_fno_async_exceptions,
false);
348 CmdArgs.push_back(
"-fasync-exceptions");
356 Args.hasFlag(options::OPT_fobjc_exceptions,
357 options::OPT_fno_objc_exceptions,
true)) {
358 CmdArgs.push_back(
"-fobjc-exceptions");
365 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
366 !Triple.isPS() && !Triple.isDriverKit();
367 Arg *ExceptionArg = Args.getLastArg(
368 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
369 options::OPT_fexceptions, options::OPT_fno_exceptions);
371 CXXExceptionsEnabled =
372 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
373 ExceptionArg->getOption().matches(options::OPT_fexceptions);
375 if (CXXExceptionsEnabled) {
376 CmdArgs.push_back(
"-fcxx-exceptions");
385 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
387 Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,
388 options::OPT_fno_assume_nothrow_exception_dtor);
391 CmdArgs.push_back(
"-fexceptions");
407 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
413 ArgStringList &CmdArgs,
414 const llvm::vfs::FileSystem &VFS) {
415 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
416 options::OPT_fdebug_compilation_dir_EQ)) {
417 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
418 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
421 A->render(Args, CmdArgs);
422 }
else if (llvm::ErrorOr<std::string> CWD =
423 VFS.getCurrentWorkingDirectory()) {
424 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
426 StringRef
Path(CmdArgs.back());
427 return Path.substr(
Path.find(
'=') + 1).data();
431 const char *DebugCompilationDir,
432 const char *OutputFileName) {
434 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
435 if (StringRef(Arg->getValue()).starts_with(
"-object-file-name"))
438 if (Args.hasArg(options::OPT_object_file_name_EQ))
442 if (ObjFileNameForDebug !=
"-" &&
443 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
444 (!DebugCompilationDir ||
445 llvm::sys::path::is_absolute(DebugCompilationDir))) {
447 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
453 llvm::sys::path::Style Style =
454 llvm::sys::path::is_absolute(ObjFileNameForDebug)
455 ? llvm::sys::path::Style::native
456 : llvm::sys::path::Style::windows_backslash;
457 llvm::sys::path::remove_dots(ObjFileNameForDebug,
true,
460 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
465 const ArgList &Args, ArgStringList &CmdArgs) {
466 auto AddOneArg = [&](StringRef Map, StringRef Name) {
467 if (!Map.contains(
'='))
468 D.Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
470 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
473 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
474 options::OPT_fdebug_prefix_map_EQ)) {
475 AddOneArg(A->getValue(), A->getOption().getName());
479 if (GlobalRemapEntry.empty())
481 AddOneArg(GlobalRemapEntry,
"environment");
486 ArgStringList &CmdArgs) {
487 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
488 options::OPT_fmacro_prefix_map_EQ)) {
489 StringRef Map = A->getValue();
490 if (!Map.contains(
'='))
491 D.Diag(diag::err_drv_invalid_argument_to_option)
492 << Map << A->getOption().getName();
494 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
501 ArgStringList &CmdArgs) {
502 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
503 options::OPT_fcoverage_prefix_map_EQ)) {
504 StringRef Map = A->getValue();
505 if (!Map.contains(
'='))
506 D.Diag(diag::err_drv_invalid_argument_to_option)
507 << Map << A->getOption().getName();
509 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
518 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
519 if (A->getOption().matches(options::OPT_O4) ||
520 A->getOption().matches(options::OPT_Ofast))
523 if (A->getOption().matches(options::OPT_O0))
526 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
529 StringRef S(A->getValue());
537 unsigned OptLevel = 0;
538 if (S.getAsInteger(10, OptLevel))
549 ArgStringList &CmdArgs) {
552 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
555 CmdArgs.push_back(
"-x");
556 if (Args.hasArg(options::OPT_rewrite_objc))
562 const char *ClangType;
564 case types::TY_CXXModule:
567 case types::TY_PP_CXXModule:
568 ClangType =
"c++-cpp-output";
574 CmdArgs.push_back(ClangType);
581 ArgStringList &CmdArgs) {
583 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
584 options::OPT_fprofile_generate_EQ,
585 options::OPT_fno_profile_generate);
586 if (PGOGenerateArg &&
587 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
588 PGOGenerateArg =
nullptr;
592 auto *ProfileGenerateArg = Args.getLastArg(
593 options::OPT_fprofile_instr_generate,
594 options::OPT_fprofile_instr_generate_EQ,
595 options::OPT_fno_profile_instr_generate);
596 if (ProfileGenerateArg &&
597 ProfileGenerateArg->getOption().matches(
598 options::OPT_fno_profile_instr_generate))
599 ProfileGenerateArg =
nullptr;
601 if (PGOGenerateArg && ProfileGenerateArg)
602 D.Diag(diag::err_drv_argument_not_allowed_with)
603 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
607 if (PGOGenerateArg && ProfileUseArg)
608 D.Diag(diag::err_drv_argument_not_allowed_with)
609 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
611 if (ProfileGenerateArg && ProfileUseArg)
612 D.Diag(diag::err_drv_argument_not_allowed_with)
613 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
615 if (CSPGOGenerateArg && PGOGenerateArg) {
616 D.Diag(diag::err_drv_argument_not_allowed_with)
617 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
618 PGOGenerateArg =
nullptr;
623 D.Diag(diag::err_drv_unsupported_opt_for_target)
624 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
627 if (ProfileGenerateArg) {
628 if (ProfileGenerateArg->getOption().matches(
629 options::OPT_fprofile_instr_generate_EQ))
630 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
631 ProfileGenerateArg->getValue()));
633 CmdArgs.push_back(
"-fprofile-instrument=clang");
634 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
635 Args.hasFlag(options::OPT_frtlib_defaultlib,
636 options::OPT_fno_rtlib_defaultlib,
true)) {
638 CmdArgs.push_back(Args.MakeArgString(
643 if (
auto *ColdFuncCoverageArg = Args.getLastArg(
644 options::OPT_fprofile_generate_cold_function_coverage,
645 options::OPT_fprofile_generate_cold_function_coverage_EQ)) {
647 ColdFuncCoverageArg->getOption().matches(
648 options::OPT_fprofile_generate_cold_function_coverage_EQ)
649 ? ColdFuncCoverageArg->getValue()
651 llvm::sys::path::append(
Path,
"default_%m.profraw");
656 CmdArgs.push_back(
"-mllvm");
657 CmdArgs.push_back(Args.MakeArgString(
658 Twine(
"--instrument-cold-function-only-path=") +
Path));
659 CmdArgs.push_back(
"-mllvm");
660 CmdArgs.push_back(
"--pgo-instrument-cold-function-only");
661 CmdArgs.push_back(
"-mllvm");
662 CmdArgs.push_back(
"--pgo-function-entry-coverage");
665 Arg *PGOGenArg =
nullptr;
666 if (PGOGenerateArg) {
667 assert(!CSPGOGenerateArg);
668 PGOGenArg = PGOGenerateArg;
669 CmdArgs.push_back(
"-fprofile-instrument=llvm");
671 if (CSPGOGenerateArg) {
672 assert(!PGOGenerateArg);
673 PGOGenArg = CSPGOGenerateArg;
674 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
677 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
678 Args.hasFlag(options::OPT_frtlib_defaultlib,
679 options::OPT_fno_rtlib_defaultlib,
true)) {
681 CmdArgs.push_back(Args.MakeArgString(
684 if (PGOGenArg->getOption().matches(
685 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
686 : options::OPT_fcs_profile_generate_EQ)) {
688 llvm::sys::path::append(
Path,
"default_%m.profraw");
690 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
Path));
695 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
696 CmdArgs.push_back(Args.MakeArgString(
697 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
698 else if ((ProfileUseArg->getOption().matches(
699 options::OPT_fprofile_use_EQ) ||
700 ProfileUseArg->getOption().matches(
701 options::OPT_fprofile_instr_use))) {
703 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
704 if (
Path.empty() || llvm::sys::fs::is_directory(
Path))
705 llvm::sys::path::append(
Path,
"default.profdata");
707 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") +
Path));
711 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
712 options::OPT_fno_test_coverage,
false) ||
713 Args.hasArg(options::OPT_coverage);
716 if (Args.hasFlag(options::OPT_fcoverage_mapping,
717 options::OPT_fno_coverage_mapping,
false)) {
718 if (!ProfileGenerateArg)
719 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
720 <<
"-fcoverage-mapping"
721 <<
"-fprofile-instr-generate";
723 CmdArgs.push_back(
"-fcoverage-mapping");
726 if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
728 if (!Args.hasFlag(options::OPT_fcoverage_mapping,
729 options::OPT_fno_coverage_mapping,
false))
730 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
732 <<
"-fcoverage-mapping";
734 CmdArgs.push_back(
"-fcoverage-mcdc");
737 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
738 options::OPT_fcoverage_compilation_dir_EQ)) {
739 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
740 CmdArgs.push_back(Args.MakeArgString(
741 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
743 A->render(Args, CmdArgs);
744 }
else if (llvm::ErrorOr<std::string> CWD =
745 D.getVFS().getCurrentWorkingDirectory()) {
746 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
749 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
750 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
751 if (!Args.hasArg(options::OPT_coverage))
752 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
753 <<
"-fprofile-exclude-files="
756 StringRef
v = Arg->getValue();
758 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
761 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
762 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
763 if (!Args.hasArg(options::OPT_coverage))
764 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
765 <<
"-fprofile-filter-files="
768 StringRef
v = Arg->getValue();
769 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
772 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
773 StringRef Val = A->getValue();
774 if (Val ==
"atomic" || Val ==
"prefer-atomic")
775 CmdArgs.push_back(
"-fprofile-update=atomic");
776 else if (Val !=
"single")
777 D.Diag(diag::err_drv_unsupported_option_argument)
778 << A->getSpelling() << Val;
781 int FunctionGroups = 1;
782 int SelectedFunctionGroup = 0;
783 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
784 StringRef Val = A->getValue();
785 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
786 D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
789 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
790 StringRef Val = A->getValue();
791 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
792 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
793 D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
795 if (FunctionGroups != 1)
796 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
797 Twine(FunctionGroups)));
798 if (SelectedFunctionGroup != 0)
799 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
800 Twine(SelectedFunctionGroup)));
806 Arg *FProfileDir =
nullptr;
807 if (Args.hasArg(options::OPT_fprofile_arcs) ||
808 Args.hasArg(options::OPT_coverage))
809 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
814 if (EmitCovNotes || EmitCovData) {
816 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
819 CoverageFilename = DumpDir->getValue();
820 CoverageFilename += llvm::sys::path::filename(Output.
getBaseInput());
821 }
else if (Arg *FinalOutput =
822 C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
823 CoverageFilename = FinalOutput->getValue();
824 }
else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o)) {
825 CoverageFilename = FinalOutput->getValue();
827 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
829 if (llvm::sys::path::is_relative(CoverageFilename))
830 (void)
D.getVFS().makeAbsolute(CoverageFilename);
831 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
834 Args.MakeArgString(
"-coverage-notes-file=" + CoverageFilename));
840 CoverageFilename = FProfileDir->getValue();
841 llvm::sys::path::append(CoverageFilename, Gcno);
843 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
845 Args.MakeArgString(
"-coverage-data-file=" + CoverageFilename));
852 llvm::codegenoptions::DebugInfoKind DebugInfoKind,
853 unsigned DwarfVersion,
854 llvm::DebuggerKind DebuggerTuning) {
856 if (DwarfVersion > 0)
858 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
859 switch (DebuggerTuning) {
860 case llvm::DebuggerKind::GDB:
861 CmdArgs.push_back(
"-debugger-tuning=gdb");
863 case llvm::DebuggerKind::LLDB:
864 CmdArgs.push_back(
"-debugger-tuning=lldb");
866 case llvm::DebuggerKind::SCE:
867 CmdArgs.push_back(
"-debugger-tuning=sce");
869 case llvm::DebuggerKind::DBX:
870 CmdArgs.push_back(
"-debugger-tuning=dbx");
879 assert(A &&
"Expected non-nullptr argument.");
882 D.Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
888 ArgStringList &CmdArgs,
891 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
895 StringRef
Value = A->getValue();
896 if (
Value ==
"none") {
897 CmdArgs.push_back(
"--compress-debug-sections=none");
898 }
else if (
Value ==
"zlib") {
899 if (llvm::compression::zlib::isAvailable()) {
901 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
903 D.Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
905 }
else if (
Value ==
"zstd") {
906 if (llvm::compression::zstd::isAvailable()) {
908 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
910 D.Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
913 D.Diag(diag::err_drv_unsupported_option_argument)
914 << A->getSpelling() <<
Value;
921 ArgStringList &CmdArgs,
922 bool IsCC1As =
false) {
930 CmdArgs.insert(CmdArgs.begin() + 1,
931 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
933 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
936 CmdArgs.insert(CmdArgs.begin() + 1,
937 Args.MakeArgString(Twine(
"-mcode-object-version=") +
943 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MemBuf =
944 D.getVFS().getBufferForFile(
Path);
947 llvm::file_magic Magic = llvm::identify_magic((*MemBuf)->getBuffer());
948 if (Magic == llvm::file_magic::unknown)
952 if (Magic == llvm::file_magic::clang_ast)
955 llvm::object::ObjectFile::createObjectFile(**MemBuf, Magic);
956 return !Obj.takeError();
960 llvm::ErrorOr<llvm::vfs::Status> Status =
D.getVFS().status(
Path);
964 if (Status->isDirectory()) {
966 for (llvm::vfs::directory_iterator DI =
D.getVFS().dir_begin(
Path, EC), DE;
967 !EC && DI != DE; DI = DI.increment(EC)) {
971 D.Diag(diag::warn_drv_pch_ignoring_gch_dir) <<
Path;
977 D.Diag(diag::warn_drv_pch_ignoring_gch_file) <<
Path;
982 const Driver &
D,
const ArgList &Args,
983 ArgStringList &CmdArgs,
990 Args.AddLastArg(CmdArgs, options::OPT_C);
991 Args.AddLastArg(CmdArgs, options::OPT_CC);
994 Arg *ArgM = Args.getLastArg(options::OPT_MM);
996 ArgM = Args.getLastArg(options::OPT_M);
997 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
999 ArgMD = Args.getLastArg(options::OPT_MD);
1003 CmdArgs.push_back(
"-w");
1009 const char *DepFile;
1010 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1011 DepFile = MF->getValue();
1012 C.addFailureResultFile(DepFile, &JA);
1013 }
else if (Output.
getType() == types::TY_Dependencies) {
1015 }
else if (!ArgMD) {
1019 C.addFailureResultFile(DepFile, &JA);
1021 CmdArgs.push_back(
"-dependency-file");
1022 CmdArgs.push_back(DepFile);
1024 bool HasTarget =
false;
1025 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1028 if (A->getOption().matches(options::OPT_MT)) {
1029 A->render(Args, CmdArgs);
1031 CmdArgs.push_back(
"-MT");
1034 CmdArgs.push_back(Args.MakeArgString(Quoted));
1040 const char *DepTarget;
1044 Arg *OutputOpt = Args.getLastArg(options::OPT_o, options::OPT__SLASH_Fo);
1045 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1046 DepTarget = OutputOpt->getValue();
1052 llvm::sys::path::replace_extension(
P,
"o");
1053 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1056 CmdArgs.push_back(
"-MT");
1059 CmdArgs.push_back(Args.MakeArgString(Quoted));
1062 if (ArgM->getOption().matches(options::OPT_M) ||
1063 ArgM->getOption().matches(options::OPT_MD))
1064 CmdArgs.push_back(
"-sys-header-deps");
1065 if ((isa<PrecompileJobAction>(JA) &&
1066 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1067 Args.hasArg(options::OPT_fmodule_file_deps))
1068 CmdArgs.push_back(
"-module-file-deps");
1071 if (Args.hasArg(options::OPT_MG)) {
1072 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1073 ArgM->getOption().matches(options::OPT_MMD))
1074 D.Diag(diag::err_drv_mg_requires_m_or_mm);
1075 CmdArgs.push_back(
"-MG");
1078 Args.AddLastArg(CmdArgs, options::OPT_MP);
1079 Args.AddLastArg(CmdArgs, options::OPT_MV);
1095 !Args.hasArg(options::OPT_nostdinc) &&
1096 !Args.hasArg(options::OPT_nogpuinc) &&
1099 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1103 llvm::sys::path::append(
P,
"include");
1104 llvm::sys::path::append(
P,
"openmp_wrappers");
1105 CmdArgs.push_back(
"-internal-isystem");
1106 CmdArgs.push_back(Args.MakeArgString(
P));
1109 CmdArgs.push_back(
"-include");
1110 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1113 if (Args.hasArg(options::OPT_foffload_via_llvm)) {
1117 llvm::sys::path::append(
P,
"include",
"llvm_offload_wrappers");
1118 CmdArgs.append({
"-internal-isystem", Args.MakeArgString(
P),
"-include"});
1120 CmdArgs.push_back(
"__llvm_offload_device.h");
1122 CmdArgs.push_back(
"__llvm_offload_host.h");
1132 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1133 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1136 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1139 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1140 options::OPT_fno_pch_instantiate_templates,
true))
1141 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1143 if (YcArg || YuArg) {
1144 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1145 if (!isa<PrecompileJobAction>(JA)) {
1146 CmdArgs.push_back(
"-include-pch");
1147 CmdArgs.push_back(Args.MakeArgString(
D.GetClPchPath(
1148 C, !ThroughHeader.empty()
1150 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1153 if (ThroughHeader.empty()) {
1154 CmdArgs.push_back(Args.MakeArgString(
1155 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1158 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1163 bool RenderedImplicitInclude =
false;
1164 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1165 if (A->getOption().matches(options::OPT_include) &&
1166 D.getProbePrecompiled()) {
1168 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1169 RenderedImplicitInclude =
true;
1171 bool FoundPCH =
false;
1176 llvm::sys::path::replace_extension(
P,
"pch");
1177 if (
D.getVFS().exists(
P))
1182 llvm::sys::path::replace_extension(
P,
"gch");
1187 if (IsFirstImplicitInclude) {
1189 CmdArgs.push_back(
"-include-pch");
1190 CmdArgs.push_back(Args.MakeArgString(
P));
1194 D.Diag(diag::warn_drv_pch_not_first_include) <<
P
1195 << A->getAsString(Args);
1198 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1205 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1208 }
else if (A->getOption().matches(options::OPT_ibuiltininc)) {
1215 A->render(Args, CmdArgs);
1218 Args.addAllArgs(CmdArgs,
1219 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1220 options::OPT_F, options::OPT_embed_dir_EQ});
1228 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1229 options::OPT_Xpreprocessor);
1232 if (Arg *A = Args.getLastArg(options::OPT_I_))
1233 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1237 StringRef sysroot =
C.getSysRoot();
1238 if (sysroot !=
"") {
1239 if (!Args.hasArg(options::OPT_isysroot)) {
1240 CmdArgs.push_back(
"-isysroot");
1241 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1258 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1266 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1269 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1279 if (!Args.hasArg(options::OPT_nostdinc) &&
1280 !Args.hasArg(options::OPT_nogpuinc) &&
1281 !Args.hasArg(options::OPT_nobuiltininc)) {
1289 llvm::sys::path::append(
P,
"include");
1290 llvm::sys::path::append(
P,
getToolChain().getTripleString());
1291 CmdArgs.push_back(
"-internal-isystem");
1292 CmdArgs.push_back(Args.MakeArgString(
P));
1297 llvm::sys::path::append(
P,
"include");
1298 llvm::sys::path::append(
P,
"llvm_libc_wrappers");
1299 CmdArgs.push_back(
"-internal-isystem");
1300 CmdArgs.push_back(Args.MakeArgString(
P));
1307 [&Args, &CmdArgs](
const ToolChain &TC) {
1318 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1319 options::OPT_fno_file_reproducible);
1321 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1322 CmdArgs.push_back(
"-source-date-epoch");
1323 CmdArgs.push_back(Args.MakeArgString(Epoch));
1326 Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,
1327 options::OPT_fno_define_target_os_macros);
1332 switch (Triple.getArch()) {
1336 case llvm::Triple::aarch64:
1337 case llvm::Triple::aarch64_32:
1338 case llvm::Triple::aarch64_be:
1339 case llvm::Triple::arm:
1340 case llvm::Triple::armeb:
1341 case llvm::Triple::thumb:
1342 case llvm::Triple::thumbeb:
1343 if (Triple.isOSDarwin() || Triple.isOSWindows())
1347 case llvm::Triple::ppc:
1348 case llvm::Triple::ppc64:
1349 if (Triple.isOSDarwin())
1353 case llvm::Triple::hexagon:
1354 case llvm::Triple::msp430:
1355 case llvm::Triple::ppcle:
1356 case llvm::Triple::ppc64le:
1357 case llvm::Triple::riscv32:
1358 case llvm::Triple::riscv64:
1359 case llvm::Triple::systemz:
1360 case llvm::Triple::xcore:
1361 case llvm::Triple::xtensa:
1367 const ArgList &Args) {
1370 if (!Triple.isOSDarwin())
1374 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1378 const llvm::Triple &Triple) {
1383 bool hasExplicitOutputFile =
1384 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1386 D.Diag(diag::err_drv_invalid_output_with_multiple_archs)
1387 <<
"-foptimization-record-file";
1394 const llvm::Triple &Triple,
1397 StringRef Format =
"yaml";
1398 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1399 Format = A->getValue();
1401 CmdArgs.push_back(
"-opt-record-file");
1403 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1405 CmdArgs.push_back(A->getValue());
1407 bool hasMultipleArchs =
1408 Triple.isOSDarwin() &&
1409 Args.getAllArgValues(options::OPT_arch).size() > 1;
1413 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1414 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1415 F = FinalOutput->getValue();
1417 if (Format !=
"yaml" &&
1418 Triple.isOSDarwin() &&
1432 llvm::sys::path::replace_extension(F,
"");
1434 Triple.normalize());
1444 if (hasMultipleArchs) {
1448 llvm::sys::path::replace_extension(F,
"");
1451 F += Triple.getArchName();
1453 llvm::sys::path::replace_extension(F, OldExtension);
1457 Extension +=
"opt.";
1458 Extension += Format;
1460 llvm::sys::path::replace_extension(F, Extension);
1461 CmdArgs.push_back(Args.MakeArgString(F));
1465 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1466 CmdArgs.push_back(
"-opt-record-passes");
1467 CmdArgs.push_back(A->getValue());
1470 if (!Format.empty()) {
1471 CmdArgs.push_back(
"-opt-record-format");
1472 CmdArgs.push_back(Format.data());
1477 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1478 options::OPT_fno_aapcs_bitfield_width,
true))
1479 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1481 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1482 CmdArgs.push_back(
"-faapcs-bitfield-load");
1486void RenderARMABI(
const Driver &
D,
const llvm::Triple &Triple,
1487 const ArgList &Args, ArgStringList &CmdArgs) {
1491 const char *ABIName =
nullptr;
1492 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1493 ABIName = A->getValue();
1495 std::string CPU =
getCPUName(
D, Args, Triple,
false);
1496 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1499 CmdArgs.push_back(
"-target-abi");
1500 CmdArgs.push_back(ABIName);
1503void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1504 auto StrictAlignIter =
1505 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1506 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1508 if (StrictAlignIter != CmdArgs.rend() &&
1509 StringRef(*StrictAlignIter) ==
"+strict-align")
1510 CmdArgs.push_back(
"-Wunaligned-access");
1518 if (!DriverArgs.hasArg(options::OPT_fptrauth_intrinsics,
1519 options::OPT_fno_ptrauth_intrinsics))
1520 CC1Args.push_back(
"-fptrauth-intrinsics");
1522 if (!DriverArgs.hasArg(options::OPT_fptrauth_calls,
1523 options::OPT_fno_ptrauth_calls))
1524 CC1Args.push_back(
"-fptrauth-calls");
1526 if (!DriverArgs.hasArg(options::OPT_fptrauth_returns,
1527 options::OPT_fno_ptrauth_returns))
1528 CC1Args.push_back(
"-fptrauth-returns");
1530 if (!DriverArgs.hasArg(options::OPT_fptrauth_auth_traps,
1531 options::OPT_fno_ptrauth_auth_traps))
1532 CC1Args.push_back(
"-fptrauth-auth-traps");
1534 if (!DriverArgs.hasArg(
1535 options::OPT_fptrauth_vtable_pointer_address_discrimination,
1536 options::OPT_fno_ptrauth_vtable_pointer_address_discrimination))
1537 CC1Args.push_back(
"-fptrauth-vtable-pointer-address-discrimination");
1539 if (!DriverArgs.hasArg(
1540 options::OPT_fptrauth_vtable_pointer_type_discrimination,
1541 options::OPT_fno_ptrauth_vtable_pointer_type_discrimination))
1542 CC1Args.push_back(
"-fptrauth-vtable-pointer-type-discrimination");
1544 if (!DriverArgs.hasArg(options::OPT_fptrauth_indirect_gotos,
1545 options::OPT_fno_ptrauth_indirect_gotos))
1546 CC1Args.push_back(
"-fptrauth-indirect-gotos");
1548 if (!DriverArgs.hasArg(options::OPT_fptrauth_init_fini,
1549 options::OPT_fno_ptrauth_init_fini))
1550 CC1Args.push_back(
"-fptrauth-init-fini");
1554 ArgStringList &CmdArgs,
bool isAArch64) {
1555 const Arg *A = isAArch64
1556 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1557 options::OPT_mbranch_protection_EQ)
1558 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1564 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1565 D.Diag(diag::warn_incompatible_branch_protection_option)
1566 << Triple.getArchName();
1568 StringRef
Scope, Key;
1569 bool IndirectBranches, BranchProtectionPAuthLR, GuardedControlStack;
1571 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1572 Scope = A->getValue();
1574 D.Diag(diag::err_drv_unsupported_option_argument)
1575 << A->getSpelling() <<
Scope;
1577 IndirectBranches =
false;
1578 BranchProtectionPAuthLR =
false;
1579 GuardedControlStack =
false;
1582 llvm::ARM::ParsedBranchProtection PBP;
1583 bool EnablePAuthLR =
false;
1590 auto isPAuthLR = [](
const char *member) {
1591 llvm::AArch64::ExtensionInfo pauthlr_extension =
1592 llvm::AArch64::getExtensionByID(llvm::AArch64::AEK_PAUTHLR);
1593 return pauthlr_extension.PosTargetFeature == member;
1596 if (std::any_of(CmdArgs.begin(), CmdArgs.end(), isPAuthLR))
1597 EnablePAuthLR =
true;
1599 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg,
1601 D.Diag(diag::err_drv_unsupported_option_argument)
1602 << A->getSpelling() << DiagMsg;
1603 if (!isAArch64 && PBP.Key ==
"b_key")
1604 D.Diag(diag::warn_unsupported_branch_protection)
1605 <<
"b-key" << A->getAsString(Args);
1608 BranchProtectionPAuthLR = PBP.BranchProtectionPAuthLR;
1609 IndirectBranches = PBP.BranchTargetEnforcement;
1610 GuardedControlStack = PBP.GuardedControlStack;
1614 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1615 if (
Scope !=
"none") {
1616 if (Triple.getEnvironment() == llvm::Triple::PAuthTest)
1617 D.Diag(diag::err_drv_unsupported_opt_for_target)
1618 << A->getAsString(Args) << Triple.getTriple();
1620 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1622 if (BranchProtectionPAuthLR) {
1623 if (Triple.getEnvironment() == llvm::Triple::PAuthTest)
1624 D.Diag(diag::err_drv_unsupported_opt_for_target)
1625 << A->getAsString(Args) << Triple.getTriple();
1627 Args.MakeArgString(Twine(
"-mbranch-protection-pauth-lr")));
1629 if (IndirectBranches)
1630 CmdArgs.push_back(
"-mbranch-target-enforce");
1633 if (GuardedControlStack) {
1634 if (Triple.getEnvironment() == llvm::Triple::PAuthTest)
1635 D.Diag(diag::err_drv_unsupported_opt_for_target)
1636 << A->getAsString(Args) << Triple.getTriple();
1637 CmdArgs.push_back(
"-mguarded-control-stack");
1641void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1642 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1643 RenderARMABI(
getToolChain().getDriver(), Triple, Args, CmdArgs);
1650 CmdArgs.push_back(
"-msoft-float");
1651 CmdArgs.push_back(
"-mfloat-abi");
1652 CmdArgs.push_back(
"soft");
1655 CmdArgs.push_back(
"-mfloat-abi");
1656 CmdArgs.push_back(
"soft");
1660 CmdArgs.push_back(
"-mfloat-abi");
1661 CmdArgs.push_back(
"hard");
1665 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1666 options::OPT_mno_global_merge)) {
1667 CmdArgs.push_back(
"-mllvm");
1668 if (A->getOption().matches(options::OPT_mno_global_merge))
1669 CmdArgs.push_back(
"-arm-global-merge=false");
1671 CmdArgs.push_back(
"-arm-global-merge=true");
1674 if (!Args.hasFlag(options::OPT_mimplicit_float,
1675 options::OPT_mno_implicit_float,
true))
1676 CmdArgs.push_back(
"-no-implicit-float");
1678 if (Args.getLastArg(options::OPT_mcmse))
1679 CmdArgs.push_back(
"-mcmse");
1686 AddUnalignedAccessWarning(CmdArgs);
1689void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1690 const ArgList &Args,
bool KernelOrKext,
1691 ArgStringList &CmdArgs)
const {
1702 case llvm::Triple::arm:
1703 case llvm::Triple::armeb:
1704 case llvm::Triple::thumb:
1705 case llvm::Triple::thumbeb:
1707 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1710 case llvm::Triple::aarch64:
1711 case llvm::Triple::aarch64_32:
1712 case llvm::Triple::aarch64_be:
1713 AddAArch64TargetArgs(Args, CmdArgs);
1716 case llvm::Triple::loongarch32:
1717 case llvm::Triple::loongarch64:
1718 AddLoongArchTargetArgs(Args, CmdArgs);
1721 case llvm::Triple::mips:
1722 case llvm::Triple::mipsel:
1723 case llvm::Triple::mips64:
1724 case llvm::Triple::mips64el:
1725 AddMIPSTargetArgs(Args, CmdArgs);
1728 case llvm::Triple::ppc:
1729 case llvm::Triple::ppcle:
1730 case llvm::Triple::ppc64:
1731 case llvm::Triple::ppc64le:
1732 AddPPCTargetArgs(Args, CmdArgs);
1735 case llvm::Triple::riscv32:
1736 case llvm::Triple::riscv64:
1737 AddRISCVTargetArgs(Args, CmdArgs);
1740 case llvm::Triple::sparc:
1741 case llvm::Triple::sparcel:
1742 case llvm::Triple::sparcv9:
1743 AddSparcTargetArgs(Args, CmdArgs);
1746 case llvm::Triple::systemz:
1747 AddSystemZTargetArgs(Args, CmdArgs);
1750 case llvm::Triple::x86:
1751 case llvm::Triple::x86_64:
1752 AddX86TargetArgs(Args, CmdArgs);
1755 case llvm::Triple::lanai:
1756 AddLanaiTargetArgs(Args, CmdArgs);
1759 case llvm::Triple::hexagon:
1760 AddHexagonTargetArgs(Args, CmdArgs);
1763 case llvm::Triple::wasm32:
1764 case llvm::Triple::wasm64:
1765 AddWebAssemblyTargetArgs(Args, CmdArgs);
1768 case llvm::Triple::ve:
1769 AddVETargetArgs(Args, CmdArgs);
1775void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1776 ArgStringList &CmdArgs) {
1777 const char *ABIName =
nullptr;
1778 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1779 ABIName = A->getValue();
1780 else if (Triple.isOSDarwin())
1781 ABIName =
"darwinpcs";
1782 else if (Triple.getEnvironment() == llvm::Triple::PAuthTest)
1783 ABIName =
"pauthtest";
1787 CmdArgs.push_back(
"-target-abi");
1788 CmdArgs.push_back(ABIName);
1792void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1793 ArgStringList &CmdArgs)
const {
1796 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1797 Args.hasArg(options::OPT_mkernel) ||
1798 Args.hasArg(options::OPT_fapple_kext))
1799 CmdArgs.push_back(
"-disable-red-zone");
1801 if (!Args.hasFlag(options::OPT_mimplicit_float,
1802 options::OPT_mno_implicit_float,
true))
1803 CmdArgs.push_back(
"-no-implicit-float");
1805 RenderAArch64ABI(Triple, Args, CmdArgs);
1808 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1809 options::OPT_mno_global_merge)) {
1810 CmdArgs.push_back(
"-mllvm");
1811 if (A->getOption().matches(options::OPT_mno_global_merge))
1812 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1814 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1820 if (Triple.getEnvironment() == llvm::Triple::PAuthTest)
1824 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1825 StringRef Val = A->getValue();
1827 if (Val ==
"128" || Val ==
"256" || Val ==
"512" || Val ==
"1024" ||
1828 Val ==
"2048" || Val ==
"128+" || Val ==
"256+" || Val ==
"512+" ||
1829 Val ==
"1024+" || Val ==
"2048+") {
1831 if (!Val.consume_back(
"+")) {
1833 assert(!
Invalid &&
"Failed to parse value");
1835 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1839 assert(!
Invalid &&
"Failed to parse value");
1841 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1843 }
else if (Val !=
"scalable")
1845 D.Diag(diag::err_drv_unsupported_option_argument)
1846 << A->getSpelling() << Val;
1851 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1852 CmdArgs.push_back(
"-tune-cpu");
1853 if (strcmp(A->getValue(),
"native") == 0)
1854 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1856 CmdArgs.push_back(A->getValue());
1859 AddUnalignedAccessWarning(CmdArgs);
1861 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
1862 options::OPT_fno_ptrauth_intrinsics);
1863 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_calls,
1864 options::OPT_fno_ptrauth_calls);
1865 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_returns,
1866 options::OPT_fno_ptrauth_returns);
1867 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_auth_traps,
1868 options::OPT_fno_ptrauth_auth_traps);
1870 CmdArgs, options::OPT_fptrauth_vtable_pointer_address_discrimination,
1871 options::OPT_fno_ptrauth_vtable_pointer_address_discrimination);
1873 CmdArgs, options::OPT_fptrauth_vtable_pointer_type_discrimination,
1874 options::OPT_fno_ptrauth_vtable_pointer_type_discrimination);
1876 CmdArgs, options::OPT_fptrauth_type_info_vtable_pointer_discrimination,
1877 options::OPT_fno_ptrauth_type_info_vtable_pointer_discrimination);
1879 CmdArgs, options::OPT_fptrauth_function_pointer_type_discrimination,
1880 options::OPT_fno_ptrauth_function_pointer_type_discrimination);
1882 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_indirect_gotos,
1883 options::OPT_fno_ptrauth_indirect_gotos);
1884 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_init_fini,
1885 options::OPT_fno_ptrauth_init_fini);
1886 Args.addOptInFlag(CmdArgs,
1887 options::OPT_fptrauth_init_fini_address_discrimination,
1888 options::OPT_fno_ptrauth_init_fini_address_discrimination);
1889 Args.addOptInFlag(CmdArgs, options::OPT_faarch64_jump_table_hardening,
1890 options::OPT_fno_aarch64_jump_table_hardening);
1893void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1894 ArgStringList &CmdArgs)
const {
1897 CmdArgs.push_back(
"-target-abi");
1903 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1904 std::string TuneCPU = A->getValue();
1906 CmdArgs.push_back(
"-tune-cpu");
1907 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1910 if (Arg *A = Args.getLastArg(options::OPT_mannotate_tablejump,
1911 options::OPT_mno_annotate_tablejump)) {
1912 if (A->getOption().matches(options::OPT_mannotate_tablejump)) {
1913 CmdArgs.push_back(
"-mllvm");
1914 CmdArgs.push_back(
"-loongarch-annotate-tablejump");
1919void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1920 ArgStringList &CmdArgs)
const {
1927 CmdArgs.push_back(
"-target-abi");
1928 CmdArgs.push_back(ABIName.data());
1933 CmdArgs.push_back(
"-msoft-float");
1934 CmdArgs.push_back(
"-mfloat-abi");
1935 CmdArgs.push_back(
"soft");
1939 CmdArgs.push_back(
"-mfloat-abi");
1940 CmdArgs.push_back(
"hard");
1943 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1944 options::OPT_mno_ldc1_sdc1)) {
1945 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1946 CmdArgs.push_back(
"-mllvm");
1947 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1951 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1952 options::OPT_mno_check_zero_division)) {
1953 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1954 CmdArgs.push_back(
"-mllvm");
1955 CmdArgs.push_back(
"-mno-check-zero-division");
1959 if (Args.getLastArg(options::OPT_mfix4300)) {
1960 CmdArgs.push_back(
"-mllvm");
1961 CmdArgs.push_back(
"-mfix4300");
1964 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1965 StringRef
v = A->getValue();
1966 CmdArgs.push_back(
"-mllvm");
1967 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1971 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1973 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1986 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1988 llvm::Reloc::Model RelocationModel;
1991 std::tie(RelocationModel, PICLevel, IsPIE) =
1994 NoABICalls = NoABICalls ||
1995 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1997 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1999 if (NoABICalls && (!GPOpt || WantGPOpt)) {
2000 CmdArgs.push_back(
"-mllvm");
2001 CmdArgs.push_back(
"-mgpopt");
2003 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
2004 options::OPT_mno_local_sdata);
2005 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
2006 options::OPT_mno_extern_sdata);
2007 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
2008 options::OPT_mno_embedded_data);
2010 CmdArgs.push_back(
"-mllvm");
2011 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
2012 CmdArgs.push_back(
"-mlocal-sdata=1");
2014 CmdArgs.push_back(
"-mlocal-sdata=0");
2016 LocalSData->claim();
2020 CmdArgs.push_back(
"-mllvm");
2021 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
2022 CmdArgs.push_back(
"-mextern-sdata=1");
2024 CmdArgs.push_back(
"-mextern-sdata=0");
2026 ExternSData->claim();
2030 CmdArgs.push_back(
"-mllvm");
2031 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
2032 CmdArgs.push_back(
"-membedded-data=1");
2034 CmdArgs.push_back(
"-membedded-data=0");
2036 EmbeddedData->claim();
2039 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
2040 D.Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
2045 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
2046 StringRef Val = StringRef(A->getValue());
2048 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
2049 CmdArgs.push_back(
"-mllvm");
2050 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
2052 D.Diag(diag::err_drv_unsupported_option_argument)
2053 << A->getSpelling() << Val;
2055 D.Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
2058 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
2059 options::OPT_mno_relax_pic_calls)) {
2060 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
2061 CmdArgs.push_back(
"-mllvm");
2062 CmdArgs.push_back(
"-mips-jalr-reloc=0");
2067void Clang::AddPPCTargetArgs(
const ArgList &Args,
2068 ArgStringList &CmdArgs)
const {
2071 if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2072 CmdArgs.push_back(
"-tune-cpu");
2073 StringRef CPU = llvm::PPC::getNormalizedPPCTuneCPU(
T, A->getValue());
2074 CmdArgs.push_back(Args.MakeArgString(CPU.str()));
2078 const char *ABIName =
nullptr;
2079 if (
T.isOSBinFormatELF()) {
2081 case llvm::Triple::ppc64: {
2082 if (
T.isPPC64ELFv2ABI())
2088 case llvm::Triple::ppc64le:
2097 bool VecExtabi =
false;
2098 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2099 StringRef
V = A->getValue();
2100 if (
V ==
"ieeelongdouble") {
2101 IEEELongDouble =
true;
2103 }
else if (
V ==
"ibmlongdouble") {
2104 IEEELongDouble =
false;
2106 }
else if (
V ==
"vec-default") {
2109 }
else if (
V ==
"vec-extabi") {
2112 }
else if (
V ==
"elfv1") {
2115 }
else if (
V ==
"elfv2") {
2118 }
else if (
V !=
"altivec")
2122 ABIName = A->getValue();
2125 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2128 D.Diag(diag::err_drv_unsupported_opt_for_target)
2129 <<
"-mabi=vec-extabi" <<
T.str();
2130 CmdArgs.push_back(
"-mabi=vec-extabi");
2133 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true))
2134 CmdArgs.push_back(
"-disable-red-zone");
2139 CmdArgs.push_back(
"-msoft-float");
2140 CmdArgs.push_back(
"-mfloat-abi");
2141 CmdArgs.push_back(
"soft");
2145 CmdArgs.push_back(
"-mfloat-abi");
2146 CmdArgs.push_back(
"hard");
2150 CmdArgs.push_back(
"-target-abi");
2151 CmdArgs.push_back(ABIName);
2155void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2156 ArgStringList &CmdArgs)
const {
2160 CmdArgs.push_back(
"-target-abi");
2161 CmdArgs.push_back(ABIName.data());
2163 if (Arg *A = Args.getLastArg(options::OPT_G)) {
2164 CmdArgs.push_back(
"-msmall-data-limit");
2165 CmdArgs.push_back(A->getValue());
2168 if (!Args.hasFlag(options::OPT_mimplicit_float,
2169 options::OPT_mno_implicit_float,
true))
2170 CmdArgs.push_back(
"-no-implicit-float");
2172 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2173 CmdArgs.push_back(
"-tune-cpu");
2174 if (strcmp(A->getValue(),
"native") == 0)
2175 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2177 CmdArgs.push_back(A->getValue());
2181 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2182 StringRef Val = A->getValue();
2186 unsigned MinVLen = 0;
2188 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
2191 if (!errorToBool(ISAInfo.takeError()))
2192 MinVLen = (*ISAInfo)->getMinVLen();
2197 if (Val ==
"zvl" && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
2199 }
else if (!Val.getAsInteger(10, Bits)) {
2202 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
2203 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
2209 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
2211 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
2213 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
2214 }
else if (Val !=
"scalable") {
2216 D.Diag(diag::err_drv_unsupported_option_argument)
2217 << A->getSpelling() << Val;
2222void Clang::AddSparcTargetArgs(
const ArgList &Args,
2223 ArgStringList &CmdArgs)
const {
2229 CmdArgs.push_back(
"-msoft-float");
2230 CmdArgs.push_back(
"-mfloat-abi");
2231 CmdArgs.push_back(
"soft");
2235 CmdArgs.push_back(
"-mfloat-abi");
2236 CmdArgs.push_back(
"hard");
2239 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2240 StringRef Name = A->getValue();
2241 std::string TuneCPU;
2242 if (Name ==
"native")
2243 TuneCPU = std::string(llvm::sys::getHostCPUName());
2245 TuneCPU = std::string(Name);
2247 CmdArgs.push_back(
"-tune-cpu");
2248 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2252void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2253 ArgStringList &CmdArgs)
const {
2254 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2255 CmdArgs.push_back(
"-tune-cpu");
2256 if (strcmp(A->getValue(),
"native") == 0)
2257 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2259 CmdArgs.push_back(A->getValue());
2263 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2264 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2265 options::OPT_mno_packed_stack,
false);
2269 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2271 D.Diag(diag::err_drv_unsupported_opt)
2272 <<
"-mpacked-stack -mbackchain -mhard-float";
2275 CmdArgs.push_back(
"-mbackchain");
2277 CmdArgs.push_back(
"-mpacked-stack");
2280 CmdArgs.push_back(
"-msoft-float");
2281 CmdArgs.push_back(
"-mfloat-abi");
2282 CmdArgs.push_back(
"soft");
2286void Clang::AddX86TargetArgs(
const ArgList &Args,
2287 ArgStringList &CmdArgs)
const {
2291 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2292 Args.hasArg(options::OPT_mkernel) ||
2293 Args.hasArg(options::OPT_fapple_kext))
2294 CmdArgs.push_back(
"-disable-red-zone");
2296 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2297 options::OPT_mno_tls_direct_seg_refs,
true))
2298 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2302 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2303 Args.hasArg(options::OPT_fapple_kext));
2304 if (Arg *A = Args.getLastArg(
2305 options::OPT_msoft_float, options::OPT_mno_soft_float,
2306 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2307 const Option &O = A->getOption();
2308 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2309 O.matches(options::OPT_msoft_float));
2311 if (NoImplicitFloat)
2312 CmdArgs.push_back(
"-no-implicit-float");
2314 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2315 StringRef
Value = A->getValue();
2317 CmdArgs.push_back(
"-mllvm");
2318 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2319 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2321 D.Diag(diag::err_drv_unsupported_option_argument)
2322 << A->getSpelling() <<
Value;
2324 }
else if (
D.IsCLMode()) {
2325 CmdArgs.push_back(
"-mllvm");
2326 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2329 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2330 options::OPT_mno_skip_rax_setup))
2331 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2332 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2335 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2336 CmdArgs.push_back(
"-mfloat-abi");
2337 CmdArgs.push_back(
"soft");
2338 CmdArgs.push_back(
"-mstack-alignment=4");
2344 std::string TuneCPU;
2345 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2347 TuneCPU =
"generic";
2350 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2351 StringRef Name = A->getValue();
2353 if (Name ==
"native") {
2354 Name = llvm::sys::getHostCPUName();
2356 TuneCPU = std::string(Name);
2358 TuneCPU = std::string(Name);
2361 if (!TuneCPU.empty()) {
2362 CmdArgs.push_back(
"-tune-cpu");
2363 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2367void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2368 ArgStringList &CmdArgs)
const {
2369 CmdArgs.push_back(
"-mqdsp6-compat");
2370 CmdArgs.push_back(
"-Wreturn-type");
2373 CmdArgs.push_back(
"-mllvm");
2375 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2378 if (!Args.hasArg(options::OPT_fno_short_enums))
2379 CmdArgs.push_back(
"-fshort-enums");
2380 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2381 CmdArgs.push_back(
"-mllvm");
2382 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2384 CmdArgs.push_back(
"-mllvm");
2385 CmdArgs.push_back(
"-machine-sink-split=0");
2388void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2389 ArgStringList &CmdArgs)
const {
2390 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2391 StringRef CPUName = A->getValue();
2393 CmdArgs.push_back(
"-target-cpu");
2394 CmdArgs.push_back(Args.MakeArgString(CPUName));
2396 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2397 StringRef
Value = A->getValue();
2401 if (
Value.getAsInteger(10, Mregparm)) {
2402 if (Mregparm != 4) {
2404 diag::err_drv_unsupported_option_argument)
2405 << A->getSpelling() <<
Value;
2411void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2412 ArgStringList &CmdArgs)
const {
2414 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2415 options::OPT_fvisibility_ms_compat))
2416 CmdArgs.push_back(
"-fvisibility=hidden");
2419void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2421 CmdArgs.push_back(
"-mfloat-abi");
2422 CmdArgs.push_back(
"hard");
2427 const InputInfo &Input,
const ArgList &Args)
const {
2429 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2432 using llvm::yaml::escape;
2435 if (!CompilationDatabase) {
2437 auto File = std::make_unique<llvm::raw_fd_ostream>(
2439 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2441 D.Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2445 CompilationDatabase = std::move(
File);
2447 auto &CDB = *CompilationDatabase;
2448 auto CWD =
D.getVFS().getCurrentWorkingDirectory();
2451 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2452 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2454 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2455 CDB <<
", \"arguments\": [\"" << escape(
D.ClangExecutable) <<
"\"";
2459 CDB <<
", \"" << escape(Buf) <<
"\"";
2460 if (!
D.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2463 CDB <<
", \"" << escape(Buf) <<
"\"";
2465 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2467 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2468 for (
auto &A: Args) {
2469 auto &O = A->getOption();
2471 if (O.getID() == options::OPT_x)
2474 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2476 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2479 if (O.getKind() == Option::InputClass)
2482 if (O.getID() == options::OPT_o)
2486 A->render(Args, ASL);
2488 CDB <<
", \"" << escape(it) <<
"\"";
2492 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2495void Clang::DumpCompilationDatabaseFragmentToDir(
2497 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2499 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2502 if (CompilationDatabase)
2503 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2506 const auto &
Driver =
C.getDriver();
2508 auto Err = llvm::sys::fs::create_directory(
Path,
true);
2510 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2514 llvm::sys::path::append(
2516 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2519 Err = llvm::sys::fs::createUniqueFile(
Path, FD, TempPath,
2520 llvm::sys::fs::OF_Text);
2522 Driver.
Diag(diag::err_drv_compilationdatabase) <<
Path << Err.message();
2525 CompilationDatabase =
2526 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2527 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2537 CmdArgs.push_back(
"-mllvm");
2538 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2542 const ArgList &Args,
2543 ArgStringList &CmdArgs,
2553 Args.addOptInFlag(CmdArgs, options::OPT_mrelax_all,
2554 options::OPT_mno_relax_all);
2558 bool DefaultIncrementalLinkerCompatible =
2559 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2560 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2561 options::OPT_mno_incremental_linker_compatible,
2562 DefaultIncrementalLinkerCompatible))
2563 CmdArgs.push_back(
"-mincremental-linker-compatible");
2565 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2567 Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2568 options::OPT_fno_emit_compact_unwind_non_canonical);
2578 bool TakeNextArg =
false;
2580 const llvm::Triple &Triple =
C.getDefaultToolChain().getTriple();
2581 bool IsELF = Triple.isOSBinFormatELF();
2582 bool Crel =
false, ExperimentalCrel =
false;
2583 bool ImplicitMapSyms =
false;
2584 bool UseRelaxRelocations =
C.getDefaultToolChain().useRelaxRelocations();
2585 bool UseNoExecStack =
false;
2587 const char *MipsTargetFeature =
nullptr;
2588 StringRef ImplicitIt;
2590 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2591 options::OPT_mimplicit_it_EQ)) {
2594 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2595 switch (
C.getDefaultToolChain().getArch()) {
2596 case llvm::Triple::arm:
2597 case llvm::Triple::armeb:
2598 case llvm::Triple::thumb:
2599 case llvm::Triple::thumbeb:
2601 ImplicitIt = A->getValue();
2603 D.Diag(diag::err_drv_unsupported_option_argument)
2604 << A->getSpelling() << ImplicitIt;
2611 for (StringRef
Value : A->getValues()) {
2613 CmdArgs.push_back(
Value.data());
2614 TakeNextArg =
false;
2618 if (
C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2619 Value ==
"-mbig-obj")
2623 auto checkArg = [&](
bool ValidTarget,
2624 std::initializer_list<const char *>
Set) {
2626 D.Diag(diag::err_drv_unsupported_opt_for_target)
2627 << (Twine(
"-Wa,") +
Equal.first +
"=").str()
2628 << Triple.getTriple();
2629 }
else if (!llvm::is_contained(
Set,
Equal.second)) {
2630 D.Diag(diag::err_drv_unsupported_option_argument)
2631 << (Twine(
"-Wa,") +
Equal.first +
"=").str() <<
Equal.second;
2634 switch (
C.getDefaultToolChain().getArch()) {
2637 case llvm::Triple::x86:
2638 case llvm::Triple::x86_64:
2639 if (
Equal.first ==
"-mrelax-relocations" ||
2640 Equal.first ==
"--mrelax-relocations") {
2641 UseRelaxRelocations =
Equal.second ==
"yes";
2642 checkArg(IsELF, {
"yes",
"no"});
2645 if (
Value ==
"-msse2avx") {
2646 CmdArgs.push_back(
"-msse2avx");
2650 case llvm::Triple::wasm32:
2651 case llvm::Triple::wasm64:
2652 if (
Value ==
"--no-type-check") {
2653 CmdArgs.push_back(
"-mno-type-check");
2657 case llvm::Triple::thumb:
2658 case llvm::Triple::thumbeb:
2659 case llvm::Triple::arm:
2660 case llvm::Triple::armeb:
2661 if (
Equal.first ==
"-mimplicit-it") {
2663 ImplicitIt =
Equal.second;
2664 checkArg(
true, {
"always",
"never",
"arm",
"thumb"});
2667 if (
Value ==
"-mthumb")
2672 case llvm::Triple::aarch64:
2673 case llvm::Triple::aarch64_be:
2674 case llvm::Triple::aarch64_32:
2675 if (
Equal.first ==
"-mmapsyms") {
2676 ImplicitMapSyms =
Equal.second ==
"implicit";
2677 checkArg(IsELF, {
"default",
"implicit"});
2681 case llvm::Triple::mips:
2682 case llvm::Triple::mipsel:
2683 case llvm::Triple::mips64:
2684 case llvm::Triple::mips64el:
2685 if (
Value ==
"--trap") {
2686 CmdArgs.push_back(
"-target-feature");
2687 CmdArgs.push_back(
"+use-tcc-in-div");
2690 if (
Value ==
"--break") {
2691 CmdArgs.push_back(
"-target-feature");
2692 CmdArgs.push_back(
"-use-tcc-in-div");
2695 if (
Value.starts_with(
"-msoft-float")) {
2696 CmdArgs.push_back(
"-target-feature");
2697 CmdArgs.push_back(
"+soft-float");
2700 if (
Value.starts_with(
"-mhard-float")) {
2701 CmdArgs.push_back(
"-target-feature");
2702 CmdArgs.push_back(
"-soft-float");
2705 if (
Value ==
"-mmsa") {
2709 if (
Value ==
"-mno-msa") {
2713 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2714 .Case(
"-mips1",
"+mips1")
2715 .Case(
"-mips2",
"+mips2")
2716 .Case(
"-mips3",
"+mips3")
2717 .Case(
"-mips4",
"+mips4")
2718 .Case(
"-mips5",
"+mips5")
2719 .Case(
"-mips32",
"+mips32")
2720 .Case(
"-mips32r2",
"+mips32r2")
2721 .Case(
"-mips32r3",
"+mips32r3")
2722 .Case(
"-mips32r5",
"+mips32r5")
2723 .Case(
"-mips32r6",
"+mips32r6")
2724 .Case(
"-mips64",
"+mips64")
2725 .Case(
"-mips64r2",
"+mips64r2")
2726 .Case(
"-mips64r3",
"+mips64r3")
2727 .Case(
"-mips64r5",
"+mips64r5")
2728 .Case(
"-mips64r6",
"+mips64r6")
2730 if (MipsTargetFeature)
2735 if (
Value ==
"-force_cpusubtype_ALL") {
2737 }
else if (
Value ==
"-L") {
2738 CmdArgs.push_back(
"-msave-temp-labels");
2739 }
else if (
Value ==
"--fatal-warnings") {
2740 CmdArgs.push_back(
"-massembler-fatal-warnings");
2741 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2742 CmdArgs.push_back(
"-massembler-no-warn");
2743 }
else if (
Value ==
"--noexecstack") {
2744 UseNoExecStack =
true;
2745 }
else if (
Value.starts_with(
"-compress-debug-sections") ||
2746 Value.starts_with(
"--compress-debug-sections") ||
2747 Value ==
"-nocompress-debug-sections" ||
2748 Value ==
"--nocompress-debug-sections") {
2749 CmdArgs.push_back(
Value.data());
2750 }
else if (
Value ==
"--crel") {
2752 }
else if (
Value ==
"--no-crel") {
2754 }
else if (
Value ==
"--allow-experimental-crel") {
2755 ExperimentalCrel =
true;
2756 }
else if (
Value.starts_with(
"-I")) {
2757 CmdArgs.push_back(
Value.data());
2762 }
else if (
Value.starts_with(
"-gdwarf-")) {
2765 if (DwarfVersion == 0) {
2766 CmdArgs.push_back(
Value.data());
2769 llvm::codegenoptions::DebugInfoConstructor,
2770 DwarfVersion, llvm::DebuggerKind::Default);
2772 }
else if (
Value.starts_with(
"-mcpu") ||
Value.starts_with(
"-mfpu") ||
2773 Value.starts_with(
"-mhwdiv") ||
Value.starts_with(
"-march")) {
2775 }
else if (
Value ==
"-defsym" ||
Value ==
"--defsym") {
2776 if (A->getNumValues() != 2) {
2777 D.Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2780 const char *S = A->getValue(1);
2781 auto Pair = StringRef(S).split(
'=');
2782 auto Sym = Pair.first;
2783 auto SVal = Pair.second;
2785 if (Sym.empty() || SVal.empty()) {
2786 D.Diag(diag::err_drv_defsym_invalid_format) << S;
2790 if (SVal.getAsInteger(0, IVal)) {
2791 D.Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2794 CmdArgs.push_back(
"--defsym");
2796 }
else if (
Value ==
"-fdebug-compilation-dir") {
2797 CmdArgs.push_back(
"-fdebug-compilation-dir");
2799 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2803 CmdArgs.push_back(
"-fdebug-compilation-dir");
2804 CmdArgs.push_back(
Value.data());
2805 }
else if (
Value ==
"--version") {
2806 D.PrintVersion(
C, llvm::outs());
2808 D.Diag(diag::err_drv_unsupported_option_argument)
2809 << A->getSpelling() <<
Value;
2813 if (ImplicitIt.size())
2816 if (!ExperimentalCrel)
2817 D.Diag(diag::err_drv_experimental_crel);
2818 if (Triple.isOSBinFormatELF() && !Triple.isMIPS()) {
2819 CmdArgs.push_back(
"--crel");
2821 D.Diag(diag::err_drv_unsupported_opt_for_target)
2822 <<
"-Wa,--crel" <<
D.getTargetTriple();
2825 if (ImplicitMapSyms)
2826 CmdArgs.push_back(
"-mmapsyms=implicit");
2828 CmdArgs.push_back(
"-mmsa");
2829 if (!UseRelaxRelocations)
2830 CmdArgs.push_back(
"-mrelax-relocations=no");
2832 CmdArgs.push_back(
"-mnoexecstack");
2833 if (MipsTargetFeature !=
nullptr) {
2834 CmdArgs.push_back(
"-target-feature");
2835 CmdArgs.push_back(MipsTargetFeature);
2839 if (
C.getDriver().embedBitcodeEnabled() ||
2840 C.getDriver().embedBitcodeMarkerOnly())
2841 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2843 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2844 CmdArgs.push_back(
"-as-secure-log-file");
2845 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2876 if (str1 != str2 && !str2.empty() && !str1.empty()) {
2877 D.Diag(clang::diag::warn_drv_overriding_option) << str1 << str2;
2884 if (!ComplexRangeStr.empty())
2885 return "-complex-range=" + ComplexRangeStr;
2886 return ComplexRangeStr;
2890 bool OFastEnabled,
const ArgList &Args,
2891 ArgStringList &CmdArgs,
2894 constexpr std::array VecLibImpliesNoMathErrno{llvm::StringLiteral(
"ArmPL"),
2895 llvm::StringLiteral(
"SLEEF")};
2896 bool NoMathErrnoWasImpliedByVecLib =
false;
2897 const Arg *VecLibArg =
nullptr;
2899 const Arg *ArgThatEnabledMathErrnoAfterVecLib =
nullptr;
2906 bool HonorINFs =
true;
2907 bool HonorNaNs =
true;
2908 bool ApproxFunc =
false;
2911 bool AssociativeMath =
false;
2912 bool ReciprocalMath =
false;
2913 bool SignedZeros =
true;
2914 bool TrappingMath =
false;
2915 bool TrappingMathPresent =
false;
2917 bool RoundingFPMath =
false;
2919 StringRef FPModel =
"";
2921 StringRef FPExceptionBehavior =
"";
2923 StringRef FPEvalMethod =
"";
2924 llvm::DenormalMode DenormalFPMath =
2926 llvm::DenormalMode DenormalFP32Math =
2931 StringRef FPContract;
2932 StringRef LastSeenFfpContractOption;
2933 StringRef LastFpContractOverrideOption;
2934 bool SeenUnsafeMathModeOption =
false;
2938 bool StrictFPModel =
false;
2939 StringRef Float16ExcessPrecision =
"";
2940 StringRef BFloat16ExcessPrecision =
"";
2942 std::string ComplexRangeStr =
"";
2943 std::string GccRangeComplexOption =
"";
2948 if (
Range != NewRange)
2950 !GccRangeComplexOption.empty()
2951 ? GccRangeComplexOption
2958 auto applyFastMath = [&](
bool Aggressive) {
2969 AssociativeMath =
true;
2970 ReciprocalMath =
true;
2972 SignedZeros =
false;
2973 TrappingMath =
false;
2974 RoundingFPMath =
false;
2975 FPExceptionBehavior =
"";
2976 FPContract =
"fast";
2977 SeenUnsafeMathModeOption =
true;
2981 auto restoreFPContractState = [&]() {
2991 if (LastSeenFfpContractOption !=
"")
2992 FPContract = LastSeenFfpContractOption;
2993 else if (SeenUnsafeMathModeOption)
2998 LastFpContractOverrideOption =
"";
3001 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3002 CmdArgs.push_back(
"-mlimit-float-precision");
3003 CmdArgs.push_back(A->getValue());
3006 for (
const Arg *A : Args) {
3007 auto CheckMathErrnoForVecLib =
3008 llvm::make_scope_exit([&, MathErrnoBeforeArg = MathErrno] {
3009 if (NoMathErrnoWasImpliedByVecLib && !MathErrnoBeforeArg && MathErrno)
3010 ArgThatEnabledMathErrnoAfterVecLib = A;
3013 switch (A->getOption().getID()) {
3017 case options::OPT_fcx_limited_range:
3018 if (GccRangeComplexOption.empty()) {
3021 "-fcx-limited-range");
3023 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
3026 GccRangeComplexOption =
"-fcx-limited-range";
3029 case options::OPT_fno_cx_limited_range:
3030 if (GccRangeComplexOption.empty()) {
3032 "-fno-cx-limited-range");
3034 if (GccRangeComplexOption !=
"-fcx-limited-range" &&
3035 GccRangeComplexOption !=
"-fno-cx-fortran-rules")
3037 "-fno-cx-limited-range");
3039 GccRangeComplexOption =
"-fno-cx-limited-range";
3042 case options::OPT_fcx_fortran_rules:
3043 if (GccRangeComplexOption.empty())
3045 "-fcx-fortran-rules");
3048 GccRangeComplexOption =
"-fcx-fortran-rules";
3051 case options::OPT_fno_cx_fortran_rules:
3052 if (GccRangeComplexOption.empty()) {
3054 "-fno-cx-fortran-rules");
3056 if (GccRangeComplexOption !=
"-fno-cx-limited-range")
3058 "-fno-cx-fortran-rules");
3060 GccRangeComplexOption =
"-fno-cx-fortran-rules";
3063 case options::OPT_fcomplex_arithmetic_EQ: {
3065 StringRef Val = A->getValue();
3068 else if (Val ==
"improved")
3070 else if (Val ==
"promoted")
3072 else if (Val ==
"basic")
3075 D.Diag(diag::err_drv_unsupported_option_argument)
3076 << A->getSpelling() << Val;
3079 if (!GccRangeComplexOption.empty()) {
3080 if (GccRangeComplexOption !=
"-fcx-limited-range") {
3081 if (GccRangeComplexOption !=
"-fcx-fortran-rules") {
3098 case options::OPT_ffp_model_EQ: {
3105 AssociativeMath =
false;
3106 ReciprocalMath =
false;
3109 StringRef Val = A->getValue();
3110 if (OFastEnabled && Val !=
"aggressive") {
3112 D.Diag(clang::diag::warn_drv_overriding_option)
3113 << Args.MakeArgString(
"-ffp-model=" + Val) <<
"-Ofast";
3116 StrictFPModel =
false;
3117 if (!FPModel.empty() && FPModel != Val)
3118 D.Diag(clang::diag::warn_drv_overriding_option)
3119 << Args.MakeArgString(
"-ffp-model=" + FPModel)
3120 << Args.MakeArgString(
"-ffp-model=" + Val);
3121 if (Val ==
"fast") {
3123 applyFastMath(
false);
3125 LastFpContractOverrideOption =
"-ffp-model=fast";
3126 }
else if (Val ==
"aggressive") {
3128 applyFastMath(
true);
3130 LastFpContractOverrideOption =
"-ffp-model=aggressive";
3131 }
else if (Val ==
"precise") {
3134 LastFpContractOverrideOption =
"-ffp-model=precise";
3136 }
else if (Val ==
"strict") {
3137 StrictFPModel =
true;
3138 FPExceptionBehavior =
"strict";
3141 LastFpContractOverrideOption =
"-ffp-model=strict";
3142 TrappingMath =
true;
3143 RoundingFPMath =
true;
3146 D.Diag(diag::err_drv_unsupported_option_argument)
3147 << A->getSpelling() << Val;
3152 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
3153 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
3154 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
3155 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
3156 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
3157 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
3158 case options::OPT_fmath_errno: MathErrno =
true;
break;
3159 case options::OPT_fno_math_errno: MathErrno =
false;
break;
3160 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
3161 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
3162 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
3163 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
3164 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
3165 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
3166 case options::OPT_ftrapping_math:
3167 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
3168 FPExceptionBehavior !=
"strict")
3170 D.Diag(clang::diag::warn_drv_overriding_option)
3171 << Args.MakeArgString(
"-ffp-exception-behavior=" +
3172 FPExceptionBehavior)
3173 <<
"-ftrapping-math";
3174 TrappingMath =
true;
3175 TrappingMathPresent =
true;
3176 FPExceptionBehavior =
"strict";
3178 case options::OPT_fveclib:
3180 NoMathErrnoWasImpliedByVecLib =
3181 llvm::is_contained(VecLibImpliesNoMathErrno, A->getValue());
3182 if (NoMathErrnoWasImpliedByVecLib)
3185 case options::OPT_fno_trapping_math:
3186 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
3187 FPExceptionBehavior !=
"ignore")
3189 D.Diag(clang::diag::warn_drv_overriding_option)
3190 << Args.MakeArgString(
"-ffp-exception-behavior=" +
3191 FPExceptionBehavior)
3192 <<
"-fno-trapping-math";
3193 TrappingMath =
false;
3194 TrappingMathPresent =
true;
3195 FPExceptionBehavior =
"ignore";
3198 case options::OPT_frounding_math:
3199 RoundingFPMath =
true;
3202 case options::OPT_fno_rounding_math:
3203 RoundingFPMath =
false;
3206 case options::OPT_fdenormal_fp_math_EQ:
3207 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
3208 DenormalFP32Math = DenormalFPMath;
3209 if (!DenormalFPMath.isValid()) {
3210 D.Diag(diag::err_drv_invalid_value)
3211 << A->getAsString(Args) << A->getValue();
3215 case options::OPT_fdenormal_fp_math_f32_EQ:
3216 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
3217 if (!DenormalFP32Math.isValid()) {
3218 D.Diag(diag::err_drv_invalid_value)
3219 << A->getAsString(Args) << A->getValue();
3224 case options::OPT_ffp_contract: {
3225 StringRef Val = A->getValue();
3226 if (Val ==
"fast" || Val ==
"on" || Val ==
"off" ||
3227 Val ==
"fast-honor-pragmas") {
3228 if (Val != FPContract && LastFpContractOverrideOption !=
"") {
3229 D.Diag(clang::diag::warn_drv_overriding_option)
3230 << LastFpContractOverrideOption
3231 << Args.MakeArgString(
"-ffp-contract=" + Val);
3235 LastSeenFfpContractOption = Val;
3236 LastFpContractOverrideOption =
"";
3238 D.Diag(diag::err_drv_unsupported_option_argument)
3239 << A->getSpelling() << Val;
3244 case options::OPT_ffp_exception_behavior_EQ: {
3245 StringRef Val = A->getValue();
3246 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
3247 FPExceptionBehavior != Val)
3249 D.Diag(clang::diag::warn_drv_overriding_option)
3250 << Args.MakeArgString(
"-ffp-exception-behavior=" +
3251 FPExceptionBehavior)
3252 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
3253 TrappingMath = TrappingMathPresent =
false;
3254 if (Val ==
"ignore" || Val ==
"maytrap")
3255 FPExceptionBehavior = Val;
3256 else if (Val ==
"strict") {
3257 FPExceptionBehavior = Val;
3258 TrappingMath = TrappingMathPresent =
true;
3260 D.Diag(diag::err_drv_unsupported_option_argument)
3261 << A->getSpelling() << Val;
3266 case options::OPT_ffp_eval_method_EQ: {
3267 StringRef Val = A->getValue();
3268 if (Val ==
"double" || Val ==
"extended" || Val ==
"source")
3271 D.Diag(diag::err_drv_unsupported_option_argument)
3272 << A->getSpelling() << Val;
3276 case options::OPT_fexcess_precision_EQ: {
3277 StringRef Val = A->getValue();
3278 const llvm::Triple::ArchType Arch = TC.
getArch();
3279 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
3280 if (Val ==
"standard" || Val ==
"fast")
3281 Float16ExcessPrecision = Val;
3285 else if (Val ==
"16")
3286 Float16ExcessPrecision =
"none";
3288 D.Diag(diag::err_drv_unsupported_option_argument)
3289 << A->getSpelling() << Val;
3291 if (!(Val ==
"standard" || Val ==
"fast"))
3292 D.Diag(diag::err_drv_unsupported_option_argument)
3293 << A->getSpelling() << Val;
3295 BFloat16ExcessPrecision = Float16ExcessPrecision;
3298 case options::OPT_ffinite_math_only:
3302 case options::OPT_fno_finite_math_only:
3307 case options::OPT_funsafe_math_optimizations:
3308 AssociativeMath =
true;
3309 ReciprocalMath =
true;
3310 SignedZeros =
false;
3312 TrappingMath =
false;
3313 FPExceptionBehavior =
"";
3314 FPContract =
"fast";
3315 LastFpContractOverrideOption =
"-funsafe-math-optimizations";
3316 SeenUnsafeMathModeOption =
true;
3318 case options::OPT_fno_unsafe_math_optimizations:
3319 AssociativeMath =
false;
3320 ReciprocalMath =
false;
3323 restoreFPContractState();
3326 case options::OPT_Ofast:
3331 case options::OPT_ffast_math:
3332 applyFastMath(
true);
3333 if (A->getOption().getID() == options::OPT_Ofast)
3334 LastFpContractOverrideOption =
"-Ofast";
3336 LastFpContractOverrideOption =
"-ffast-math";
3338 case options::OPT_fno_fast_math:
3345 AssociativeMath =
false;
3346 ReciprocalMath =
false;
3349 restoreFPContractState();
3350 LastFpContractOverrideOption =
"";
3360 if (StrictFPModel) {
3363 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3364 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3365 FPContract ==
"off")
3369 StrictFPModel =
false;
3374 auto RHS = (A->getNumValues() == 0)
3376 : Args.MakeArgString(A->getSpelling() + A->getValue());
3377 if (A->getSpelling() !=
"-ffp-contract=") {
3378 if (RHS !=
"-ffp-model=strict")
3379 D.Diag(clang::diag::warn_drv_overriding_option)
3380 <<
"-ffp-model=strict" << RHS;
3390 CmdArgs.push_back(
"-menable-no-infs");
3393 CmdArgs.push_back(
"-menable-no-nans");
3396 CmdArgs.push_back(
"-fapprox-func");
3399 CmdArgs.push_back(
"-fmath-errno");
3400 if (NoMathErrnoWasImpliedByVecLib)
3401 D.Diag(clang::diag::warn_drv_math_errno_enabled_after_veclib)
3402 << ArgThatEnabledMathErrnoAfterVecLib->getAsString(Args)
3403 << VecLibArg->getAsString(Args);
3406 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3408 CmdArgs.push_back(
"-funsafe-math-optimizations");
3411 CmdArgs.push_back(
"-fno-signed-zeros");
3413 if (AssociativeMath && !SignedZeros && !TrappingMath)
3414 CmdArgs.push_back(
"-mreassociate");
3417 CmdArgs.push_back(
"-freciprocal-math");
3421 assert(FPExceptionBehavior ==
"strict");
3425 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3427 llvm::raw_svector_ostream ArgStr(DenormFlag);
3428 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3429 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3433 if (DenormalFP32Math != DenormalFPMath) {
3435 llvm::raw_svector_ostream ArgStr(DenormFlag);
3436 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3437 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3440 if (!FPContract.empty())
3441 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3444 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3446 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3448 if (!FPExceptionBehavior.empty())
3449 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3450 FPExceptionBehavior));
3452 if (!FPEvalMethod.empty())
3453 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3455 if (!Float16ExcessPrecision.empty())
3456 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3457 Float16ExcessPrecision));
3458 if (!BFloat16ExcessPrecision.empty())
3459 CmdArgs.push_back(Args.MakeArgString(
"-fbfloat16-excess-precision=" +
3460 BFloat16ExcessPrecision));
3467 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3468 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath)
3469 CmdArgs.push_back(
"-ffast-math");
3475 bool shouldAddFiniteMathOnly =
false;
3476 if (!HonorINFs && !HonorNaNs) {
3477 shouldAddFiniteMathOnly =
true;
3479 bool InfValues =
true;
3480 bool NanValues =
true;
3481 for (
const auto *Arg : Args.filtered(options::OPT_Xclang)) {
3482 StringRef ArgValue = Arg->getValue();
3483 if (ArgValue ==
"-menable-no-nans")
3485 else if (ArgValue ==
"-menable-no-infs")
3488 if (!NanValues && !InfValues)
3489 shouldAddFiniteMathOnly =
true;
3491 if (shouldAddFiniteMathOnly) {
3492 CmdArgs.push_back(
"-ffinite-math-only");
3494 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3495 CmdArgs.push_back(
"-mfpmath");
3496 CmdArgs.push_back(A->getValue());
3500 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3501 options::OPT_fstrict_float_cast_overflow,
false))
3502 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3506 if (!ComplexRangeStr.empty()) {
3507 CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
3508 if (Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))
3509 CmdArgs.push_back(Args.MakeArgString(
"-fcomplex-arithmetic=" +
3512 if (Args.hasArg(options::OPT_fcx_limited_range))
3513 CmdArgs.push_back(
"-fcx-limited-range");
3514 if (Args.hasArg(options::OPT_fcx_fortran_rules))
3515 CmdArgs.push_back(
"-fcx-fortran-rules");
3516 if (Args.hasArg(options::OPT_fno_cx_limited_range))
3517 CmdArgs.push_back(
"-fno-cx-limited-range");
3518 if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
3519 CmdArgs.push_back(
"-fno-cx-fortran-rules");
3523 const llvm::Triple &Triple,
3526 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3527 CmdArgs.push_back(
"-analyzer-checker=core");
3528 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3530 if (!Triple.isWindowsMSVCEnvironment()) {
3531 CmdArgs.push_back(
"-analyzer-checker=unix");
3534 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3535 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3536 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3537 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3538 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3539 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3543 if (Triple.isPS()) {
3544 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3545 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3548 if (Triple.isOSDarwin()) {
3549 CmdArgs.push_back(
"-analyzer-checker=osx");
3551 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3553 else if (Triple.isOSFuchsia())
3554 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3556 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3559 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3561 if (!Triple.isPS()) {
3562 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3563 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3564 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3565 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3566 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3567 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3571 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3572 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3576 CmdArgs.push_back(
"-analyzer-output");
3577 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3578 CmdArgs.push_back(A->getValue());
3580 CmdArgs.push_back(
"plist");
3585 CmdArgs.push_back(
"-w");
3588 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3595 if (std::isdigit(S[0]))
3598 return llvm::all_of(S, [](
char C) {
return std::isalnum(
C) ||
C ==
'_'; });
3602 const ArgList &Args, ArgStringList &CmdArgs,
3603 bool KernelOrKext) {
3608 if (EffectiveTriple.isNVPTX())
3616 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3617 options::OPT_fstack_protector_all,
3618 options::OPT_fstack_protector_strong,
3619 options::OPT_fstack_protector)) {
3620 if (A->getOption().matches(options::OPT_fstack_protector))
3621 StackProtectorLevel =
3623 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3625 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3629 D.Diag(diag::warn_drv_unsupported_option_for_target)
3630 << A->getSpelling() << EffectiveTriple.getTriple();
3631 StackProtectorLevel = DefaultStackProtectorLevel;
3634 StackProtectorLevel = DefaultStackProtectorLevel;
3637 if (StackProtectorLevel) {
3638 CmdArgs.push_back(
"-stack-protector");
3639 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3643 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3644 StringRef Str(A->getValue());
3645 if (Str.starts_with(
"ssp-buffer-size=")) {
3646 if (StackProtectorLevel) {
3647 CmdArgs.push_back(
"-stack-protector-buffer-size");
3649 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3655 const std::string &TripleStr = EffectiveTriple.getTriple();
3656 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3657 StringRef
Value = A->getValue();
3658 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3659 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb() &&
3660 !EffectiveTriple.isRISCV() && !EffectiveTriple.isPPC())
3661 D.Diag(diag::err_drv_unsupported_opt_for_target)
3662 << A->getAsString(Args) << TripleStr;
3663 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3664 EffectiveTriple.isThumb()) &&
3666 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3667 << A->getOption().getName() <<
Value <<
"tls global";
3670 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3672 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3673 D.Diag(diag::err_drv_ssp_missing_offset_argument)
3674 << A->getAsString(Args);
3679 D.Diag(diag::err_target_unsupported_tp_hard)
3680 << EffectiveTriple.getArchName();
3684 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3685 StringRef
Value = A->getValue();
3686 if (
Value !=
"cp15") {
3687 D.Diag(diag::err_drv_argument_not_allowed_with)
3688 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3692 CmdArgs.push_back(
"-target-feature");
3693 CmdArgs.push_back(
"+read-tp-tpidruro");
3695 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3696 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3697 << A->getOption().getName() <<
Value <<
"sysreg global";
3700 if (EffectiveTriple.isRISCV() || EffectiveTriple.isPPC()) {
3702 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3703 << A->getOption().getName() <<
Value <<
"tls global";
3706 if (
Value ==
"tls") {
3707 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3708 D.Diag(diag::err_drv_ssp_missing_offset_argument)
3709 << A->getAsString(Args);
3714 A->render(Args, CmdArgs);
3717 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3718 StringRef
Value = A->getValue();
3719 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3720 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb() &&
3721 !EffectiveTriple.isRISCV() && !EffectiveTriple.isPPC())
3722 D.Diag(diag::err_drv_unsupported_opt_for_target)
3723 << A->getAsString(Args) << TripleStr;
3725 if (
Value.getAsInteger(10, Offset)) {
3726 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3729 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3730 (Offset < 0 || Offset > 0xfffff)) {
3731 D.Diag(diag::err_drv_invalid_int_value)
3732 << A->getOption().getName() <<
Value;
3735 A->render(Args, CmdArgs);
3738 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3739 StringRef
Value = A->getValue();
3740 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3741 !EffectiveTriple.isRISCV() && !EffectiveTriple.isPPC())
3742 D.Diag(diag::err_drv_unsupported_opt_for_target)
3743 << A->getAsString(Args) << TripleStr;
3744 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3745 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3746 << A->getOption().getName() <<
Value <<
"fs gs";
3749 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3750 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3753 if (EffectiveTriple.isRISCV() &&
Value !=
"tp") {
3754 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3755 << A->getOption().getName() <<
Value <<
"tp";
3758 if (EffectiveTriple.isPPC64() &&
Value !=
"r13") {
3759 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3760 << A->getOption().getName() <<
Value <<
"r13";
3763 if (EffectiveTriple.isPPC32() &&
Value !=
"r2") {
3764 D.Diag(diag::err_drv_invalid_value_with_suggestion)
3765 << A->getOption().getName() <<
Value <<
"r2";
3768 A->render(Args, CmdArgs);
3771 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3772 StringRef
Value = A->getValue();
3774 D.Diag(diag::err_drv_argument_only_allowed_with)
3775 << A->getOption().getName() <<
"legal symbol name";
3778 A->render(Args, CmdArgs);
3783 ArgStringList &CmdArgs) {
3786 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux() &&
3787 !EffectiveTriple.isOSFuchsia())
3790 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3791 !EffectiveTriple.isPPC64() && !EffectiveTriple.isAArch64() &&
3792 !EffectiveTriple.isRISCV())
3795 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3796 options::OPT_fno_stack_clash_protection);
3801 const ArgList &Args,
3802 ArgStringList &CmdArgs) {
3804 StringRef TrivialAutoVarInit =
"";
3806 for (
const Arg *A : Args) {
3807 switch (A->getOption().getID()) {
3810 case options::OPT_ftrivial_auto_var_init: {
3812 StringRef Val = A->getValue();
3813 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3814 TrivialAutoVarInit = Val;
3816 D.Diag(diag::err_drv_unsupported_option_argument)
3817 << A->getSpelling() << Val;
3823 if (TrivialAutoVarInit.empty())
3824 switch (DefaultTrivialAutoVarInit) {
3828 TrivialAutoVarInit =
"pattern";
3831 TrivialAutoVarInit =
"zero";
3835 if (!TrivialAutoVarInit.empty()) {
3837 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3841 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3842 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3844 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3846 D.Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3848 StringRef Val = A->getValue();
3849 if (std::stoi(Val.str()) <= 0)
3850 D.Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3852 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3855 if (Arg *A = Args.getLastArg(options::OPT_ftrivial_auto_var_init_max_size)) {
3856 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3858 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3860 D.Diag(diag::err_drv_trivial_auto_var_init_max_size_missing_dependency);
3862 StringRef Val = A->getValue();
3863 if (std::stoi(Val.str()) <= 0)
3864 D.Diag(diag::err_drv_trivial_auto_var_init_max_size_invalid_value);
3866 Args.MakeArgString(
"-ftrivial-auto-var-init-max-size=" + Val));
3874 const unsigned ForwardedArguments[] = {
3875 options::OPT_cl_opt_disable,
3876 options::OPT_cl_strict_aliasing,
3877 options::OPT_cl_single_precision_constant,
3878 options::OPT_cl_finite_math_only,
3879 options::OPT_cl_kernel_arg_info,
3880 options::OPT_cl_unsafe_math_optimizations,
3881 options::OPT_cl_fast_relaxed_math,
3882 options::OPT_cl_mad_enable,
3883 options::OPT_cl_no_signed_zeros,
3884 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3885 options::OPT_cl_uniform_work_group_size
3888 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3889 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3890 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3891 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3892 std::string CLExtStr = std::string(
"-cl-ext=") + A->getValue();
3893 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3896 if (Args.hasArg(options::OPT_cl_finite_math_only)) {
3897 CmdArgs.push_back(
"-menable-no-infs");
3898 CmdArgs.push_back(
"-menable-no-nans");
3901 for (
const auto &Arg : ForwardedArguments)
3902 if (
const auto *A = Args.getLastArg(Arg))
3903 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3908 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3909 CmdArgs.push_back(
"-finclude-default-header");
3910 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3916 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3920 options::OPT_emit_llvm,
3921 options::OPT_emit_obj,
3922 options::OPT_disable_llvm_passes,
3923 options::OPT_fnative_half_type,
3924 options::OPT_hlsl_entrypoint};
3927 for (
const auto &Arg : ForwardedArguments)
3928 if (
const auto *A = Args.getLastArg(Arg))
3929 A->renderAsInput(Args, CmdArgs);
3931 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3932 !Args.hasArg(options::OPT_nostdinc))
3933 CmdArgs.push_back(
"-finclude-default-header");
3937 ArgStringList &CmdArgs,
types::ID InputType) {
3938 if (!Args.hasArg(options::OPT_fopenacc))
3941 CmdArgs.push_back(
"-fopenacc");
3943 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override)) {
3944 StringRef
Value = A->getValue();
3946 if (!
Value.getAsInteger(10, Version))
3947 A->renderAsInput(Args, CmdArgs);
3949 D.Diag(diag::err_drv_clang_unsupported) <<
Value;
3954 ArgStringList &CmdArgs) {
3955 bool ARCMTEnabled =
false;
3956 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3957 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3958 options::OPT_ccc_arcmt_modify,
3959 options::OPT_ccc_arcmt_migrate)) {
3960 ARCMTEnabled =
true;
3961 switch (A->getOption().getID()) {
3962 default: llvm_unreachable(
"missed a case");
3963 case options::OPT_ccc_arcmt_check:
3964 CmdArgs.push_back(
"-arcmt-action=check");
3966 case options::OPT_ccc_arcmt_modify:
3967 CmdArgs.push_back(
"-arcmt-action=modify");
3969 case options::OPT_ccc_arcmt_migrate:
3970 CmdArgs.push_back(
"-arcmt-action=migrate");
3971 CmdArgs.push_back(
"-mt-migrate-directory");
3972 CmdArgs.push_back(A->getValue());
3974 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3975 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3980 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3981 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3982 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3985 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3987 D.Diag(diag::err_drv_argument_not_allowed_with)
3988 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3990 CmdArgs.push_back(
"-mt-migrate-directory");
3991 CmdArgs.push_back(A->getValue());
3993 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3994 options::OPT_objcmt_migrate_subscripting,
3995 options::OPT_objcmt_migrate_property)) {
3997 CmdArgs.push_back(
"-objcmt-migrate-literals");
3998 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3999 CmdArgs.push_back(
"-objcmt-migrate-property");
4001 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4002 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4003 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4006 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4007 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4008 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4009 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
4010 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
4011 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
4012 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
4013 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
4014 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
4015 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
4016 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
4017 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
4018 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
4019 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
4020 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
4021 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
4026 const ArgList &Args, ArgStringList &CmdArgs) {
4029 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
4030 !Args.hasArg(options::OPT_mkernel));
4032 CmdArgs.push_back(
"-fno-builtin");
4035 if (Args.hasArg(options::OPT_ffreestanding))
4036 UseBuiltins =
false;
4039 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
4045 A->render(Args, CmdArgs);
4050 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
4053 return Path.getSingleStringRef() !=
"";
4055 if (llvm::sys::path::cache_directory(
Result)) {
4056 llvm::sys::path::append(
Result,
"clang");
4057 llvm::sys::path::append(
Result,
"ModuleCache");
4065 const char *BaseInput) {
4066 if (Arg *ModuleOutputEQ = Args.getLastArg(options::OPT_fmodule_output_EQ))
4067 return StringRef(ModuleOutputEQ->getValue());
4070 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o);
4071 FinalOutput && Args.hasArg(options::OPT_c))
4072 OutputPath = FinalOutput->getValue();
4074 OutputPath = BaseInput;
4077 llvm::sys::path::replace_extension(OutputPath, Extension);
4082 const ArgList &Args,
const InputInfo &Input,
4083 const InputInfo &Output,
bool HaveStd20,
4084 ArgStringList &CmdArgs) {
4086 bool HaveStdCXXModules = IsCXX && HaveStd20;
4087 bool HaveModules = HaveStdCXXModules;
4092 bool HaveClangModules =
false;
4093 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
4094 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4095 options::OPT_fno_cxx_modules,
true);
4096 if (AllowedInCXX || !IsCXX) {
4097 CmdArgs.push_back(
"-fmodules");
4098 HaveClangModules =
true;
4102 HaveModules |= HaveClangModules;
4106 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4107 options::OPT_fno_implicit_module_maps, HaveClangModules))
4108 CmdArgs.push_back(
"-fimplicit-module-maps");
4111 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
4112 options::OPT_fno_modules_decluse);
4116 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4117 options::OPT_fno_modules_strict_decluse,
false))
4118 CmdArgs.push_back(
"-fmodules-strict-decluse");
4120 Args.addOptOutFlag(CmdArgs, options::OPT_fmodulemap_allow_subdirectory_search,
4121 options::OPT_fno_modulemap_allow_subdirectory_search);
4124 bool ImplicitModules =
false;
4125 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4126 options::OPT_fno_implicit_modules, HaveClangModules)) {
4128 CmdArgs.push_back(
"-fno-implicit-modules");
4129 }
else if (HaveModules) {
4130 ImplicitModules =
true;
4134 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4135 Path = A->getValue();
4137 bool HasPath =
true;
4138 if (
C.isForDiagnostics()) {
4142 llvm::sys::path::replace_extension(
Path,
".cache");
4143 llvm::sys::path::append(
Path,
"modules");
4144 }
else if (
Path.empty()) {
4152 const char Arg[] =
"-fmodules-cache-path=";
4153 Path.insert(
Path.begin(), Arg, Arg + strlen(Arg));
4154 CmdArgs.push_back(Args.MakeArgString(
Path));
4159 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
4160 options::OPT_fno_prebuilt_implicit_modules,
false))
4161 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
4162 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
4163 options::OPT_fno_modules_validate_input_files_content,
4165 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
4170 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
4174 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
4178 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
4180 llvm::sys::path::append(BuiltinModuleMap,
"include");
4181 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
4182 if (llvm::sys::fs::exists(BuiltinModuleMap))
4184 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
4191 if (HaveModules || Input.
getType() == clang::driver::types::TY_ModuleFile) {
4192 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4195 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
4196 CmdArgs.push_back(Args.MakeArgString(
4197 std::string(
"-fprebuilt-module-path=") + A->getValue()));
4201 Args.ClaimAllArgs(options::OPT_fmodule_file);
4205 if (HaveClangModules &&
C.isForDiagnostics()) {
4207 llvm::sys::path::replace_extension(VFSDir,
".cache");
4209 C.addTempFile(Args.MakeArgString(VFSDir));
4211 llvm::sys::path::append(VFSDir,
"vfs");
4212 CmdArgs.push_back(
"-module-dependency-dir");
4213 CmdArgs.push_back(Args.MakeArgString(VFSDir));
4216 if (HaveClangModules)
4217 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
4220 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
4221 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4222 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
4224 if (HaveClangModules) {
4225 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4227 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4228 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4229 D.Diag(diag::err_drv_argument_not_allowed_with)
4230 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
4232 llvm::sys::fs::file_status Status;
4233 if (llvm::sys::fs::status(A->getValue(), Status))
4234 D.Diag(diag::err_drv_no_such_file) << A->getValue();
4235 CmdArgs.push_back(Args.MakeArgString(
4236 "-fbuild-session-timestamp=" +
4237 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
4238 Status.getLastModificationTime().time_since_epoch())
4242 if (Args.getLastArg(
4243 options::OPT_fmodules_validate_once_per_build_session)) {
4244 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4245 options::OPT_fbuild_session_file))
4246 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4248 Args.AddLastArg(CmdArgs,
4249 options::OPT_fmodules_validate_once_per_build_session);
4252 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
4253 options::OPT_fno_modules_validate_system_headers,
4255 CmdArgs.push_back(
"-fmodules-validate-system-headers");
4257 Args.AddLastArg(CmdArgs,
4258 options::OPT_fmodules_disable_diagnostic_validation);
4260 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
4261 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
4262 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
4263 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
4264 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
4265 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
4270 CmdArgs.push_back(
"-fskip-odr-check-in-gmf");
4272 if (Args.hasArg(options::OPT_modules_reduced_bmi) &&
4273 (Input.
getType() == driver::types::TY_CXXModule ||
4274 Input.
getType() == driver::types::TY_PP_CXXModule)) {
4275 CmdArgs.push_back(
"-fmodules-reduced-bmi");
4277 if (Args.hasArg(options::OPT_fmodule_output_EQ))
4278 Args.AddLastArg(CmdArgs, options::OPT_fmodule_output_EQ);
4280 CmdArgs.push_back(Args.MakeArgString(
4281 "-fmodule-output=" +
4288 Args.ClaimAllArgs(options::OPT_modules_reduced_bmi);
4296 if (Input.
getType() == driver::types::TY_CXXModule ||
4297 Input.
getType() == driver::types::TY_PP_CXXModule ||
4298 Input.
getType() == driver::types::TY_ModuleFile) {
4299 Args.ClaimAllArgs(options::OPT_fmodule_output);
4300 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
4303 if (Args.hasArg(options::OPT_fmodules_embed_all_files))
4304 CmdArgs.push_back(
"-fmodules-embed-all-files");
4310 ArgStringList &CmdArgs) {
4312 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
4313 options::OPT_fno_signed_char,
4314 options::OPT_funsigned_char,
4315 options::OPT_fno_unsigned_char)) {
4316 if (A->getOption().matches(options::OPT_funsigned_char) ||
4317 A->getOption().matches(options::OPT_fno_signed_char)) {
4318 CmdArgs.push_back(
"-fno-signed-char");
4321 CmdArgs.push_back(
"-fno-signed-char");
4325 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
4327 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4328 options::OPT_fno_short_wchar)) {
4329 if (A->getOption().matches(options::OPT_fshort_wchar)) {
4330 CmdArgs.push_back(
"-fwchar-type=short");
4331 CmdArgs.push_back(
"-fno-signed-wchar");
4333 bool IsARM =
T.isARM() ||
T.isThumb() ||
T.isAArch64();
4334 CmdArgs.push_back(
"-fwchar-type=int");
4336 (IsARM && !(
T.isOSWindows() ||
T.isOSNetBSD() ||
T.isOSOpenBSD())))
4337 CmdArgs.push_back(
"-fno-signed-wchar");
4339 CmdArgs.push_back(
"-fsigned-wchar");
4341 }
else if (
T.isOSzOS())
4342 CmdArgs.push_back(
"-fno-signed-wchar");
4346 const llvm::Triple &
T,
const ArgList &Args,
4348 const InputInfo &Input, ArgStringList &CmdArgs) {
4349 const llvm::Triple::ArchType Arch = TC.
getArch();
4355 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4356 options::OPT_fno_objc_legacy_dispatch,
4359 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
4361 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
4367 if (Arch == llvm::Triple::x86 &&
T.isMacOSX() &&
4369 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
4376 CmdArgs.push_back(
"-fobjc-arc");
4383 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
4385 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
4390 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4391 options::OPT_fno_objc_arc_exceptions,
4393 CmdArgs.push_back(
"-fobjc-arc-exceptions");
4398 if (Args.hasArg(options::OPT_fno_objc_arc)) {
4399 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4400 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4406 auto *Arg = Args.getLastArg(
4407 options::OPT_fobjc_convert_messages_to_runtime_calls,
4408 options::OPT_fno_objc_convert_messages_to_runtime_calls);
4410 Arg->getOption().matches(
4411 options::OPT_fno_objc_convert_messages_to_runtime_calls))
4412 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
4417 if (InferCovariantReturns)
4418 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4423 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4427 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4428 D.Diag(diag::err_objc_weak_unsupported);
4430 WeakArg->render(Args, CmdArgs);
4434 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4435 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
4439 ArgStringList &CmdArgs) {
4440 bool CaretDefault =
true;
4441 bool ColumnDefault =
true;
4443 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4444 options::OPT__SLASH_diagnostics_column,
4445 options::OPT__SLASH_diagnostics_caret)) {
4446 switch (A->getOption().getID()) {
4447 case options::OPT__SLASH_diagnostics_caret:
4448 CaretDefault =
true;
4449 ColumnDefault =
true;
4451 case options::OPT__SLASH_diagnostics_column:
4452 CaretDefault =
false;
4453 ColumnDefault =
true;
4455 case options::OPT__SLASH_diagnostics_classic:
4456 CaretDefault =
false;
4457 ColumnDefault =
false;
4463 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4464 options::OPT_fno_caret_diagnostics, CaretDefault))
4465 CmdArgs.push_back(
"-fno-caret-diagnostics");
4467 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4468 options::OPT_fno_diagnostics_fixit_info);
4469 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4470 options::OPT_fno_diagnostics_show_option);
4473 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4474 CmdArgs.push_back(
"-fdiagnostics-show-category");
4475 CmdArgs.push_back(A->getValue());
4478 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4479 options::OPT_fno_diagnostics_show_hotness);
4482 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4484 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4485 CmdArgs.push_back(Args.MakeArgString(Opt));
4489 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4491 std::string(
"-fdiagnostics-misexpect-tolerance=") + A->getValue();
4492 CmdArgs.push_back(Args.MakeArgString(Opt));
4495 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4496 CmdArgs.push_back(
"-fdiagnostics-format");
4497 CmdArgs.push_back(A->getValue());
4498 if (StringRef(A->getValue()) ==
"sarif" ||
4499 StringRef(A->getValue()) ==
"SARIF")
4500 D.Diag(diag::warn_drv_sarif_format_unstable);
4503 if (
const Arg *A = Args.getLastArg(
4504 options::OPT_fdiagnostics_show_note_include_stack,
4505 options::OPT_fno_diagnostics_show_note_include_stack)) {
4506 const Option &O = A->getOption();
4507 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4508 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4510 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4515 if (Args.hasArg(options::OPT_fansi_escape_codes))
4516 CmdArgs.push_back(
"-fansi-escape-codes");
4518 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4519 options::OPT_fno_show_source_location);
4521 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4522 options::OPT_fno_diagnostics_show_line_numbers);
4524 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4525 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4527 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4529 CmdArgs.push_back(
"-fno-show-column");
4531 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4532 options::OPT_fno_spell_checking);
4534 Args.addLastArg(CmdArgs, options::OPT_warning_suppression_mappings_EQ);
4538 const ArgList &Args, Arg *&Arg) {
4539 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4540 options::OPT_gno_split_dwarf);
4541 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4544 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4547 StringRef
Value = Arg->getValue();
4548 if (
Value ==
"split")
4550 if (
Value ==
"single")
4553 D.Diag(diag::err_drv_unsupported_option_argument)
4554 << Arg->getSpelling() << Arg->getValue();
4559 const ArgList &Args, ArgStringList &CmdArgs,
4560 unsigned DwarfVersion) {
4561 auto *DwarfFormatArg =
4562 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4563 if (!DwarfFormatArg)
4566 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4567 if (DwarfVersion < 3)
4568 D.Diag(diag::err_drv_argument_only_allowed_with)
4569 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4570 else if (!
T.isArch64Bit())
4571 D.Diag(diag::err_drv_argument_only_allowed_with)
4572 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4573 else if (!
T.isOSBinFormatELF())
4574 D.Diag(diag::err_drv_argument_only_allowed_with)
4575 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4578 DwarfFormatArg->render(Args, CmdArgs);
4583 const ArgList &Args,
bool IRInput, ArgStringList &CmdArgs,
4585 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
4587 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4588 options::OPT_fno_debug_info_for_profiling,
false) &&
4590 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args,
D, TC))
4591 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4604 bool SplitDWARFInlining =
4605 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4606 options::OPT_fno_split_dwarf_inlining,
false);
4611 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4617 SplitDWARFInlining =
false;
4620 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4621 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4625 A->getOption().matches(options::OPT_gN_Group)) {
4631 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
4632 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
4633 (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
4634 SplitDWARFInlining))
4640 bool HasDebuggerTuning =
false;
4642 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4643 HasDebuggerTuning =
true;
4645 if (A->getOption().matches(options::OPT_glldb))
4646 DebuggerTuning = llvm::DebuggerKind::LLDB;
4647 else if (A->getOption().matches(options::OPT_gsce))
4648 DebuggerTuning = llvm::DebuggerKind::SCE;
4649 else if (A->getOption().matches(options::OPT_gdbx))
4650 DebuggerTuning = llvm::DebuggerKind::DBX;
4652 DebuggerTuning = llvm::DebuggerKind::GDB;
4657 bool EmitDwarf =
false;
4661 bool EmitCodeView =
false;
4662 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4667 if (!EmitCodeView && !EmitDwarf &&
4668 DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
4670 case llvm::codegenoptions::DIF_CodeView:
4671 EmitCodeView =
true;
4673 case llvm::codegenoptions::DIF_DWARF:
4679 unsigned RequestedDWARFVersion = 0;
4680 unsigned EffectiveDWARFVersion = 0;
4685 EffectiveDWARFVersion =
4688 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4692 if (RequestedDWARFVersion == 0 &&
4693 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
4694 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
4698 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4700 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4701 DebuggerTuning == llvm::DebuggerKind::DBX))
4702 CmdArgs.push_back(
"-gstrict-dwarf");
4705 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4713 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4715 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4717 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4718 DebuggerTuning != llvm::DebuggerKind::DBX)))
4719 CmdArgs.push_back(
"-gno-column-info");
4722 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4727 if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
4728 DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
4729 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4730 CmdArgs.push_back(
"-dwarf-ext-refs");
4731 CmdArgs.push_back(
"-fmodule-format=obj");
4736 if (
T.isOSBinFormatELF() && SplitDWARFInlining)
4737 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4744 bool NeedFullDebug = Args.hasFlag(
4745 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4746 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4748 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4751 if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
4752 DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
4753 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4754 options::OPT_feliminate_unused_debug_types,
false))
4755 DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
4756 else if (NeedFullDebug)
4757 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
4760 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4766 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4767 if (RequestedDWARFVersion < 5)
4768 D.Diag(diag::err_drv_argument_only_allowed_with)
4769 << A->getAsString(Args) <<
"-gdwarf-5";
4770 else if (EffectiveDWARFVersion < 5)
4773 D.Diag(diag::warn_drv_dwarf_version_limited_by_target)
4775 << EffectiveDWARFVersion;
4777 CmdArgs.push_back(
"-gembed-source");
4781 CmdArgs.push_back(
"-gcodeview");
4783 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4784 options::OPT_gno_codeview_ghash);
4786 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4787 options::OPT_gno_codeview_command_line);
4790 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4791 options::OPT_gno_inline_line_tables);
4795 DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
4796 DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
4804 T.isOSAIX() && !HasDebuggerTuning
4805 ? llvm::DebuggerKind::Default
4809 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4813 CmdArgs.push_back(
"-debug-info-macro");
4816 const auto *PubnamesArg =
4817 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4818 options::OPT_gpubnames, options::OPT_gno_pubnames);
4821 const bool OptionSet =
4823 (PubnamesArg->getOption().matches(options::OPT_gpubnames) ||
4824 PubnamesArg->getOption().matches(options::OPT_ggnu_pubnames)));
4825 if ((DebuggerTuning != llvm::DebuggerKind::LLDB || OptionSet) &&
4827 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4828 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames))))
4829 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4830 options::OPT_gpubnames)
4832 :
"-ggnu-pubnames");
4834 const auto *SimpleTemplateNamesArg =
4835 Args.getLastArg(options::OPT_gsimple_template_names,
4836 options::OPT_gno_simple_template_names);
4837 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4838 if (SimpleTemplateNamesArg &&
4840 const auto &Opt = SimpleTemplateNamesArg->getOption();
4841 if (Opt.matches(options::OPT_gsimple_template_names)) {
4842 ForwardTemplateParams =
true;
4843 CmdArgs.push_back(
"-gsimple-template-names=simple");
4848 bool UseDebugTemplateAlias =
4849 DebuggerTuning == llvm::DebuggerKind::SCE && RequestedDWARFVersion >= 4;
4850 if (
const auto *DebugTemplateAlias = Args.getLastArg(
4851 options::OPT_gtemplate_alias, options::OPT_gno_template_alias)) {
4855 const auto &Opt = DebugTemplateAlias->getOption();
4856 UseDebugTemplateAlias = Opt.matches(options::OPT_gtemplate_alias);
4859 if (UseDebugTemplateAlias)
4860 CmdArgs.push_back(
"-gtemplate-alias");
4862 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4863 StringRef
v = A->getValue();
4864 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4867 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4868 options::OPT_fno_debug_ranges_base_address);
4872 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges);
4874 CmdArgs.push_back(
"-mllvm");
4875 CmdArgs.push_back(
"-generate-arange-section");
4878 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4879 options::OPT_fno_force_dwarf_frame);
4881 bool EnableTypeUnits =
false;
4882 if (Args.hasFlag(options::OPT_fdebug_types_section,
4883 options::OPT_fno_debug_types_section,
false)) {
4884 if (!(
T.isOSBinFormatELF() ||
T.isOSBinFormatWasm())) {
4885 D.Diag(diag::err_drv_unsupported_opt_for_target)
4886 << Args.getLastArg(options::OPT_fdebug_types_section)
4890 Args.getLastArg(options::OPT_fdebug_types_section), Args,
D,
4892 EnableTypeUnits =
true;
4893 CmdArgs.push_back(
"-mllvm");
4894 CmdArgs.push_back(
"-generate-type-units");
4899 Args.getLastArg(options::OPT_gomit_unreferenced_methods,
4900 options::OPT_gno_omit_unreferenced_methods))
4902 if (Args.hasFlag(options::OPT_gomit_unreferenced_methods,
4903 options::OPT_gno_omit_unreferenced_methods,
false) &&
4904 (DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor ||
4905 DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo) &&
4907 CmdArgs.push_back(
"-gomit-unreferenced-methods");
4913 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4914 options::OPT_fno_dwarf_directory_asm,
4916 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4920 if (ForwardTemplateParams)
4921 CmdArgs.push_back(
"-debug-forward-template-params");
4925 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4926 CmdArgs.push_back(
"-dwarf-explicit-import");
4932 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
4933 if (TC.
getTriple().isOSBinFormatELF() ||
4934 TC.
getTriple().isWindowsMSVCEnvironment()) {
4935 if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
4936 CmdArgs.push_back(
"-fjmc");
4937 else if (
D.IsCLMode())
4938 D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"/JMC"
4941 D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
4944 D.Diag(clang::diag::warn_drv_fjmc_for_elf_only);
4949 const char *DebugCompilationDir =
4961 ArgStringList &CmdArgs) {
4962 unsigned RTOptionID = options::OPT__SLASH_MT;
4964 if (Args.hasArg(options::OPT__SLASH_LDd))
4967 RTOptionID = options::OPT__SLASH_MTd;
4969 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4970 RTOptionID = A->getOption().getID();
4972 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4973 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4974 .Case(
"static", options::OPT__SLASH_MT)
4975 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4976 .Case(
"dll", options::OPT__SLASH_MD)
4977 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4978 .Default(options::OPT__SLASH_MT);
4981 StringRef FlagForCRT;
4982 switch (RTOptionID) {
4983 case options::OPT__SLASH_MD:
4984 if (Args.hasArg(options::OPT__SLASH_LDd))
4985 CmdArgs.push_back(
"-D_DEBUG");
4986 CmdArgs.push_back(
"-D_MT");
4987 CmdArgs.push_back(
"-D_DLL");
4988 FlagForCRT =
"--dependent-lib=msvcrt";
4990 case options::OPT__SLASH_MDd:
4991 CmdArgs.push_back(
"-D_DEBUG");
4992 CmdArgs.push_back(
"-D_MT");
4993 CmdArgs.push_back(
"-D_DLL");
4994 FlagForCRT =
"--dependent-lib=msvcrtd";
4996 case options::OPT__SLASH_MT:
4997 if (Args.hasArg(options::OPT__SLASH_LDd))
4998 CmdArgs.push_back(
"-D_DEBUG");
4999 CmdArgs.push_back(
"-D_MT");
5000 CmdArgs.push_back(
"-flto-visibility-public-std");
5001 FlagForCRT =
"--dependent-lib=libcmt";
5003 case options::OPT__SLASH_MTd:
5004 CmdArgs.push_back(
"-D_DEBUG");
5005 CmdArgs.push_back(
"-D_MT");
5006 CmdArgs.push_back(
"-flto-visibility-public-std");
5007 FlagForCRT =
"--dependent-lib=libcmtd";
5010 llvm_unreachable(
"Unexpected option ID.");
5013 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
5014 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
5016 CmdArgs.push_back(FlagForCRT.data());
5021 CmdArgs.push_back(
"--dependent-lib=oldnames");
5028 CmdArgs.push_back(
"--dependent-lib=softintrin");
5033 const ArgList &Args,
const char *LinkingOutput)
const {
5035 const llvm::Triple &RawTriple = TC.
getTriple();
5037 const std::string &TripleStr = Triple.getTriple();
5040 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
5042 ArgStringList CmdArgs;
5044 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
5059 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
5062 bool IsHostOffloadingAction =
5066 Args.hasFlag(options::OPT_offload_new_driver,
5067 options::OPT_no_offload_new_driver,
5071 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
5073 auto LTOMode = IsDeviceOffloadAction ?
D.getOffloadLTOMode() :
D.getLTOMode();
5078 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
5082 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
5086 const InputInfo *CudaDeviceInput =
nullptr;
5087 const InputInfo *OpenMPDeviceInput =
nullptr;
5089 if (&I == &Input || I.
getType() == types::TY_Nothing) {
5091 }
else if (IsExtractAPI) {
5092 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
5093 if (I.getType() != ExpectedInputType) {
5094 D.Diag(diag::err_drv_extract_api_wrong_kind)
5098 ExtractAPIInputs.push_back(I);
5099 }
else if (IsHostOffloadingAction) {
5100 HostOffloadingInputs.push_back(I);
5101 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
5102 CudaDeviceInput = &I;
5103 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
5104 OpenMPDeviceInput = &I;
5106 llvm_unreachable(
"unexpectedly given multiple inputs");
5110 const llvm::Triple *AuxTriple =
5112 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
5113 bool IsUEFI = RawTriple.isUEFI();
5114 bool IsIAMCU = RawTriple.isOSIAMCU();
5119 if (IsCuda || IsHIP || IsSYCL)
5120 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
5124 D.Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
5129 CmdArgs.push_back(
"-cc1");
5132 CmdArgs.push_back(
"-triple");
5133 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5135 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
5136 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
5137 Args.ClaimAllArgs(options::OPT_MJ);
5138 }
else if (
const Arg *GenCDBFragment =
5139 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
5140 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
5141 TripleStr, Output, Input, Args);
5142 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
5145 if (IsCuda || IsHIP) {
5148 std::string NormalizedTriple;
5166 assert(CTC &&
"Expected valid CUDA Toolchain.");
5168 CmdArgs.push_back(Args.MakeArgString(
5169 Twine(
"-target-sdk-version=") +
5177 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
5180 CmdArgs.push_back(
"-aux-triple");
5181 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5186 getToolChain().getTriple().getVendor() == llvm::Triple::AMD))) {
5188 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
5189 CmdArgs.push_back(Args.MakeArgString(
5191 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
5194 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
5200 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
5206 llvm::Triple AuxT =
C.getDefaultToolChain().getTriple();
5207 std::string NormalizedTriple = AuxT.normalize();
5208 CmdArgs.push_back(
"-aux-triple");
5209 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5212 CmdArgs.push_back(
"-fsycl-is-device");
5215 if (!Args.getLastArg(options::OPT_O_Group))
5216 CmdArgs.push_back(
"-O2");
5223 CmdArgs.push_back(
"-fsycl-is-host");
5227 Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
5229 SYCLStdArg->render(Args, CmdArgs);
5232 CmdArgs.push_back(
"-sycl-std=2020");
5236 if (Args.hasArg(options::OPT_fclangir))
5237 CmdArgs.push_back(
"-fclangir");
5239 if (IsOpenMPDevice) {
5241 std::string NormalizedTriple =
5245 CmdArgs.push_back(
"-aux-triple");
5246 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5249 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
5250 Triple.getArch() == llvm::Triple::thumb)) {
5251 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5252 unsigned Version = 0;
5254 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
5255 if (Failure || Version < 7)
5256 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
5266 if (Triple.isSPIR() || Triple.isSPIRV())
5267 CmdArgs.push_back(
"-Wspir-compat");
5270 RewriteKind rewriteKind = RK_None;
5272 bool UnifiedLTO =
false;
5274 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5275 options::OPT_fno_unified_lto, Triple.isPS());
5277 CmdArgs.push_back(
"-funified-lto");
5287 if (!isa<AssembleJobAction>(JA)) {
5291 Args.ClaimAllArgs(options::OPT_mrelax_all);
5292 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5293 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5294 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5295 switch (
C.getDefaultToolChain().getArch()) {
5296 case llvm::Triple::arm:
5297 case llvm::Triple::armeb:
5298 case llvm::Triple::thumb:
5299 case llvm::Triple::thumbeb:
5300 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5306 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5307 Args.ClaimAllArgs(options::OPT_Xassembler);
5308 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5311 if (isa<AnalyzeJobAction>(JA)) {
5312 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5313 CmdArgs.push_back(
"-analyze");
5314 }
else if (isa<MigrateJobAction>(JA)) {
5315 CmdArgs.push_back(
"-migrate");
5316 }
else if (isa<PreprocessJobAction>(JA)) {
5317 if (Output.
getType() == types::TY_Dependencies)
5318 CmdArgs.push_back(
"-Eonly");
5320 CmdArgs.push_back(
"-E");
5321 if (Args.hasArg(options::OPT_rewrite_objc) &&
5322 !Args.hasArg(options::OPT_g_Group))
5323 CmdArgs.push_back(
"-P");
5324 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5325 CmdArgs.push_back(
"-fdirectives-only");
5327 }
else if (isa<AssembleJobAction>(JA)) {
5328 CmdArgs.push_back(
"-emit-obj");
5333 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5334 }
else if (isa<PrecompileJobAction>(JA)) {
5335 if (JA.
getType() == types::TY_Nothing)
5336 CmdArgs.push_back(
"-fsyntax-only");
5337 else if (JA.
getType() == types::TY_ModuleFile)
5338 CmdArgs.push_back(
"-emit-module-interface");
5339 else if (JA.
getType() == types::TY_HeaderUnit)
5340 CmdArgs.push_back(
"-emit-header-unit");
5342 CmdArgs.push_back(
"-emit-pch");
5343 }
else if (isa<VerifyPCHJobAction>(JA)) {
5344 CmdArgs.push_back(
"-verify-pch");
5345 }
else if (isa<ExtractAPIJobAction>(JA)) {
5346 assert(JA.
getType() == types::TY_API_INFO &&
5347 "Extract API actions must generate a API information.");
5348 CmdArgs.push_back(
"-extract-api");
5350 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5351 PrettySGFArg->render(Args, CmdArgs);
5353 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5355 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5356 ProductNameArg->render(Args, CmdArgs);
5357 if (Arg *ExtractAPIIgnoresFileArg =
5358 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5359 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5360 if (Arg *EmitExtensionSymbolGraphs =
5361 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5362 if (!SymbolGraphDirArg)
5363 D.Diag(diag::err_drv_missing_symbol_graph_dir);
5365 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5367 if (SymbolGraphDirArg)
5368 SymbolGraphDirArg->render(Args, CmdArgs);
5370 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
5371 "Invalid action for clang tool.");
5372 if (JA.
getType() == types::TY_Nothing) {
5373 CmdArgs.push_back(
"-fsyntax-only");
5374 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5375 JA.
getType() == types::TY_LTO_IR) {
5376 CmdArgs.push_back(
"-emit-llvm");
5377 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5378 JA.
getType() == types::TY_LTO_BC) {
5380 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5381 Args.hasArg(options::OPT_emit_llvm)) {
5382 CmdArgs.push_back(
"-emit-llvm");
5384 CmdArgs.push_back(
"-emit-llvm-bc");
5386 }
else if (JA.
getType() == types::TY_IFS ||
5387 JA.
getType() == types::TY_IFS_CPP) {
5389 Args.hasArg(options::OPT_interface_stub_version_EQ)
5390 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5392 CmdArgs.push_back(
"-emit-interface-stubs");
5394 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5395 }
else if (JA.
getType() == types::TY_PP_Asm) {
5396 CmdArgs.push_back(
"-S");
5397 }
else if (JA.
getType() == types::TY_AST) {
5398 CmdArgs.push_back(
"-emit-pch");
5399 }
else if (JA.
getType() == types::TY_ModuleFile) {
5400 CmdArgs.push_back(
"-module-file-info");
5401 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5402 CmdArgs.push_back(
"-rewrite-objc");
5403 rewriteKind = RK_NonFragile;
5404 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5405 CmdArgs.push_back(
"-rewrite-objc");
5406 rewriteKind = RK_Fragile;
5407 }
else if (JA.
getType() == types::TY_CIR) {
5408 CmdArgs.push_back(
"-emit-cir");
5410 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5417 if (JA.
getType() == types::TY_LLVM_BC)
5418 CmdArgs.push_back(
"-emit-llvm-uselists");
5422 !Args.hasFlag(options::OPT_offload_new_driver,
5423 options::OPT_no_offload_new_driver,
5425 !Triple.isAMDGPU()) {
5426 D.Diag(diag::err_drv_unsupported_opt_for_target)
5427 << Args.getLastArg(options::OPT_foffload_lto,
5428 options::OPT_foffload_lto_EQ)
5430 << Triple.getTriple();
5431 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5433 D.Diag(diag::err_drv_unsupported_opt_for_language_mode)
5434 << Args.getLastArg(options::OPT_foffload_lto,
5435 options::OPT_foffload_lto_EQ)
5440 CmdArgs.push_back(Args.MakeArgString(
5441 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5444 if (!RawTriple.isPS4() ||
5445 (
D.getLTOMode() ==
LTOK_Full) || !UnifiedLTO)
5446 CmdArgs.push_back(
"-flto-unit");
5451 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5453 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5455 D.Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5456 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5460 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5461 options::OPT_mno_regnames);
5463 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5464 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5466 if (Args.getLastArg(options::OPT_save_temps_EQ))
5467 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5469 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5470 options::OPT_fmemory_profile_EQ,
5471 options::OPT_fno_memory_profile);
5473 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5474 MemProfArg->render(Args, CmdArgs);
5476 if (
auto *MemProfUseArg =
5477 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5479 D.Diag(diag::err_drv_argument_not_allowed_with)
5480 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5481 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5482 options::OPT_fprofile_generate_EQ))
5483 D.Diag(diag::err_drv_argument_not_allowed_with)
5484 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5485 MemProfUseArg->render(Args, CmdArgs);
5490 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5491 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
5493 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5495 CmdArgs.push_back(
"-disable-llvm-passes");
5502 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5503 options::OPT_mkernel,
5504 options::OPT_fapple_kext,
5505 options::OPT_ffunction_sections,
5506 options::OPT_fno_function_sections,
5507 options::OPT_fdata_sections,
5508 options::OPT_fno_data_sections,
5509 options::OPT_fbasic_block_sections_EQ,
5510 options::OPT_funique_internal_linkage_names,
5511 options::OPT_fno_unique_internal_linkage_names,
5512 options::OPT_funique_section_names,
5513 options::OPT_fno_unique_section_names,
5514 options::OPT_funique_basic_block_section_names,
5515 options::OPT_fno_unique_basic_block_section_names,
5516 options::OPT_mrestrict_it,
5517 options::OPT_mno_restrict_it,
5518 options::OPT_mstackrealign,
5519 options::OPT_mno_stackrealign,
5520 options::OPT_mstack_alignment,
5521 options::OPT_mcmodel_EQ,
5522 options::OPT_mlong_calls,
5523 options::OPT_mno_long_calls,
5524 options::OPT_ggnu_pubnames,
5525 options::OPT_gdwarf_aranges,
5526 options::OPT_fdebug_types_section,
5527 options::OPT_fno_debug_types_section,
5528 options::OPT_fdwarf_directory_asm,
5529 options::OPT_fno_dwarf_directory_asm,
5530 options::OPT_mrelax_all,
5531 options::OPT_mno_relax_all,
5532 options::OPT_ftrap_function_EQ,
5533 options::OPT_ffixed_r9,
5534 options::OPT_mfix_cortex_a53_835769,
5535 options::OPT_mno_fix_cortex_a53_835769,
5536 options::OPT_ffixed_x18,
5537 options::OPT_mglobal_merge,
5538 options::OPT_mno_global_merge,
5539 options::OPT_mred_zone,
5540 options::OPT_mno_red_zone,
5541 options::OPT_Wa_COMMA,
5542 options::OPT_Xassembler,
5545 for (
const auto &A : Args)
5546 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5547 D.Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5550 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5551 options::OPT_fno_optimize_sibling_calls);
5559 case llvm::Triple::arm:
5560 case llvm::Triple::armeb:
5561 case llvm::Triple::thumbeb:
5562 RenderARMABI(
D, Triple, Args, CmdArgs);
5564 case llvm::Triple::aarch64:
5565 case llvm::Triple::aarch64_32:
5566 case llvm::Triple::aarch64_be:
5567 RenderAArch64ABI(Triple, Args, CmdArgs);
5572 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5573 if (A->getOption().matches(options::OPT_O4)) {
5574 CmdArgs.push_back(
"-O3");
5575 D.Diag(diag::warn_O4_is_O3);
5577 A->render(Args, CmdArgs);
5582 if (Output.
getType() == types::TY_Dependencies) {
5585 CmdArgs.push_back(
"-o");
5588 assert(Output.
isNothing() &&
"Input output.");
5591 for (
const auto &II : Inputs) {
5593 if (II.isFilename())
5594 CmdArgs.push_back(II.getFilename());
5596 II.getInputArg().renderAsInput(Args, CmdArgs);
5599 C.addCommand(std::make_unique<Command>(
5601 CmdArgs, Inputs, Output,
D.getPrependArg()));
5605 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5606 CmdArgs.push_back(
"-fembed-bitcode=marker");
5611 if (!
C.isForDiagnostics())
5612 CmdArgs.push_back(
"-disable-free");
5613 CmdArgs.push_back(
"-clear-ast-before-backend");
5616 const bool IsAssertBuild =
false;
5618 const bool IsAssertBuild =
true;
5622 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5623 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5624 CmdArgs.push_back(
"-disable-llvm-verifier");
5628 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5629 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5630 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5632 return types::isLLVMIR(II.getType());
5634 D.Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5636 CmdArgs.push_back(
"-discard-value-names");
5641 CmdArgs.push_back(
"-main-file-name");
5646 if (Args.hasArg(options::OPT_static))
5647 CmdArgs.push_back(
"-static-define");
5649 if (Args.hasArg(options::OPT_municode))
5650 CmdArgs.push_back(
"-DUNICODE");
5652 if (isa<AnalyzeJobAction>(JA))
5655 if (isa<AnalyzeJobAction>(JA) ||
5656 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5657 CmdArgs.push_back(
"-setup-static-analyzer");
5662 bool FoundAnalyzerConfig =
false;
5663 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5664 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5665 FoundAnalyzerConfig =
true;
5668 if (!FoundAnalyzerConfig)
5669 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5670 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5671 FoundAnalyzerConfig =
true;
5674 if (FoundAnalyzerConfig)
5675 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5680 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5681 if (FunctionAlignment) {
5682 CmdArgs.push_back(
"-function-alignment");
5683 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5688 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5690 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5692 << A->getAsString(Args) << A->getValue();
5694 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5695 << A->getAsString(Args) << A->getValue();
5698 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5699 Twine(std::min(
Value, 65536u))));
5702 if (Triple.isOSzOS()) {
5711 auto findMacroDefinition = [&](
const std::string &Macro) {
5712 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5713 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5714 return M == Macro || M.find(Macro +
'=') != std::string::npos;
5719 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5720 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5722 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5723 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5726 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5727 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5731 llvm::Reloc::Model RelocationModel;
5734 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5735 Arg *LastPICDataRelArg =
5736 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5737 options::OPT_mpic_data_is_text_relative);
5738 bool NoPICDataIsTextRelative =
false;
5739 if (LastPICDataRelArg) {
5740 if (LastPICDataRelArg->getOption().matches(
5741 options::OPT_mno_pic_data_is_text_relative)) {
5742 NoPICDataIsTextRelative =
true;
5744 D.Diag(diag::err_drv_argument_only_allowed_with)
5745 <<
"-mno-pic-data-is-text-relative"
5748 if (!Triple.isSystemZ())
5749 D.Diag(diag::err_drv_unsupported_opt_for_target)
5750 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5751 :
"-mpic-data-is-text-relative")
5755 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5756 RelocationModel == llvm::Reloc::ROPI_RWPI;
5757 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5758 RelocationModel == llvm::Reloc::ROPI_RWPI;
5760 if (Args.hasArg(options::OPT_mcmse) &&
5761 !Args.hasArg(options::OPT_fallow_unsupported)) {
5763 D.Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5765 D.Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5769 !Args.hasArg(options::OPT_fallow_unsupported))
5770 D.Diag(diag::err_drv_ropi_incompatible_with_cxx);
5774 CmdArgs.push_back(
"-mrelocation-model");
5775 CmdArgs.push_back(RMName);
5778 CmdArgs.push_back(
"-pic-level");
5779 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5781 CmdArgs.push_back(
"-pic-is-pie");
5782 if (NoPICDataIsTextRelative)
5783 CmdArgs.push_back(
"-mcmodel=medium");
5786 if (RelocationModel == llvm::Reloc::ROPI ||
5787 RelocationModel == llvm::Reloc::ROPI_RWPI)
5788 CmdArgs.push_back(
"-fropi");
5789 if (RelocationModel == llvm::Reloc::RWPI ||
5790 RelocationModel == llvm::Reloc::ROPI_RWPI)
5791 CmdArgs.push_back(
"-frwpi");
5793 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5794 CmdArgs.push_back(
"-meabi");
5795 CmdArgs.push_back(A->getValue());
5809 if (Triple.isOSBinFormatELF()) {
5810 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5811 options::OPT_fno_semantic_interposition);
5812 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5814 bool SupportsLocalAlias =
5815 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5817 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5818 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5819 A->render(Args, CmdArgs);
5820 else if (!SupportsLocalAlias)
5821 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5827 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5829 D.Diag(diag::err_drv_invalid_thread_model_for_target)
5830 << A->getValue() << A->getAsString(Args);
5831 Model = A->getValue();
5834 if (Model !=
"posix") {
5835 CmdArgs.push_back(
"-mthread-model");
5836 CmdArgs.push_back(Args.MakeArgString(Model));
5840 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5841 StringRef Name = A->getValue();
5842 if (Name ==
"SVML") {
5843 if (Triple.getArch() != llvm::Triple::x86 &&
5844 Triple.getArch() != llvm::Triple::x86_64)
5845 D.Diag(diag::err_drv_unsupported_opt_for_target)
5846 << Name << Triple.getArchName();
5847 }
else if (Name ==
"LIBMVEC-X86") {
5848 if (Triple.getArch() != llvm::Triple::x86 &&
5849 Triple.getArch() != llvm::Triple::x86_64)
5850 D.Diag(diag::err_drv_unsupported_opt_for_target)
5851 << Name << Triple.getArchName();
5852 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5853 if (Triple.getArch() != llvm::Triple::aarch64 &&
5854 Triple.getArch() != llvm::Triple::aarch64_be &&
5855 Triple.getArch() != llvm::Triple::riscv64)
5856 D.Diag(diag::err_drv_unsupported_opt_for_target)
5857 << Name << Triple.getArchName();
5859 A->render(Args, CmdArgs);
5862 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5863 options::OPT_fno_merge_all_constants,
false))
5864 CmdArgs.push_back(
"-fmerge-all-constants");
5866 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5867 options::OPT_fno_delete_null_pointer_checks);
5871 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5872 if (!Triple.isOSAIX() || Triple.isPPC32())
5873 D.Diag(diag::err_drv_unsupported_opt_for_target)
5874 << A->getSpelling() << RawTriple.str();
5875 CmdArgs.push_back(
"-mabi=quadword-atomics");
5878 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5881 if (Triple.isOSAIX())
5882 D.Diag(diag::err_drv_unsupported_opt_for_target)
5883 << A->getSpelling() << RawTriple.str();
5886 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5887 StringRef
V = A->getValue(), V1 =
V;
5889 if (V1.consumeInteger(10, Size) || !V1.empty())
5890 D.Diag(diag::err_drv_invalid_argument_to_option)
5891 <<
V << A->getOption().getName();
5893 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5896 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5897 options::OPT_fno_jump_tables);
5898 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5899 options::OPT_fno_profile_sample_accurate);
5900 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5901 options::OPT_fno_preserve_as_comments);
5903 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5904 CmdArgs.push_back(
"-mregparm");
5905 CmdArgs.push_back(A->getValue());
5908 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5909 options::OPT_msvr4_struct_return)) {
5911 D.Diag(diag::err_drv_unsupported_opt_for_target)
5912 << A->getSpelling() << RawTriple.str();
5913 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5914 CmdArgs.push_back(
"-maix-struct-return");
5916 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5917 CmdArgs.push_back(
"-msvr4-struct-return");
5921 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5922 options::OPT_freg_struct_return)) {
5923 if (TC.
getArch() != llvm::Triple::x86) {
5924 D.Diag(diag::err_drv_unsupported_opt_for_target)
5925 << A->getSpelling() << RawTriple.str();
5926 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5927 CmdArgs.push_back(
"-fpcc-struct-return");
5929 assert(A->getOption().matches(options::OPT_freg_struct_return));
5930 CmdArgs.push_back(
"-freg-struct-return");
5934 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5935 if (Triple.getArch() == llvm::Triple::m68k)
5936 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5938 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5941 if (Args.hasArg(options::OPT_fenable_matrix)) {
5943 CmdArgs.push_back(
"-fenable-matrix");
5944 CmdArgs.push_back(
"-mllvm");
5945 CmdArgs.push_back(
"-enable-matrix");
5950 const char *FPKeepKindStr =
nullptr;
5951 switch (FPKeepKind) {
5953 FPKeepKindStr =
"-mframe-pointer=none";
5956 FPKeepKindStr =
"-mframe-pointer=reserved";
5959 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5962 FPKeepKindStr =
"-mframe-pointer=all";
5965 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5966 CmdArgs.push_back(FPKeepKindStr);
5968 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5969 options::OPT_fno_zero_initialized_in_bss);
5973 D.Diag(diag::warn_drv_deprecated_arg_ofast);
5976 OptSpecifier StrictAliasingAliasOption =
5977 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5980 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5981 options::OPT_fno_strict_aliasing, !IsWindowsMSVC))
5982 CmdArgs.push_back(
"-relaxed-aliasing");
5983 if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
5985 CmdArgs.push_back(
"-no-pointer-tbaa");
5986 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5987 options::OPT_fno_struct_path_tbaa,
true))
5988 CmdArgs.push_back(
"-no-struct-path-tbaa");
5989 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5990 options::OPT_fno_strict_enums);
5991 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5992 options::OPT_fno_strict_return);
5993 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5994 options::OPT_fno_allow_editor_placeholders);
5995 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5996 options::OPT_fno_strict_vtable_pointers);
5997 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5998 options::OPT_fno_force_emit_vtables);
5999 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
6000 options::OPT_fno_optimize_sibling_calls);
6001 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
6002 options::OPT_fno_escaping_block_tail_calls);
6004 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
6005 options::OPT_fno_fine_grained_bitfield_accesses);
6007 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6008 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6010 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6011 options::OPT_fno_experimental_omit_vtable_rtti);
6013 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
6014 options::OPT_fno_disable_block_signature_string);
6017 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
6018 options::OPT_fno_split_stack);
6021 if (Args.hasFlag(options::OPT_fprotect_parens,
6022 options::OPT_fno_protect_parens,
false))
6023 CmdArgs.push_back(
"-fprotect-parens");
6027 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
6028 const llvm::Triple::ArchType Arch = TC.
getArch();
6029 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6030 StringRef
V = A->getValue();
6032 CmdArgs.push_back(
"-fextend-arguments=64");
6034 D.Diag(diag::err_drv_invalid_argument_to_option)
6035 << A->getValue() << A->getOption().getName();
6037 D.Diag(diag::err_drv_unsupported_opt_for_target)
6038 << A->getOption().getName() << TripleStr;
6041 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
6042 if (TC.
getArch() == llvm::Triple::avr)
6043 A->render(Args, CmdArgs);
6045 D.Diag(diag::err_drv_unsupported_opt_for_target)
6046 << A->getAsString(Args) << TripleStr;
6049 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
6051 A->render(Args, CmdArgs);
6053 (A->getOption().getID() != options::OPT_mlong_double_80))
6054 A->render(Args, CmdArgs);
6056 D.Diag(diag::err_drv_unsupported_opt_for_target)
6057 << A->getAsString(Args) << TripleStr;
6063 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
6064 IsIntegratedAssemblerDefault))
6065 CmdArgs.push_back(
"-fno-verbose-asm");
6069 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
6070 StringRef
V = A->getValue();
6073 A->render(Args, CmdArgs);
6074 else if (!
V.consumeInteger(10,
Num) &&
Num > 0 &&
6075 (
V.empty() || (
V.consume_front(
".") &&
6076 !
V.consumeInteger(10,
Num) &&
V.empty())))
6077 A->render(Args, CmdArgs);
6079 D.Diag(diag::err_drv_invalid_argument_to_option)
6080 << A->getValue() << A->getOption().getName();
6086 CmdArgs.push_back(
"-no-integrated-as");
6088 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
6089 CmdArgs.push_back(
"-mdebug-pass");
6090 CmdArgs.push_back(
"Structure");
6092 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
6093 CmdArgs.push_back(
"-mdebug-pass");
6094 CmdArgs.push_back(
"Arguments");
6100 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
6101 CmdArgs.push_back(
"-mconstructor-aliases");
6105 if (KernelOrKext && RawTriple.isOSDarwin())
6106 CmdArgs.push_back(
"-fforbid-guard-variables");
6108 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
6109 Triple.isWindowsGNUEnvironment())) {
6110 CmdArgs.push_back(
"-mms-bitfields");
6113 if (Triple.isWindowsGNUEnvironment()) {
6114 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
6115 options::OPT_fno_auto_import);
6118 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
6119 Triple.isX86() && IsWindowsMSVC))
6120 CmdArgs.push_back(
"-fms-volatile");
6125 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
6126 options::OPT_fno_direct_access_external_data)) {
6127 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
6129 A->render(Args, CmdArgs);
6130 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
6133 CmdArgs.push_back(
"-fno-direct-access-external-data");
6136 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
6137 CmdArgs.push_back(
"-fno-plt");
6144 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
6147 CmdArgs.push_back(
"-ffreestanding");
6149 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
6156 bool IsAsyncUnwindTablesDefault =
6158 bool IsSyncUnwindTablesDefault =
6161 bool AsyncUnwindTables = Args.hasFlag(
6162 options::OPT_fasynchronous_unwind_tables,
6163 options::OPT_fno_asynchronous_unwind_tables,
6164 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
6167 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
6168 IsSyncUnwindTablesDefault && !Freestanding);
6169 if (AsyncUnwindTables)
6170 CmdArgs.push_back(
"-funwind-tables=2");
6171 else if (UnwindTables)
6172 CmdArgs.push_back(
"-funwind-tables=1");
6176 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
6177 (IsCudaDevice || IsHIPDevice || IsSYCLDevice)) {
6178 const ArgList &HostArgs =
6180 std::string HostCPU =
6182 if (!HostCPU.empty()) {
6183 CmdArgs.push_back(
"-aux-target-cpu");
6184 CmdArgs.push_back(Args.MakeArgString(HostCPU));
6192 addMCModel(
D, Args, Triple, RelocationModel, CmdArgs);
6194 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
6195 StringRef
Value = A->getValue();
6196 unsigned TLSSize = 0;
6197 Value.getAsInteger(10, TLSSize);
6198 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
6199 D.Diag(diag::err_drv_unsupported_opt_for_target)
6200 << A->getOption().getName() << TripleStr;
6201 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
6202 D.Diag(diag::err_drv_invalid_int_value)
6203 << A->getOption().getName() <<
Value;
6204 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6208 CmdArgs.push_back(
"-enable-tlsdesc");
6211 std::string CPU =
getCPUName(
D, Args, Triple,
false);
6213 CmdArgs.push_back(
"-target-cpu");
6214 CmdArgs.push_back(Args.MakeArgString(CPU));
6217 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6222 AddClangCLArgs(Args, InputType, CmdArgs);
6224 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6225 llvm::codegenoptions::NoDebugInfo;
6228 CmdArgs, Output, DebugInfoKind, DwarfFission);
6236 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
6237 isa<BackendJobAction>(JA));
6239 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6240 CmdArgs.push_back(
"-split-dwarf-file");
6241 CmdArgs.push_back(SplitDWARFOut);
6243 CmdArgs.push_back(
"-split-dwarf-output");
6244 CmdArgs.push_back(SplitDWARFOut);
6249 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6250 CmdArgs.push_back(
"-target-linker-version");
6251 CmdArgs.push_back(A->getValue());
6256 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6258 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6259 TC.
getArch() == llvm::Triple::x86) {
6260 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6261 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6262 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6263 << Unsupported->getOption().getName();
6266 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6267 D.Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6268 << Unsupported->getOption().getName()
6269 <<
"please use -maltivec and include altivec.h explicitly";
6270 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6271 D.Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6272 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6275 Args.AddAllArgs(CmdArgs, options::OPT_v);
6277 if (Args.getLastArg(options::OPT_H)) {
6278 CmdArgs.push_back(
"-H");
6279 CmdArgs.push_back(
"-sys-header-deps");
6281 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6283 if (
D.CCPrintHeadersFormat && !
D.CCGenDiagnostics) {
6284 CmdArgs.push_back(
"-header-include-file");
6285 CmdArgs.push_back(!
D.CCPrintHeadersFilename.empty()
6286 ?
D.CCPrintHeadersFilename.c_str()
6288 CmdArgs.push_back(
"-sys-header-deps");
6289 CmdArgs.push_back(Args.MakeArgString(
6290 "-header-include-format=" +
6293 Args.MakeArgString(
"-header-include-filtering=" +
6295 D.CCPrintHeadersFiltering))));
6297 Args.AddLastArg(CmdArgs, options::OPT_P);
6298 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6300 if (
D.CCLogDiagnostics && !
D.CCGenDiagnostics) {
6301 CmdArgs.push_back(
"-diagnostic-log-file");
6302 CmdArgs.push_back(!
D.CCLogDiagnosticsFilename.empty()
6303 ?
D.CCLogDiagnosticsFilename.c_str()
6309 if (
D.CCGenDiagnostics)
6310 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6314 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6315 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6316 CmdArgs.push_back(
"-mllvm");
6317 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6322 if (Args.hasFlag(options::OPT_ffunction_sections,
6323 options::OPT_fno_function_sections, UseSeparateSections)) {
6324 CmdArgs.push_back(
"-ffunction-sections");
6327 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6328 options::OPT_fno_basic_block_address_map)) {
6329 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6330 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6331 A->render(Args, CmdArgs);
6333 D.Diag(diag::err_drv_unsupported_opt_for_target)
6334 << A->getAsString(Args) << TripleStr;
6338 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6339 StringRef Val = A->getValue();
6340 if (Val ==
"labels") {
6341 D.Diag(diag::warn_drv_deprecated_arg)
6342 << A->getAsString(Args) <<
true
6343 <<
"-fbasic-block-address-map";
6344 CmdArgs.push_back(
"-fbasic-block-address-map");
6345 }
else if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6346 if (Val !=
"all" && Val !=
"none" && !Val.starts_with(
"list="))
6347 D.Diag(diag::err_drv_invalid_value)
6348 << A->getAsString(Args) << A->getValue();
6350 A->render(Args, CmdArgs);
6351 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6354 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6355 D.Diag(diag::err_drv_invalid_value)
6356 << A->getAsString(Args) << A->getValue();
6358 A->render(Args, CmdArgs);
6359 }
else if (Triple.isNVPTX()) {
6362 }
else if (Val !=
"none") {
6365 D.Diag(diag::err_drv_unsupported_opt_for_target)
6366 << A->getAsString(Args) << TripleStr;
6370 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6371 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6372 UseSeparateSections || HasDefaultDataSections)) {
6373 CmdArgs.push_back(
"-fdata-sections");
6376 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6377 options::OPT_fno_unique_section_names);
6378 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6379 options::OPT_fno_separate_named_sections);
6380 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6381 options::OPT_fno_unique_internal_linkage_names);
6382 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6383 options::OPT_fno_unique_basic_block_section_names);
6385 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6386 options::OPT_fno_split_machine_functions)) {
6387 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6389 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6390 A->render(Args, CmdArgs);
6392 D.Diag(diag::err_drv_unsupported_opt_for_target)
6393 << A->getAsString(Args) << TripleStr;
6397 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6398 options::OPT_finstrument_functions_after_inlining,
6399 options::OPT_finstrument_function_entry_bare);
6400 Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6401 options::OPT_fno_convergent_functions);
6406 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
6409 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6412 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
6413 CmdArgs.push_back(
"-mllvm");
6414 CmdArgs.push_back(
"-sample-profile-use-profi");
6418 if (RawTriple.isPS() &&
6419 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6425 if (Args.hasArg(options::OPT_nostdinc)) {
6426 CmdArgs.push_back(
"-nostdsysteminc");
6427 CmdArgs.push_back(
"-nobuiltininc");
6429 if (Args.hasArg(options::OPT_nostdlibinc))
6430 CmdArgs.push_back(
"-nostdsysteminc");
6431 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6432 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6436 CmdArgs.push_back(
"-resource-dir");
6437 CmdArgs.push_back(
D.ResourceDir.c_str());
6439 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6448 AddPreprocessingOptions(
C, JA,
D, Args, CmdArgs, Output, Inputs);
6454 Args.ClaimAllArgs(options::OPT_D);
6457 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
6458 if (A->getOption().matches(options::OPT_O4)) {
6459 CmdArgs.push_back(
"-O3");
6460 D.Diag(diag::warn_O4_is_O3);
6462 A->render(Args, CmdArgs);
6468 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6469 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6474 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6475 D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6481 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6484 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6486 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6487 unsigned WarningNumber;
6488 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6489 D.Diag(diag::err_drv_invalid_int_value)
6490 << A->getAsString(Args) << A->getValue();
6495 CmdArgs.push_back(Args.MakeArgString(
6500 A->render(Args, CmdArgs);
6503 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6505 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6506 CmdArgs.push_back(
"-pedantic");
6507 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6508 Args.AddLastArg(CmdArgs, options::OPT_w);
6510 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6511 options::OPT_fno_fixed_point);
6513 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6514 A->render(Args, CmdArgs);
6516 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6517 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6519 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6520 options::OPT_fno_experimental_omit_vtable_rtti);
6522 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6523 A->render(Args, CmdArgs);
6530 bool ImplyVCPPCVer =
false;
6531 bool ImplyVCPPCXXVer =
false;
6532 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6534 if (
Std->getOption().matches(options::OPT_ansi))
6536 CmdArgs.push_back(
"-std=c++98");
6538 CmdArgs.push_back(
"-std=c89");
6540 Std->render(Args, CmdArgs);
6543 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6544 options::OPT_ftrigraphs,
6545 options::OPT_fno_trigraphs))
6547 A->render(Args, CmdArgs);
6556 if (!Args.hasArg(options::OPT__SLASH_std)) {
6557 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6560 ImplyVCPPCVer =
true;
6562 else if (IsWindowsMSVC)
6563 ImplyVCPPCXXVer =
true;
6565 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6566 options::OPT_fno_trigraphs);
6582 Args.getLastArg(options::OPT_Wwrite_strings,
6583 options::OPT_Wno_write_strings, options::OPT_w);
6585 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6586 CmdArgs.push_back(
"-fconst-strings");
6593 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6595 CmdArgs.push_back(
"-fdeprecated-macro");
6599 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6600 if (
Asm->getOption().matches(options::OPT_fasm))
6601 CmdArgs.push_back(
"-fgnu-keywords");
6603 CmdArgs.push_back(
"-fno-gnu-keywords");
6607 CmdArgs.push_back(
"-fno-autolink");
6609 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6610 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6611 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6612 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6614 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6616 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6617 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6619 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6620 CmdArgs.push_back(
"-fbracket-depth");
6621 CmdArgs.push_back(A->getValue());
6624 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6625 options::OPT_Wlarge_by_value_copy_def)) {
6626 if (A->getNumValues()) {
6627 StringRef
bytes = A->getValue();
6628 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6630 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6633 if (Args.hasArg(options::OPT_relocatable_pch))
6634 CmdArgs.push_back(
"-relocatable-pch");
6636 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6637 static const char *kCFABIs[] = {
6638 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6641 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6642 D.Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6644 A->render(Args, CmdArgs);
6647 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6648 CmdArgs.push_back(
"-fconstant-string-class");
6649 CmdArgs.push_back(A->getValue());
6652 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6653 CmdArgs.push_back(
"-ftabstop");
6654 CmdArgs.push_back(A->getValue());
6657 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6658 options::OPT_fno_stack_size_section);
6660 if (Args.hasArg(options::OPT_fstack_usage)) {
6661 CmdArgs.push_back(
"-stack-usage-file");
6663 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6665 llvm::sys::path::replace_extension(OutputFilename,
"su");
6666 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6672 CmdArgs.push_back(
"-ferror-limit");
6673 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6674 CmdArgs.push_back(A->getValue());
6676 CmdArgs.push_back(
"19");
6678 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6679 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6680 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6681 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6682 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6685 unsigned MessageLength = 0;
6686 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6687 StringRef
V(A->getValue());
6688 if (
V.getAsInteger(0, MessageLength))
6689 D.Diag(diag::err_drv_invalid_argument_to_option)
6690 <<
V << A->getOption().getName();
6694 MessageLength = llvm::sys::Process::StandardErrColumns();
6696 if (MessageLength != 0)
6698 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6700 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6702 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6704 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6705 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6706 Twine(A->getValue(0))));
6709 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6710 options::OPT_fvisibility_ms_compat)) {
6711 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6712 A->render(Args, CmdArgs);
6714 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6715 CmdArgs.push_back(
"-fvisibility=hidden");
6716 CmdArgs.push_back(
"-ftype-visibility=default");
6718 }
else if (IsOpenMPDevice) {
6722 CmdArgs.push_back(
"-fvisibility=protected");
6726 if (!RawTriple.isPS()) {
6728 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6729 options::OPT_fno_visibility_from_dllstorageclass)) {
6730 if (A->getOption().matches(
6731 options::OPT_fvisibility_from_dllstorageclass)) {
6732 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6733 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6734 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6735 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6736 Args.AddLastArg(CmdArgs,
6737 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6742 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6743 options::OPT_fno_visibility_inlines_hidden,
false))
6744 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6746 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6747 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6752 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6753 D.Diag(diag::warn_drv_deprecated_arg)
6754 << A->getAsString(Args) <<
true
6755 <<
"-fvisibility-global-new-delete=force-hidden";
6759 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6760 options::OPT_fvisibility_global_new_delete_hidden)) {
6761 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6762 A->render(Args, CmdArgs);
6764 assert(A->getOption().matches(
6765 options::OPT_fvisibility_global_new_delete_hidden));
6766 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6770 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6772 if (Args.hasFlag(options::OPT_fnew_infallible,
6773 options::OPT_fno_new_infallible,
false))
6774 CmdArgs.push_back(
"-fnew-infallible");
6776 if (Args.hasFlag(options::OPT_fno_operator_names,
6777 options::OPT_foperator_names,
false))
6778 CmdArgs.push_back(
"-fno-operator-names");
6781 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6782 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6783 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6784 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6785 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
6786 options::OPT_fno_raw_string_literals);
6788 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6789 Triple.hasDefaultEmulatedTLS()))
6790 CmdArgs.push_back(
"-femulated-tls");
6792 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6793 options::OPT_fno_check_new);
6795 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6799 if (!Triple.isX86() && !Triple.isAArch64())
6800 D.Diag(diag::err_drv_unsupported_opt_for_target)
6801 << A->getAsString(Args) << TripleStr;
6805 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm)
6806 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6808 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6809 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6813 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6814 options::OPT_fno_openmp,
false) &&
6815 !Args.hasFlag(options::OPT_foffload_via_llvm,
6816 options::OPT_fno_offload_via_llvm,
false) &&
6819 switch (
D.getOpenMPRuntime(Args)) {
6823 CmdArgs.push_back(
"-fopenmp");
6828 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6829 options::OPT_fnoopenmp_use_tls,
true))
6830 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6831 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6832 options::OPT_fno_openmp_simd);
6833 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6834 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6835 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6836 options::OPT_fno_openmp_extensions,
true))
6837 CmdArgs.push_back(
"-fno-openmp-extensions");
6838 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6839 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6840 Args.AddAllArgs(CmdArgs,
6841 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6842 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6843 options::OPT_fno_openmp_optimistic_collapse,
6845 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6849 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6850 options::OPT_fno_openmp_cuda_mode,
false))
6851 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6854 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6855 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6856 options::OPT_fno_openmp_target_debug,
false))
6857 CmdArgs.push_back(
"-fopenmp-target-debug");
6861 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6862 options::OPT_fno_openmp_assume_teams_oversubscription,
6864 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6865 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6866 options::OPT_fno_openmp_assume_threads_oversubscription,
6868 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6869 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6870 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6871 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6872 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6873 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6874 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6875 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6876 CmdArgs.push_back(
"-fopenmp-force-usm");
6888 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6889 options::OPT_fno_openmp_simd);
6890 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6891 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6892 options::OPT_fno_openmp_extensions);
6897 if (Args.hasFlag(options::OPT_foffload_via_llvm,
6898 options::OPT_fno_offload_via_llvm,
false)) {
6899 CmdArgs.append({
"--offload-new-driver",
"-foffload-via-llvm"});
6900 }
else if (Args.hasFlag(options::OPT_offload_new_driver,
6901 options::OPT_no_offload_new_driver,
6903 CmdArgs.push_back(
"--offload-new-driver");
6907 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6910 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6912 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" +
Filename));
6914 D.Diag(clang::diag::err_drv_no_such_file) <<
Filename;
6917 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6918 StringRef S0 = A->getValue(), S = S0;
6919 unsigned Size, Offset = 0;
6920 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6922 !(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||
6923 Triple.getArch() == llvm::Triple::ppc64)))
6924 D.Diag(diag::err_drv_unsupported_opt_for_target)
6925 << A->getAsString(Args) << TripleStr;
6926 else if (S.consumeInteger(10, Size) ||
6927 (!S.empty() && (!S.consume_front(
",") ||
6928 S.consumeInteger(10, Offset) || !S.empty())))
6929 D.Diag(diag::err_drv_invalid_argument_to_option)
6930 << S0 << A->getOption().getName();
6931 else if (Size < Offset)
6932 D.Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6934 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6935 CmdArgs.push_back(Args.MakeArgString(
6936 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6940 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6943 Args.AddLastArg(CmdArgs, options::OPT_pg);
6945 llvm::Triple::ArchType Arch = TC.
getArch();
6946 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6947 if (Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6948 A->render(Args, CmdArgs);
6950 D.Diag(diag::err_drv_unsupported_opt_for_target)
6951 << A->getAsString(Args) << TripleStr;
6953 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6954 if (Arch == llvm::Triple::systemz)
6955 A->render(Args, CmdArgs);
6957 D.Diag(diag::err_drv_unsupported_opt_for_target)
6958 << A->getAsString(Args) << TripleStr;
6960 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6961 if (Arch == llvm::Triple::systemz)
6962 A->render(Args, CmdArgs);
6964 D.Diag(diag::err_drv_unsupported_opt_for_target)
6965 << A->getAsString(Args) << TripleStr;
6969 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6971 D.Diag(diag::err_drv_unsupported_opt_for_target)
6972 << A->getAsString(Args) << TripleStr;
6975 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6977 D.Diag(diag::err_drv_unsupported_opt_for_target)
6978 << A->getAsString(Args) << TripleStr;
6981 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6982 if (A->getOption().matches(options::OPT_p)) {
6984 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6985 CmdArgs.push_back(
"-pg");
6991 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6992 options::OPT_mxcoff_build_id_EQ)) {
6993 D.Diag(diag::err_drv_unsupported_opt_for_target)
6994 << A->getSpelling() << TripleStr;
6998 if (Args.getLastArg(options::OPT_fapple_kext) ||
6999 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
7000 CmdArgs.push_back(
"-fapple-kext");
7002 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
7003 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
7004 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
7005 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
7006 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
7007 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
7008 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
7009 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
7010 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
7011 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
7013 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
7014 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
7015 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
7016 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
7019 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
7020 CmdArgs.push_back(
"-ftrapv-handler");
7021 CmdArgs.push_back(A->getValue());
7024 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
7030 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
7031 options::OPT_fno_finite_loops);
7033 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
7034 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
7035 options::OPT_fno_unroll_loops);
7037 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
7039 Args.AddLastArg(CmdArgs, options::OPT_pthread);
7041 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
7042 options::OPT_mno_speculative_load_hardening);
7048 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
7050 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
7051 options::OPT_mno_stackrealign);
7053 if (Args.hasArg(options::OPT_mstack_alignment)) {
7054 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
7055 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
7058 if (Args.hasArg(options::OPT_mstack_probe_size)) {
7059 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
7062 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
7064 CmdArgs.push_back(
"-mstack-probe-size=0");
7067 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
7068 options::OPT_mno_stack_arg_probe);
7070 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
7071 options::OPT_mno_restrict_it)) {
7072 if (A->getOption().matches(options::OPT_mrestrict_it)) {
7073 CmdArgs.push_back(
"-mllvm");
7074 CmdArgs.push_back(
"-arm-restrict-it");
7076 CmdArgs.push_back(
"-mllvm");
7077 CmdArgs.push_back(
"-arm-default-it");
7091 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
7092 options::OPT_fno_hip_new_launch_api,
true))
7093 CmdArgs.push_back(
"-fhip-new-launch-api");
7094 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
7095 options::OPT_fno_gpu_allow_device_init);
7096 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
7097 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
7098 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
7099 options::OPT_fno_hip_kernel_arg_name);
7102 if (IsCuda || IsHIP) {
7104 CmdArgs.push_back(
"-fgpu-rdc");
7105 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
7106 options::OPT_fno_gpu_defer_diag);
7107 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
7108 options::OPT_fno_gpu_exclude_wrong_side_overloads,
7110 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
7111 CmdArgs.push_back(
"-fgpu-defer-diag");
7116 if (Args.hasArg(options::OPT_nogpulib))
7117 CmdArgs.push_back(
"-nogpulib");
7119 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
7121 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
7123 if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
7124 CmdArgs.push_back(Args.MakeArgString(Twine(
"-mcf-branch-label-scheme=") +
7128 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
7130 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
7132 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
7137 if (!(IsCudaDevice || IsHIPDevice)) {
7139 auto *PGOArg = Args.getLastArg(
7140 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
7141 options::OPT_fcs_profile_generate,
7142 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
7143 options::OPT_fprofile_use_EQ);
7145 D.Diag(diag::err_drv_argument_not_allowed_with)
7146 <<
"SampleUse with PGO options";
7148 StringRef fname = A->getValue();
7149 if (!llvm::sys::fs::exists(fname))
7150 D.Diag(diag::err_drv_no_such_file) << fname;
7152 A->render(Args, CmdArgs);
7154 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
7156 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
7157 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
7158 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
7161 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
7162 options::OPT_fno_unique_internal_linkage_names,
true))
7163 CmdArgs.push_back(
"-funique-internal-linkage-names");
7168 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7169 options::OPT_fno_assume_sane_operator_new);
7171 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
7172 CmdArgs.push_back(
"-fapinotes");
7173 if (Args.hasFlag(options::OPT_fapinotes_modules,
7174 options::OPT_fno_apinotes_modules,
false))
7175 CmdArgs.push_back(
"-fapinotes-modules");
7176 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
7179 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
7181 (Args.hasArg(options::OPT_fgnu_runtime) &&
7182 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
7183 !Args.hasArg(options::OPT_fno_blocks))) {
7184 CmdArgs.push_back(
"-fblocks");
7187 CmdArgs.push_back(
"-fblocks-runtime-optional");
7192 CmdArgs.push_back(
"-fencode-extended-block-signature");
7194 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7195 options::OPT_fno_coro_aligned_allocation,
false) &&
7197 CmdArgs.push_back(
"-fcoro-aligned-allocation");
7199 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7200 options::OPT_fno_double_square_bracket_attributes);
7202 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7203 options::OPT_fno_access_control);
7204 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7205 options::OPT_fno_elide_constructors);
7211 CmdArgs.push_back(
"-fno-rtti");
7214 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7215 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
7216 CmdArgs.push_back(
"-fshort-enums");
7222 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
7223 !RawTriple.isOSAIX() && !RawTriple.isOSWindows() &&
7224 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
7225 RawTriple.hasEnvironment())) ||
7227 CmdArgs.push_back(
"-fno-use-cxa-atexit");
7229 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7230 options::OPT_fno_register_global_dtors_with_atexit,
7231 RawTriple.isOSDarwin() && !KernelOrKext))
7232 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7234 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7235 options::OPT_fno_use_line_directives);
7238 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7239 options::OPT_fno_minimize_whitespace,
false)) {
7240 types::ID InputType = Inputs[0].getType();
7241 if (!isDerivedFromC(InputType))
7242 D.Diag(diag::err_drv_opt_unsupported_input_type)
7244 CmdArgs.push_back(
"-fminimize-whitespace");
7248 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7249 options::OPT_fno_keep_system_includes,
false)) {
7250 types::ID InputType = Inputs[0].getType();
7251 if (!isDerivedFromC(InputType))
7252 D.Diag(diag::err_drv_opt_unsupported_input_type)
7254 CmdArgs.push_back(
"-fkeep-system-includes");
7258 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7259 IsWindowsMSVC || IsUEFI))
7260 CmdArgs.push_back(
"-fms-extensions");
7263 bool IsMSVCCompat = Args.hasFlag(
7264 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7265 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7266 options::OPT_fno_ms_extensions,
true)));
7268 CmdArgs.push_back(
"-fms-compatibility");
7270 Args.hasArg(options::OPT_fms_define_stdc))
7271 CmdArgs.push_back(
"-fms-define-stdc");
7274 if (Triple.isWindowsMSVCEnvironment() && !
D.IsCLMode() &&
7275 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7279 VersionTuple GNUCVer;
7280 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7283 StringRef Val = A->getValue();
7284 Val = Val.empty() ?
"0" : Val;
7285 bool Invalid = GNUCVer.tryParse(Val);
7286 unsigned Minor = GNUCVer.getMinor().value_or(0);
7287 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7288 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7289 D.Diag(diag::err_drv_invalid_value)
7290 << A->getAsString(Args) << A->getValue();
7292 }
else if (!IsMSVCCompat) {
7294 GNUCVer = VersionTuple(4, 2, 1);
7296 if (!GNUCVer.empty()) {
7298 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7304 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7306 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7307 if (ImplyVCPPCVer) {
7308 StringRef LanguageStandard;
7309 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7311 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7312 .Case(
"c11",
"-std=c11")
7313 .Case(
"c17",
"-std=c17")
7315 if (LanguageStandard.empty())
7316 D.Diag(clang::diag::warn_drv_unused_argument)
7317 << StdArg->getAsString(Args);
7319 CmdArgs.push_back(LanguageStandard.data());
7321 if (ImplyVCPPCXXVer) {
7322 StringRef LanguageStandard;
7323 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7325 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7326 .Case(
"c++14",
"-std=c++14")
7327 .Case(
"c++17",
"-std=c++17")
7328 .Case(
"c++20",
"-std=c++20")
7330 .Case(
"c++23preview",
"-std=c++23")
7331 .Case(
"c++latest",
"-std=c++26")
7333 if (LanguageStandard.empty())
7334 D.Diag(clang::diag::warn_drv_unused_argument)
7335 << StdArg->getAsString(Args);
7338 if (LanguageStandard.empty()) {
7339 if (IsMSVC2015Compatible)
7340 LanguageStandard =
"-std=c++14";
7342 LanguageStandard =
"-std=c++11";
7345 CmdArgs.push_back(LanguageStandard.data());
7348 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7349 options::OPT_fno_borland_extensions);
7352 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7354 CmdArgs.push_back(
"-fdeclspec");
7355 else if (Args.hasArg(options::OPT_fno_declspec))
7356 CmdArgs.push_back(
"-fno-declspec");
7360 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7361 options::OPT_fno_threadsafe_statics,
7363 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7364 CmdArgs.push_back(
"-fno-threadsafe-statics");
7366 if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7368 CmdArgs.push_back(
"-fno-ms-tls-guards");
7371 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7373 CmdArgs.push_back(
"-fno-assumptions");
7377 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7378 options::OPT_fno_gnu_keywords);
7380 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7381 options::OPT_fno_gnu89_inline);
7383 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7384 options::OPT_finline_hint_functions,
7385 options::OPT_fno_inline_functions);
7386 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7387 if (A->getOption().matches(options::OPT_fno_inline))
7388 A->render(Args, CmdArgs);
7389 }
else if (InlineArg) {
7390 InlineArg->render(Args, CmdArgs);
7393 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7398 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"gnu++2a") ||
7399 Std->containsValue(
"c++20") ||
Std->containsValue(
"gnu++20") ||
7400 Std->containsValue(
"c++2b") ||
Std->containsValue(
"gnu++2b") ||
7401 Std->containsValue(
"c++23") ||
Std->containsValue(
"gnu++23") ||
7402 Std->containsValue(
"c++2c") ||
Std->containsValue(
"gnu++2c") ||
7403 Std->containsValue(
"c++26") ||
Std->containsValue(
"gnu++26") ||
7404 Std->containsValue(
"c++latest") ||
Std->containsValue(
"gnu++latest"));
7419 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7420 options::OPT_fno_delayed_template_parsing,
7421 IsWindowsMSVC && !HaveCxx20)) {
7423 D.Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7425 CmdArgs.push_back(
"-fdelayed-template-parsing");
7428 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7429 options::OPT_fno_pch_validate_input_files_content,
false))
7430 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7431 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7432 options::OPT_fno_pch_instantiate_templates,
false))
7433 CmdArgs.push_back(
"-fpch-instantiate-templates");
7434 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7436 CmdArgs.push_back(
"-fmodules-codegen");
7437 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7439 CmdArgs.push_back(
"-fmodules-debuginfo");
7441 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7446 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7447 options::OPT_fno_objc_encode_cxx_class_template_spec,
7449 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7451 if (Args.hasFlag(options::OPT_fapplication_extension,
7452 options::OPT_fno_application_extension,
false))
7453 CmdArgs.push_back(
"-fapplication-extension");
7457 if (!
C.getDriver().IsCLMode())
7458 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7461 Arg *A = Args.getLastArg(
7462 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7463 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7465 const Option &Opt = A->getOption();
7466 if (Opt.matches(options::OPT_fsjlj_exceptions))
7467 CmdArgs.push_back(
"-exception-model=sjlj");
7468 if (Opt.matches(options::OPT_fseh_exceptions))
7469 CmdArgs.push_back(
"-exception-model=seh");
7470 if (Opt.matches(options::OPT_fdwarf_exceptions))
7471 CmdArgs.push_back(
"-exception-model=dwarf");
7472 if (Opt.matches(options::OPT_fwasm_exceptions))
7473 CmdArgs.push_back(
"-exception-model=wasm");
7478 case llvm::ExceptionHandling::DwarfCFI:
7479 CmdArgs.push_back(
"-exception-model=dwarf");
7481 case llvm::ExceptionHandling::SjLj:
7482 CmdArgs.push_back(
"-exception-model=sjlj");
7484 case llvm::ExceptionHandling::WinEH:
7485 CmdArgs.push_back(
"-exception-model=seh");
7491 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7492 options::OPT_fno_assume_sane_operator_new);
7495 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7496 options::OPT_fno_assume_unique_vtables);
7500 Args.getLastArg(options::OPT_frelaxed_template_template_args,
7501 options::OPT_fno_relaxed_template_template_args)) {
7502 if (A->getOption().matches(
7503 options::OPT_fno_relaxed_template_template_args)) {
7504 D.Diag(diag::warn_drv_deprecated_arg_no_relaxed_template_template_args);
7505 CmdArgs.push_back(
"-fno-relaxed-template-template-args");
7507 D.Diag(diag::warn_drv_deprecated_arg)
7508 << A->getAsString(Args) <<
false;
7514 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
7515 options::OPT_fno_sized_deallocation);
7519 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7520 options::OPT_fno_aligned_allocation,
7521 options::OPT_faligned_new_EQ)) {
7522 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7523 CmdArgs.push_back(
"-fno-aligned-allocation");
7525 CmdArgs.push_back(
"-faligned-allocation");
7530 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7531 options::OPT_faligned_new_EQ))
7533 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7537 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7538 options::OPT_fno_constant_cfstrings,
true) ||
7539 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7540 options::OPT_mno_constant_cfstrings,
true))
7541 CmdArgs.push_back(
"-fno-constant-cfstrings");
7543 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7544 options::OPT_fno_pascal_strings);
7548 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7549 std::string PackStructStr =
"-fpack-struct=";
7550 PackStructStr += A->getValue();
7551 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7552 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7553 options::OPT_fno_pack_struct,
false)) {
7554 CmdArgs.push_back(
"-fpack-struct=1");
7558 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7559 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7560 if (!SkipMaxTypeAlign) {
7561 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7562 MaxTypeAlignStr += A->getValue();
7563 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7565 }
else if (RawTriple.isOSDarwin()) {
7566 if (!SkipMaxTypeAlign) {
7567 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7568 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7572 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7573 CmdArgs.push_back(
"-Qn");
7576 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7580 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7581 options::OPT_funsigned_bitfields,
true))
7582 D.Diag(diag::warn_drv_clang_unsupported)
7583 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7586 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7587 D.Diag(diag::err_drv_clang_unsupported)
7588 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7591 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7592 StringRef value = inputCharset->getValue();
7593 if (!value.equals_insensitive(
"utf-8"))
7594 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7599 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7600 StringRef value = execCharset->getValue();
7601 if (!value.equals_insensitive(
"utf-8"))
7602 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7608 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7609 options::OPT_fno_asm_blocks);
7611 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7612 options::OPT_fno_gnu_inline_asm);
7618 OptSpecifier VectorizeAliasOption =
7619 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
7620 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
7621 options::OPT_fno_vectorize, EnableVec))
7622 CmdArgs.push_back(
"-vectorize-loops");
7626 OptSpecifier SLPVectAliasOption =
7627 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
7628 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
7629 options::OPT_fno_slp_vectorize, EnableSLPVec))
7630 CmdArgs.push_back(
"-vectorize-slp");
7634 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7635 Args.AddLastArg(CmdArgs,
7636 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7640 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7641 options::OPT_fno_dollars_in_identifiers)) {
7642 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7643 CmdArgs.push_back(
"-fdollars-in-identifiers");
7645 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7648 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7649 options::OPT_fno_apple_pragma_pack);
7655 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7656 options::OPT_fno_rewrite_imports,
false);
7658 CmdArgs.push_back(
"-frewrite-imports");
7660 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7661 options::OPT_fno_directives_only);
7667 if (Args.hasFlag(options::OPT_frewrite_includes,
7668 options::OPT_fno_rewrite_includes,
false) ||
7669 (
C.isForDiagnostics() && !HaveModules))
7670 CmdArgs.push_back(
"-frewrite-includes");
7672 if (Args.hasFlag(options::OPT_fzos_extensions,
7673 options::OPT_fno_zos_extensions,
false))
7674 CmdArgs.push_back(
"-fzos-extensions");
7675 else if (Args.hasArg(options::OPT_fno_zos_extensions))
7676 CmdArgs.push_back(
"-fno-zos-extensions");
7679 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7680 options::OPT_traditional_cpp)) {
7681 if (isa<PreprocessJobAction>(JA))
7682 CmdArgs.push_back(
"-traditional-cpp");
7684 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7687 Args.AddLastArg(CmdArgs, options::OPT_dM);
7688 Args.AddLastArg(CmdArgs, options::OPT_dD);
7689 Args.AddLastArg(CmdArgs, options::OPT_dI);
7691 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7694 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7695 CmdArgs.push_back(
"-serialize-diagnostic-file");
7696 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7699 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7700 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7703 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7705 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7708 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7709 CmdArgs.push_back(
"-load");
7710 CmdArgs.push_back(A->getValue());
7722 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7723 auto ArgValue = StringRef(A->getValue());
7724 auto FirstDashIndex = ArgValue.find(
'-');
7725 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7726 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7729 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7730 if (PluginName.empty()) {
7731 D.Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7733 D.Diag(diag::warn_drv_missing_plugin_arg)
7734 << PluginName << A->getAsString(Args);
7739 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7740 CmdArgs.push_back(Args.MakeArgString(Arg));
7744 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7746 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7751 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7752 CmdArgs.push_back(
"--vfsoverlay");
7753 CmdArgs.push_back(A->getValue());
7757 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7758 options::OPT_fno_safe_buffer_usage_suggestions);
7760 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7761 options::OPT_fno_experimental_late_parse_attributes);
7765 if (!StatsFile.empty()) {
7766 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7767 if (
D.CCPrintInternalStats)
7768 CmdArgs.push_back(
"-stats-file-append");
7773 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7777 if (
C.getDriver().isSaveTempsEnabled() &&
7778 !isa<PreprocessJobAction>(JA)) {
7779 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7782 CmdArgs.push_back(Arg->getValue());
7784 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7790 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7791 CmdArgs.push_back(
"-disable-llvm-optzns");
7793 A->render(Args, CmdArgs);
7799 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
7809 if ((
C.getDriver().isSaveTempsEnabled() ||
7811 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7812 isa<CompileJobAction>(JA))
7813 CmdArgs.push_back(
"-disable-llvm-passes");
7815 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7817 const char *Exec =
D.getClangProgramPath();
7824 auto GRecordSwitches =
false;
7825 auto FRecordSwitches =
false;
7829 CmdArgs.push_back(
"-dwarf-debug-flags");
7830 CmdArgs.push_back(FlagsArgString);
7832 if (FRecordSwitches) {
7833 CmdArgs.push_back(
"-record-command-line");
7834 CmdArgs.push_back(FlagsArgString);
7841 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7842 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7843 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7844 }
else if (!HostOffloadingInputs.empty()) {
7845 if ((IsCuda || IsHIP) && !IsRDCMode) {
7846 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7847 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7848 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7850 for (
const InputInfo Input : HostOffloadingInputs)
7851 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7857 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7858 options::OPT_fno_cuda_short_ptr,
false))
7859 CmdArgs.push_back(
"-fcuda-short-ptr");
7862 if (IsCuda || IsHIP) {
7864 const Action *SourceAction = &JA;
7866 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7867 SourceAction = SourceAction->
getInputs()[0];
7869 auto CUID = cast<InputAction>(SourceAction)->getId();
7871 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7875 bool UseApproxTranscendentals = Args.hasFlag(
7876 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7877 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7878 options::OPT_fno_gpu_approx_transcendentals,
7879 UseApproxTranscendentals))
7880 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7882 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7883 options::OPT_fno_gpu_approx_transcendentals);
7887 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7888 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7891 Args.AddAllArgs(CmdArgs,
7892 options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);
7894 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7895 options::OPT_fno_offload_uniform_block);
7897 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7898 options::OPT_fno_offload_implicit_host_device_templates);
7900 if (IsCudaDevice || IsHIPDevice) {
7901 StringRef InlineThresh =
7902 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7903 if (!InlineThresh.empty()) {
7904 std::string ArgStr =
7905 std::string(
"-inline-threshold=") + InlineThresh.str();
7906 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7911 Args.addOptOutFlag(CmdArgs,
7912 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7913 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7920 if (IsOpenMPDevice) {
7921 CmdArgs.push_back(
"-fopenmp-is-target-device");
7923 if (Args.hasArg(options::OPT_foffload_via_llvm))
7924 CmdArgs.push_back(
"-fcuda-is-device");
7926 if (OpenMPDeviceInput) {
7927 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7928 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7932 if (Triple.isAMDGPU()) {
7935 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7936 options::OPT_mno_unsafe_fp_atomics);
7937 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7938 options::OPT_mno_amdgpu_ieee);
7943 bool VirtualFunctionElimination =
7944 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7945 options::OPT_fno_virtual_function_elimination,
false);
7946 if (VirtualFunctionElimination) {
7950 D.Diag(diag::err_drv_argument_only_allowed_with)
7951 <<
"-fvirtual-function-elimination"
7954 CmdArgs.push_back(
"-fvirtual-function-elimination");
7958 bool WholeProgramVTables = Args.hasFlag(
7959 options::OPT_fwhole_program_vtables,
7960 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7961 if (VirtualFunctionElimination && !WholeProgramVTables) {
7962 D.Diag(diag::err_drv_argument_not_allowed_with)
7963 <<
"-fno-whole-program-vtables"
7964 <<
"-fvirtual-function-elimination";
7967 if (WholeProgramVTables) {
7979 IsDeviceOffloadAction ?
D.getLTOMode() :
D.getOffloadLTOMode();
7980 auto OtherIsUsingLTO = OtherLTOMode !=
LTOK_None;
7982 if ((!IsUsingLTO && !OtherIsUsingLTO) ||
7983 (IsPS4 && !UnifiedLTO && (
D.getLTOMode() !=
LTOK_Full)))
7984 D.Diag(diag::err_drv_argument_only_allowed_with)
7985 <<
"-fwhole-program-vtables"
7986 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7990 CmdArgs.push_back(
"-fwhole-program-vtables");
7993 bool DefaultsSplitLTOUnit =
7994 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7996 (!Triple.isPS4() && UnifiedLTO);
7998 Args.hasFlag(options::OPT_fsplit_lto_unit,
7999 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
8000 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
8001 D.Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
8002 <<
"-fsanitize=cfi";
8004 CmdArgs.push_back(
"-fsplit-lto-unit");
8006 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
8007 options::OPT_fno_fat_lto_objects)) {
8008 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
8010 if (!Triple.isOSBinFormatELF()) {
8011 D.Diag(diag::err_drv_unsupported_opt_for_target)
8014 CmdArgs.push_back(Args.MakeArgString(
8015 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
8016 CmdArgs.push_back(
"-flto-unit");
8017 CmdArgs.push_back(
"-ffat-lto-objects");
8018 A->render(Args, CmdArgs);
8022 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
8023 options::OPT_fno_global_isel)) {
8024 CmdArgs.push_back(
"-mllvm");
8025 if (A->getOption().matches(options::OPT_fglobal_isel)) {
8026 CmdArgs.push_back(
"-global-isel=1");
8031 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
8032 bool IsOptLevelSupported =
false;
8034 Arg *A = Args.getLastArg(options::OPT_O_Group);
8035 if (Triple.getArch() == llvm::Triple::aarch64) {
8036 if (!A || A->getOption().matches(options::OPT_O0))
8037 IsOptLevelSupported =
true;
8039 if (!IsArchSupported || !IsOptLevelSupported) {
8040 CmdArgs.push_back(
"-mllvm");
8041 CmdArgs.push_back(
"-global-isel-abort=2");
8043 if (!IsArchSupported)
8044 D.Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
8046 D.Diag(diag::warn_drv_global_isel_incomplete_opt);
8049 CmdArgs.push_back(
"-global-isel=0");
8054 Args.getLastArg(options::OPT_forder_file_instrumentation)) {
8055 D.Diag(diag::warn_drv_deprecated_arg)
8056 << A->getAsString(Args) <<
true
8057 <<
"-mllvm -pgo-temporal-instrumentation";
8058 CmdArgs.push_back(
"-forder-file-instrumentation");
8063 CmdArgs.push_back(
"-mllvm");
8064 CmdArgs.push_back(
"-enable-order-file-instrumentation");
8068 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
8069 options::OPT_fno_force_enable_int128)) {
8070 if (A->getOption().matches(options::OPT_fforce_enable_int128))
8071 CmdArgs.push_back(
"-fforce-enable-int128");
8074 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
8075 options::OPT_fno_keep_static_consts);
8076 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
8077 options::OPT_fno_keep_persistent_storage_variables);
8078 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
8079 options::OPT_fno_complete_member_pointers);
8080 if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
8081 A->render(Args, CmdArgs);
8087 if (Triple.isAArch64() &&
8088 (Args.hasArg(options::OPT_mno_fmv) ||
8089 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
8092 CmdArgs.push_back(
"-target-feature");
8093 CmdArgs.push_back(
"-fmv");
8096 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
8103 CmdArgs.push_back(
"-faddrsig");
8105 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
8106 (EH || UnwindTables || AsyncUnwindTables ||
8107 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
8108 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
8110 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
8111 std::string Str = A->getAsString(Args);
8113 D.Diag(diag::err_drv_unsupported_opt_for_target)
8115 CmdArgs.push_back(Args.MakeArgString(Str));
8120 if (Output.
getType() == types::TY_Dependencies) {
8123 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
8124 Output.
getType() == clang::driver::types::TY_IFS) {
8126 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
8127 CmdArgs.push_back(
"-o");
8128 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
8130 CmdArgs.push_back(
"-o");
8134 assert(Output.
isNothing() &&
"Invalid output.");
8141 FrontendInputs = ExtractAPIInputs;
8143 FrontendInputs = {};
8145 for (
const InputInfo &Input : FrontendInputs) {
8152 if (
D.CC1Main && !
D.CCGenDiagnostics) {
8154 C.addCommand(std::make_unique<CC1Command>(
8156 Output,
D.getPrependArg()));
8158 C.addCommand(std::make_unique<Command>(
8160 Output,
D.getPrependArg()));
8164 if (Output.
getType() == types::TY_Object &&
8165 Args.hasFlag(options::OPT__SLASH_showFilenames,
8166 options::OPT__SLASH_showFilenames_,
false)) {
8167 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
8170 if (Arg *A = Args.getLastArg(options::OPT_pg))
8172 !Args.hasArg(options::OPT_mfentry))
8173 D.Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
8174 << A->getAsString(Args);
8180 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
8184 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8185 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8188 Args.ClaimAllArgs(options::OPT_emit_llvm);
8195 :
Tool(
"clang",
"clang frontend", TC), HasBackend(HasIntegratedBackend) {}
8202ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
8204 ArgStringList &cmdArgs,
8205 RewriteKind rewriteKind)
const {
8208 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
8209 options::OPT_fobjc_runtime_EQ);
8214 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
8216 StringRef value = runtimeArg->getValue();
8222 (runtime.
getVersion() >= VersionTuple(2, 0)))
8226 diag::err_drv_gnustep_objc_runtime_incompatible_binary)
8230 runtimeArg->render(args, cmdArgs);
8239 unsigned objcABIVersion = 1;
8241 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
8242 StringRef value = abiArg->getValue();
8245 else if (value ==
"2")
8247 else if (value ==
"3")
8253 bool nonFragileABIIsDefault =
8254 (rewriteKind == RK_NonFragile ||
8255 (rewriteKind == RK_None &&
8257 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
8258 options::OPT_fno_objc_nonfragile_abi,
8259 nonFragileABIIsDefault)) {
8261#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
8262 unsigned nonFragileABIVersion = 1;
8264 unsigned nonFragileABIVersion = 2;
8268 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
8269 StringRef value = abiArg->getValue();
8271 nonFragileABIVersion = 1;
8272 else if (value ==
"2")
8273 nonFragileABIVersion = 2;
8279 objcABIVersion = 1 + nonFragileABIVersion;
8287 bool isNonFragile = objcABIVersion != 1;
8293 switch (rewriteKind) {
8306 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
8318 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
8327 if (llvm::any_of(inputs, [](
const InputInfo &input) {
8331 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
8336 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
8344 bool Asynch =
false;
8345 bool NoUnwindC =
false;
8357 bool isWindowsMSVC) {
8360 std::vector<std::string> EHArgs =
8361 Args.getAllArgValues(options::OPT__SLASH_EH);
8362 for (
const auto &EHVal : EHArgs) {
8363 for (
size_t I = 0,
E = EHVal.size(); I !=
E; ++I) {
8369 if (!isWindowsMSVC) {
8371 D.Diag(clang::diag::warn_drv_unused_argument) <<
"/EHa" << EHVal;
8388 D.Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
8394 if (EHArgs.empty() &&
8395 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
8398 EH.NoUnwindC =
true;
8401 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8403 EH.NoUnwindC =
false;
8410void Clang::AddClangCLArgs(
const ArgList &Args,
types::ID InputType,
8411 ArgStringList &CmdArgs)
const {
8416 if (Arg *ShowIncludes =
8417 Args.getLastArg(options::OPT__SLASH_showIncludes,
8418 options::OPT__SLASH_showIncludes_user)) {
8419 CmdArgs.push_back(
"--show-includes");
8420 if (ShowIncludes->getOption().matches(options::OPT__SLASH_showIncludes))
8421 CmdArgs.push_back(
"-sys-header-deps");
8425 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8427 CmdArgs.push_back(
"-fno-rtti-data");
8431 if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
8433 CmdArgs.push_back(
"-stack-protector");
8441 if (!isNVPTX && (EH.Synch || EH.Asynch)) {
8443 CmdArgs.push_back(
"-fcxx-exceptions");
8444 CmdArgs.push_back(
"-fexceptions");
8446 CmdArgs.push_back(
"-fasync-exceptions");
8448 if (
types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
8449 CmdArgs.push_back(
"-fexternc-nounwind");
8452 if (Args.hasArg(options::OPT__SLASH_EP)) {
8453 CmdArgs.push_back(
"-E");
8454 CmdArgs.push_back(
"-P");
8457 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
8458 options::OPT__SLASH_Zc_dllexportInlines,
8460 CmdArgs.push_back(
"-fno-dllexport-inlines");
8463 if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
8464 options::OPT__SLASH_Zc_wchar_t,
false)) {
8465 CmdArgs.push_back(
"-fno-wchar");
8468 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8470 std::vector<std::string> Values =
8471 Args.getAllArgValues(options::OPT__SLASH_arch);
8472 if (!Values.empty()) {
8473 llvm::SmallSet<std::string, 4> SupportedArches;
8474 if (Arch == llvm::Triple::x86)
8475 SupportedArches.insert(
"IA32");
8477 for (
auto &
V : Values)
8478 if (!SupportedArches.contains(
V))
8479 D.Diag(diag::err_drv_argument_not_allowed_with)
8480 << std::string(
"/arch:").append(
V) <<
"/kernel";
8483 CmdArgs.push_back(
"-fno-rtti");
8484 if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_,
false))
8485 D.Diag(diag::err_drv_argument_not_allowed_with) <<
"/GR"
8489 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
8490 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
8491 if (MostGeneralArg && BestCaseArg)
8492 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
8493 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
8495 if (MostGeneralArg) {
8496 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
8497 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
8498 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
8500 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
8501 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
8502 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
8503 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
8504 << FirstConflict->getAsString(Args)
8505 << SecondConflict->getAsString(Args);
8508 CmdArgs.push_back(
"-fms-memptr-rep=single");
8509 else if (MultipleArg)
8510 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
8512 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
8515 if (Args.hasArg(options::OPT_regcall4))
8516 CmdArgs.push_back(
"-regcall4");
8520 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
8521 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
8522 options::OPT__SLASH_Gregcall)) {
8523 unsigned DCCOptId = CCArg->getOption().
getID();
8524 const char *DCCFlag =
nullptr;
8525 bool ArchSupported = !isNVPTX;
8528 case options::OPT__SLASH_Gd:
8529 DCCFlag =
"-fdefault-calling-conv=cdecl";
8531 case options::OPT__SLASH_Gr:
8532 ArchSupported = Arch == llvm::Triple::x86;
8533 DCCFlag =
"-fdefault-calling-conv=fastcall";
8535 case options::OPT__SLASH_Gz:
8536 ArchSupported = Arch == llvm::Triple::x86;
8537 DCCFlag =
"-fdefault-calling-conv=stdcall";
8539 case options::OPT__SLASH_Gv:
8540 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8541 DCCFlag =
"-fdefault-calling-conv=vectorcall";
8543 case options::OPT__SLASH_Gregcall:
8544 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
8545 DCCFlag =
"-fdefault-calling-conv=regcall";
8550 if (ArchSupported && DCCFlag)
8551 CmdArgs.push_back(DCCFlag);
8554 if (Args.hasArg(options::OPT__SLASH_Gregcall4))
8555 CmdArgs.push_back(
"-regcall4");
8557 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
8559 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
8560 CmdArgs.push_back(
"-fdiagnostics-format");
8561 CmdArgs.push_back(
"msvc");
8564 if (Args.hasArg(options::OPT__SLASH_kernel))
8565 CmdArgs.push_back(
"-fms-kernel");
8567 for (
const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
8568 StringRef GuardArgs = A->getValue();
8571 if (GuardArgs.equals_insensitive(
"cf")) {
8573 CmdArgs.push_back(
"-cfguard");
8574 }
else if (GuardArgs.equals_insensitive(
"cf,nochecks")) {
8576 CmdArgs.push_back(
"-cfguard-no-checks");
8577 }
else if (GuardArgs.equals_insensitive(
"ehcont")) {
8579 CmdArgs.push_back(
"-ehcontguard");
8580 }
else if (GuardArgs.equals_insensitive(
"cf-") ||
8581 GuardArgs.equals_insensitive(
"ehcont-")) {
8584 D.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
8592 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
8599 if (
const char *End = strrchr(Str,
'.'))
8600 return Args.MakeArgString(std::string(Str, End));
8609 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
8611 llvm::sys::path::replace_extension(OutputFilename, llvm::Twine(
'd'));
8612 return Args.MakeArgString(OutputFilename);
8621 ArgStringList &CmdArgs)
const {
8627 CmdArgs.push_back(
"-target-abi");
8628 CmdArgs.push_back(ABIName.data());
8632 ArgStringList &CmdArgs)
const {
8636 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
8637 StringRef
Value = A->getValue();
8639 CmdArgs.push_back(
"-mllvm");
8640 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
8643 << A->getSpelling() <<
Value;
8649 ArgStringList &CmdArgs)
const {
8650 CmdArgs.push_back(
"-target-abi");
8657 ArgStringList &CmdArgs)
const {
8661 CmdArgs.push_back(
"-target-abi");
8662 CmdArgs.push_back(ABIName.data());
8664 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8665 options::OPT_mno_default_build_attributes,
true)) {
8666 CmdArgs.push_back(
"-mllvm");
8667 CmdArgs.push_back(
"-riscv-add-build-attributes");
8673 const ArgList &Args,
8674 const char *LinkingOutput)
const {
8675 ArgStringList CmdArgs;
8677 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
8681 const std::string &TripleStr = Triple.getTriple();
8685 Args.ClaimAllArgs(options::OPT_w);
8687 Args.ClaimAllArgs(options::OPT_emit_llvm);
8694 CmdArgs.push_back(
"-cc1as");
8697 CmdArgs.push_back(
"-triple");
8698 CmdArgs.push_back(Args.MakeArgString(TripleStr));
8704 CmdArgs.push_back(
"-filetype");
8705 CmdArgs.push_back(
"obj");
8709 CmdArgs.push_back(
"-main-file-name");
8713 std::string CPU =
getCPUName(
D, Args, Triple,
true);
8715 CmdArgs.push_back(
"-target-cpu");
8716 CmdArgs.push_back(Args.MakeArgString(CPU));
8723 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
8726 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
8729 Args.AddAllArgs(CmdArgs, options::OPT_embed_dir_EQ);
8732 auto FindSource = [](
const Action *S) ->
const Action * {
8734 assert(!S->getInputs().empty() &&
"unexpected root action!");
8735 S = S->getInputs()[0];
8739 const Action *SourceAction = FindSource(&JA);
8743 bool WantDebug =
false;
8744 Args.ClaimAllArgs(options::OPT_g_Group);
8745 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8746 WantDebug = !A->getOption().matches(options::OPT_g0) &&
8747 !A->getOption().matches(options::OPT_ggdb0);
8750 bool EmitDwarf =
false;
8754 bool EmitCodeView =
false;
8755 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
8760 if (!EmitCodeView && !EmitDwarf && WantDebug) {
8762 case llvm::codegenoptions::DIF_CodeView:
8763 EmitCodeView =
true;
8765 case llvm::codegenoptions::DIF_DWARF:
8775 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
8776 llvm::codegenoptions::NoDebugInfo;
8779 const char *DebugCompilationDir =
8782 if (SourceAction->
getType() == types::TY_Asm ||
8783 SourceAction->
getType() == types::TY_PP_Asm) {
8788 DebugInfoKind = (WantDebug ? llvm::codegenoptions::DebugInfoConstructor
8789 : llvm::codegenoptions::NoDebugInfo);
8796 CmdArgs.push_back(
"-dwarf-debug-producer");
8800 Args.AddAllArgs(CmdArgs, options::OPT_I);
8804 llvm::DebuggerKind::Default);
8810 llvm::Reloc::Model RelocationModel;
8813 std::tie(RelocationModel, PICLevel, IsPIE) =
8818 CmdArgs.push_back(
"-mrelocation-model");
8819 CmdArgs.push_back(RMName);
8825 ArgStringList OriginalArgs;
8826 for (
const auto &Arg : Args)
8827 Arg->render(Args, OriginalArgs);
8832 for (
const char *OriginalArg : OriginalArgs) {
8836 Flags += EscapedArg;
8838 CmdArgs.push_back(
"-dwarf-debug-flags");
8839 CmdArgs.push_back(Args.MakeArgString(Flags));
8849 case llvm::Triple::mips:
8850 case llvm::Triple::mipsel:
8851 case llvm::Triple::mips64:
8852 case llvm::Triple::mips64el:
8856 case llvm::Triple::x86:
8857 case llvm::Triple::x86_64:
8861 case llvm::Triple::arm:
8862 case llvm::Triple::armeb:
8863 case llvm::Triple::thumb:
8864 case llvm::Triple::thumbeb:
8867 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8868 options::OPT_mno_default_build_attributes,
true)) {
8869 CmdArgs.push_back(
"-mllvm");
8870 CmdArgs.push_back(
"-arm-add-build-attributes");
8874 case llvm::Triple::aarch64:
8875 case llvm::Triple::aarch64_32:
8876 case llvm::Triple::aarch64_be:
8877 if (Args.hasArg(options::OPT_mmark_bti_property)) {
8878 CmdArgs.push_back(
"-mllvm");
8879 CmdArgs.push_back(
"-aarch64-mark-bti-property");
8883 case llvm::Triple::loongarch32:
8884 case llvm::Triple::loongarch64:
8888 case llvm::Triple::riscv32:
8889 case llvm::Triple::riscv64:
8893 case llvm::Triple::hexagon:
8894 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8895 options::OPT_mno_default_build_attributes,
true)) {
8896 CmdArgs.push_back(
"-mllvm");
8897 CmdArgs.push_back(
"-hexagon-add-build-attributes");
8907 Args.ClaimAllArgs(options::OPT_W_Group);
8912 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
8914 if (DebugInfoKind > llvm::codegenoptions::NoDebugInfo && Output.
isFilename())
8921 if (SourceAction != FindSource(&J.getSource()))
8923 auto &JArgs = J.getArguments();
8924 for (
unsigned I = 0; I < JArgs.size(); ++I) {
8925 if (StringRef(JArgs[I]).starts_with(
"-object-file-name=") &&
8927 ArgStringList NewArgs(JArgs.begin(), JArgs.begin() + I);
8930 NewArgs.append(JArgs.begin() + I + 1, JArgs.end());
8931 J.replaceArguments(NewArgs);
8937 assert(Output.
isFilename() &&
"Unexpected lipo output.");
8938 CmdArgs.push_back(
"-o");
8944 T.isOSBinFormatELF()) {
8945 CmdArgs.push_back(
"-split-dwarf-output");
8949 if (Triple.isAMDGPU())
8952 assert(Input.
isFilename() &&
"Invalid input.");
8956 if (
D.CC1Main && !
D.CCGenDiagnostics) {
8958 C.addCommand(std::make_unique<CC1Command>(
8960 Output,
D.getPrependArg()));
8962 C.addCommand(std::make_unique<Command>(
8964 Output,
D.getPrependArg()));
8972 const llvm::opt::ArgList &TCArgs,
8973 const char *LinkingOutput)
const {
8975 assert(isa<OffloadBundlingJobAction>(JA) &&
"Expecting bundling job!");
8985 ArgStringList CmdArgs;
8988 CmdArgs.push_back(TCArgs.MakeArgString(
8991 assert(JA.
getInputs().size() == Inputs.size() &&
8992 "Not have inputs for all dependence actions??");
8996 Triples +=
"-targets=";
8997 for (
unsigned I = 0; I < Inputs.size(); ++I) {
9006 if (
const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
9008 OA->doOnEachDependence([&](
Action *A,
const ToolChain *TC,
const char *) {
9009 assert(CurTC ==
nullptr &&
"Expected one dependence!");
9016 Triples += CurTC->
getTriple().normalize();
9025 StringRef GPUArchName;
9028 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
9029 auto ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
9030 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
9032 GPUArchName = ArchStr.substr(7);
9037 Triples += GPUArchName.str();
9040 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
9044 TCArgs.MakeArgString(Twine(
"-output=") + Output.
getFilename()));
9047 for (
unsigned I = 0; I < Inputs.size(); ++I) {
9053 if (
const auto *OA = dyn_cast<OffloadAction>(JA.
getInputs()[I])) {
9055 OA->doOnEachDependence([&](
Action *,
const ToolChain *TC,
const char *) {
9056 assert(CurTC ==
nullptr &&
"Expected one dependence!");
9059 UB +=
C.addTempFile(
9064 CmdArgs.push_back(TCArgs.MakeArgString(UB));
9068 C.addCommand(std::make_unique<Command>(
9071 CmdArgs, std::nullopt, Output));
9076 const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
9077 const char *LinkingOutput)
const {
9079 auto &UA = cast<OffloadUnbundlingJobAction>(JA);
9090 ArgStringList CmdArgs;
9092 assert(Inputs.size() == 1 &&
"Expecting to unbundle a single file!");
9096 CmdArgs.push_back(TCArgs.MakeArgString(
9101 Triples +=
"-targets=";
9102 auto DepInfo = UA.getDependentActionsInfo();
9103 for (
unsigned I = 0; I < DepInfo.size(); ++I) {
9107 auto &Dep = DepInfo[I];
9110 Triples += Dep.DependentToolChain->getTriple().normalize();
9113 !Dep.DependentBoundArch.empty()) {
9115 Triples += Dep.DependentBoundArch;
9119 StringRef GPUArchName;
9122 for (
unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
9123 StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
9124 auto Arch = ArchStr.starts_with_insensitive(
"-march=");
9126 GPUArchName = ArchStr.substr(7);
9131 Triples += GPUArchName.str();
9135 CmdArgs.push_back(TCArgs.MakeArgString(Triples));
9139 TCArgs.MakeArgString(Twine(
"-input=") + Input.
getFilename()));
9142 for (
unsigned I = 0; I < Outputs.size(); ++I) {
9145 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
9146 CmdArgs.push_back(TCArgs.MakeArgString(UB));
9148 CmdArgs.push_back(
"-unbundle");
9149 CmdArgs.push_back(
"-allow-missing-bundles");
9150 if (TCArgs.hasArg(options::OPT_v))
9151 CmdArgs.push_back(
"-verbose");
9154 C.addCommand(std::make_unique<Command>(
9157 CmdArgs, std::nullopt, Outputs));
9163 const llvm::opt::ArgList &Args,
9164 const char *LinkingOutput)
const {
9165 ArgStringList CmdArgs;
9168 assert(Output.
isFilename() &&
"Invalid output.");
9169 CmdArgs.push_back(
"-o");
9176 const ArgList &TCArgs =
9182 : TCArgs.getLastArgValue(options::OPT_march_EQ);
9186 ArgStringList Features;
9190 llvm::copy_if(Features, std::back_inserter(FeatureArgs),
9191 [](StringRef Arg) {
return !Arg.starts_with(
"-target"); });
9196 "file=" +
File.str(),
9198 "arch=" + Arch.str(),
9199 "kind=" + Kind.str(),
9203 for (StringRef Feature : FeatureArgs)
9204 Parts.emplace_back(
"feature=" + Feature.str());
9206 CmdArgs.push_back(Args.MakeArgString(
"--image=" + llvm::join(Parts,
",")));
9209 C.addCommand(std::make_unique<Command>(
9212 CmdArgs, Inputs, Output));
9218 const ArgList &Args,
9219 const char *LinkingOutput)
const {
9222 ArgStringList CmdArgs;
9226 auto TCRange =
C.getOffloadToolChains(Kind);
9227 for (
auto &I : llvm::make_range(TCRange)) {
9231 if (CudaInstallation.
isValid())
9232 CmdArgs.push_back(Args.MakeArgString(
9240 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
9242 if (A->getOption().matches(options::OPT_O4) ||
9243 A->getOption().matches(options::OPT_Ofast))
9245 else if (A->getOption().matches(options::OPT_O)) {
9246 OOpt = A->getValue();
9249 else if (OOpt ==
"s" || OOpt ==
"z")
9251 }
else if (A->getOption().matches(options::OPT_O0))
9254 CmdArgs.push_back(Args.MakeArgString(Twine(
"--opt-level=O") + OOpt));
9258 Args.MakeArgString(
"--host-triple=" + TheTriple.getTriple()));
9259 if (Args.hasArg(options::OPT_v))
9260 CmdArgs.push_back(
"--wrapper-verbose");
9262 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
9263 if (!A->getOption().matches(options::OPT_g0))
9264 CmdArgs.push_back(
"--device-debug");
9269 if (
const Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
9270 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
9271 CmdArgs.push_back(Args.MakeArgString(
9272 Twine(
"--amdhsa-code-object-version=") + A->getValue()));
9275 for (
const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
9276 CmdArgs.push_back(Args.MakeArgString(
"--ptxas-arg=" + A));
9279 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
9280 CmdArgs.push_back(Args.MakeArgString(Twine(
"--offload-opt=-pass-remarks=") +
9282 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
9283 CmdArgs.push_back(Args.MakeArgString(
9284 Twine(
"--offload-opt=-pass-remarks-missed=") + A->getValue()));
9285 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
9286 CmdArgs.push_back(Args.MakeArgString(
9287 Twine(
"--offload-opt=-pass-remarks-analysis=") + A->getValue()));
9289 if (Args.getLastArg(options::OPT_ftime_report))
9290 CmdArgs.push_back(
"--device-compiler=-ftime-report");
9292 if (Args.getLastArg(options::OPT_save_temps_EQ))
9293 CmdArgs.push_back(
"--save-temps");
9296 Linker->
ConstructJob(
C, JA, Output, Inputs, Args, LinkingOutput);
9297 const auto &LinkCommand =
C.getJobs().getJobs().back();
9300 for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) {
9301 StringRef Val = A->getValue(0);
9304 Args.MakeArgString(Twine(
"--device-linker=") + A->getValue(1)));
9306 CmdArgs.push_back(Args.MakeArgString(
9307 "--device-linker=" +
9311 Args.ClaimAllArgs(options::OPT_Xoffload_linker);
9314 if (Args.hasFlag(options::OPT_fopenmp_target_jit,
9315 options::OPT_fno_openmp_target_jit,
false))
9316 CmdArgs.push_back(
"--embed-bitcode");
9319 for (Arg *A : Args.filtered(options::OPT_mllvm)) {
9320 CmdArgs.push_back(
"-mllvm");
9321 CmdArgs.push_back(A->getValue());
9326 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r, options::OPT_nogpulib,
9327 options::OPT_nodefaultlibs, options::OPT_nolibc,
9328 options::OPT_nogpulibc)) {
9336 CmdArgs.push_back(Args.MakeArgString(
9338 CmdArgs.push_back(Args.MakeArgString(
9346 "-lclang_rt.builtins"));
9352 if (!Args.hasFlag(options::OPT_gpulibc, options::OPT_nogpulibc,
true))
9353 CmdArgs.push_back(
"--device-compiler=-nolibc");
9356 CmdArgs.push_back(Args.MakeArgString(Twine(
"--linker-path=") +
9357 LinkCommand->getExecutable()));
9358 for (
const char *LinkArg : LinkCommand->getArguments())
9359 CmdArgs.push_back(LinkArg);
9364 Args.MakeArgString(
getToolChain().GetProgramPath(
"clang-linker-wrapper"));
9368 LinkCommand->replaceExecutable(Exec);
9369 LinkCommand->replaceArguments(CmdArgs);
static StringRef bytes(const std::vector< T, Allocator > &v)
static std::string ComplexRangeKindToStr(LangOptions::ComplexRangeKind Range)
static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
The -mprefer-vector-width option accepts either a positive integer or the string "none".
static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC)
static bool checkDebugInfoOption(const Arg *A, const ArgList &Args, const Driver &D, const ToolChain &TC)
static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs, types::ID InputType)
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, ArgStringList &CmdArgs)
static std::string RenderComplexRangeOption(LangOptions::ComplexRangeKind Range)
static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind, unsigned DwarfVersion, llvm::DebuggerKind DebuggerTuning)
static void ProcessVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static void renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, bool IRInput, ArgStringList &CmdArgs, const InputInfo &Output, llvm::codegenoptions::DebugInfoKind &DebugInfoKind, DwarfFissionKind &DwarfFission)
static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec)
Vectorize at all optimization levels greater than 1 except for -Oz.
static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
static bool maybeHasClangPchSignature(const Driver &D, StringRef Path)
static bool addExceptionArgs(const ArgList &Args, types::ID InputType, const ToolChain &TC, bool KernelOrKext, const ObjCRuntime &objcRuntime, ArgStringList &CmdArgs)
Adds exception related arguments to the driver command arguments.
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args)
void AddAAPCSVolatileBitfieldArgs(const ArgList &Args, ArgStringList &CmdArgs)
static bool isSignedCharDefault(const llvm::Triple &Triple)
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args, bool isWindowsMSVC)
/EH controls whether to run destructor cleanups when exceptions are thrown.
static bool gchProbe(const Driver &D, StringRef Path)
static void RenderOpenACCOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs, types::ID InputType)
static void EmitComplexRangeDiag(const Driver &D, std::string str1, std::string str2)
static bool CheckARMImplicitITArg(StringRef Value)
static bool hasMultipleInvocations(const llvm::Triple &Triple, const ArgList &Args)
static void handleAMDGPUCodeObjectVersionOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs, bool IsCC1As=false)
static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
static void ParseMRecip(const Driver &D, const ArgList &Args, ArgStringList &OutStrings)
The -mrecip flag requires processing of many optional parameters.
static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs, types::ID InputType)
static void renderDwarfFormat(const Driver &D, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs, unsigned DwarfVersion)
static void RenderObjCOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, ObjCRuntime &Runtime, bool InferCovariantReturns, const InputInfo &Input, ArgStringList &CmdArgs)
static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the coverage file path prefix map.
static void AddARMImplicitITArgs(const ArgList &Args, ArgStringList &CmdArgs, StringRef Value)
static bool checkRemarksOptions(const Driver &D, const ArgList &Args, const llvm::Triple &Triple)
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
static bool RenderModulesOptions(Compilation &C, const Driver &D, const ArgList &Args, const InputInfo &Input, const InputInfo &Output, bool HaveStd20, ArgStringList &CmdArgs)
static void forAllAssociatedToolChains(Compilation &C, const JobAction &JA, const ToolChain &RegularToolChain, llvm::function_ref< void(const ToolChain &)> Work)
Apply Work on the current tool chain RegularToolChain and any other offloading tool chain that is ass...
static bool isValidSymbolName(StringRef S)
static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the macro file path prefix map.
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
static std::string ComplexArithmeticStr(LangOptions::ComplexRangeKind Range)
static void addDebugObjectName(const ArgList &Args, ArgStringList &CmdArgs, const char *DebugCompilationDir, const char *OutputFileName)
static bool getRefinementStep(StringRef In, const Driver &D, const Arg &A, size_t &Position)
This is a helper function for validating the optional refinement step parameter in reciprocal argumen...
static void CollectARMPACBTIOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool isAArch64)
static void RenderSSPOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext)
static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs)
static void RenderSCPOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static void RenderTrivialAutoVarInitOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static bool maybeConsumeDash(const std::string &EH, size_t &I)
static const char * addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs, const llvm::vfs::FileSystem &VFS)
Add a CC1 option to specify the debug compilation directory.
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args)
static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC, const JobAction &JA)
static void 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)
static void handlePAuthABI(const ArgList &DriverArgs, ArgStringList &CC1Args)
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.
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...
static bool getDefaultModuleCachePath(SmallVectorImpl< char > &Result)
Compute the default -fmodule-cache-path.
const char * getClangProgramPath() const
Get the path to the main clang executable.
DiagnosticBuilder Diag(unsigned DiagID) const
bool isUsingOffloadLTO() const
Returns true if we are performing any kind of offload LTO.
llvm::vfs::FileSystem & getVFS() const
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
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.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
void quoteMakeTarget(StringRef Target, SmallVectorImpl< char > &Res)
Quote target names for inclusion in GNU Make dependency files.
const char * headerIncludeFormatKindToString(HeaderIncludeFormatKind K)
const char * headerIncludeFilteringKindToString(HeaderIncludeFilteringKind K)
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ Result
The result type of a method or function.
const char * CudaVersionToString(CudaVersion V)
const FunctionProtoType * T
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
static constexpr ResponseFileSupport AtFileUTF8()