35#include "clang/Config/config.h"
44#include "llvm/ADT/SmallSet.h"
45#include "llvm/ADT/StringExtras.h"
46#include "llvm/Config/llvm-config.h"
47#include "llvm/Option/ArgList.h"
48#include "llvm/Support/CodeGen.h"
49#include "llvm/Support/Compiler.h"
50#include "llvm/Support/Compression.h"
51#include "llvm/Support/Error.h"
52#include "llvm/Support/FileSystem.h"
53#include "llvm/Support/Path.h"
54#include "llvm/Support/Process.h"
55#include "llvm/Support/RISCVISAInfo.h"
56#include "llvm/Support/YAMLParser.h"
57#include "llvm/TargetParser/ARMTargetParserCommon.h"
58#include "llvm/TargetParser/Host.h"
59#include "llvm/TargetParser/LoongArchTargetParser.h"
60#include "llvm/TargetParser/RISCVTargetParser.h"
69 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
70 options::OPT_fminimize_whitespace,
71 options::OPT_fno_minimize_whitespace)) {
72 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
73 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
74 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
75 << A->getBaseArg().getAsString(Args)
76 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
83 if (Args.hasArg(options::OPT_static))
85 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
86 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
113 llvm::function_ref<
void(
const ToolChain &)> Work) {
115 Work(RegularToolChain);
130 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
145 const Arg &A,
size_t &Position) {
146 const char RefinementStepToken =
':';
147 Position = In.find(RefinementStepToken);
148 if (Position != StringRef::npos) {
149 StringRef Option = A.getOption().getName();
150 StringRef RefStep = In.substr(Position + 1);
158 if (RefStep.size() != 1) {
159 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
162 char RefStepChar = RefStep[0];
163 if (RefStepChar <
'0' || RefStepChar >
'9') {
164 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
173 ArgStringList &OutStrings) {
174 StringRef DisabledPrefixIn =
"!";
175 StringRef DisabledPrefixOut =
"!";
176 StringRef EnabledPrefixOut =
"";
177 StringRef Out =
"-mrecip=";
179 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
183 unsigned NumOptions = A->getNumValues();
184 if (NumOptions == 0) {
186 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
191 if (NumOptions == 1) {
192 StringRef Val = A->getValue(0);
196 StringRef ValBase = Val.slice(0, RefStepLoc);
197 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
198 OutStrings.push_back(Args.MakeArgString(Out + Val));
207 llvm::StringMap<bool> OptionStrings;
208 OptionStrings.insert(std::make_pair(
"divd",
false));
209 OptionStrings.insert(std::make_pair(
"divf",
false));
210 OptionStrings.insert(std::make_pair(
"divh",
false));
211 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
212 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
213 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
214 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
215 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
216 OptionStrings.insert(std::make_pair(
"sqrth",
false));
217 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
218 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
219 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
221 for (
unsigned i = 0; i != NumOptions; ++i) {
222 StringRef Val = A->getValue(i);
224 bool IsDisabled = Val.startswith(DisabledPrefixIn);
233 StringRef ValBase = Val.slice(0, RefStep);
234 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
235 if (OptionIter == OptionStrings.end()) {
237 OptionIter = OptionStrings.find(ValBase.str() +
'f');
238 if (OptionIter == OptionStrings.end()) {
240 D.
Diag(diag::err_drv_unknown_argument) << Val;
246 if (OptionStrings[ValBase.str() +
'd'] ||
247 OptionStrings[ValBase.str() +
'h']) {
248 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
253 if (OptionIter->second ==
true) {
255 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
260 OptionIter->second =
true;
264 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
265 OptionStrings[ValBase.str() +
'd'] =
true;
266 OptionStrings[ValBase.str() +
'h'] =
true;
270 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
271 Out = Args.MakeArgString(Out + Prefix + Val);
272 if (i != NumOptions - 1)
273 Out = Args.MakeArgString(Out +
",");
276 OutStrings.push_back(Args.MakeArgString(Out));
282 ArgStringList &CmdArgs) {
283 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
287 StringRef
Value = A->getValue();
288 if (
Value ==
"none") {
289 CmdArgs.push_back(
"-mprefer-vector-width=none");
292 if (
Value.getAsInteger(10, Width)) {
293 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
296 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
302 const llvm::Triple &Triple) {
309 if (!Triple.isMacOSX())
312 return (!Triple.isMacOSXVersionLT(10, 5) &&
313 (Triple.getArch() == llvm::Triple::x86_64 ||
314 Triple.getArch() == llvm::Triple::arm));
324 ArgStringList &CmdArgs) {
325 const llvm::Triple &Triple = TC.
getTriple();
330 Args.ClaimAllArgs(options::OPT_fexceptions);
331 Args.ClaimAllArgs(options::OPT_fno_exceptions);
332 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
333 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
334 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
335 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
336 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
337 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
342 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
345 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
346 options::OPT_fno_async_exceptions,
false);
348 CmdArgs.push_back(
"-fasync-exceptions");
355 Args.hasFlag(options::OPT_fobjc_exceptions,
356 options::OPT_fno_objc_exceptions,
true)) {
357 CmdArgs.push_back(
"-fobjc-exceptions");
364 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
365 !Triple.isPS() && !Triple.isDriverKit();
366 Arg *ExceptionArg = Args.getLastArg(
367 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
368 options::OPT_fexceptions, options::OPT_fno_exceptions);
370 CXXExceptionsEnabled =
371 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
372 ExceptionArg->getOption().matches(options::OPT_fexceptions);
374 if (CXXExceptionsEnabled) {
375 CmdArgs.push_back(
"-fcxx-exceptions");
384 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
387 CmdArgs.push_back(
"-fexceptions");
403 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
408 switch (Triple.getArch()){
411 case llvm::Triple::arm:
412 case llvm::Triple::thumb:
415 return Triple.isOSDarwin();
420 const llvm::Triple &Triple) {
421 if (Args.hasArg(options::OPT_pg) && !Args.hasArg(options::OPT_mfentry))
424 if (Triple.isAndroid()) {
425 switch (Triple.getArch()) {
426 case llvm::Triple::aarch64:
427 case llvm::Triple::arm:
428 case llvm::Triple::armeb:
429 case llvm::Triple::thumb:
430 case llvm::Triple::thumbeb:
431 case llvm::Triple::riscv64:
438 switch (Triple.getArch()) {
439 case llvm::Triple::xcore:
440 case llvm::Triple::wasm32:
441 case llvm::Triple::wasm64:
442 case llvm::Triple::msp430:
446 case llvm::Triple::ppc:
447 case llvm::Triple::ppcle:
448 case llvm::Triple::ppc64:
449 case llvm::Triple::ppc64le:
450 case llvm::Triple::riscv32:
451 case llvm::Triple::riscv64:
452 case llvm::Triple::sparc:
453 case llvm::Triple::sparcel:
454 case llvm::Triple::sparcv9:
455 case llvm::Triple::amdgcn:
456 case llvm::Triple::r600:
457 case llvm::Triple::csky:
458 case llvm::Triple::loongarch32:
459 case llvm::Triple::loongarch64:
465 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
469 if (Triple.isOSLinux() || Triple.isOSHurd()) {
470 switch (Triple.getArch()) {
472 case llvm::Triple::arm:
473 case llvm::Triple::armeb:
474 case llvm::Triple::thumb:
475 case llvm::Triple::thumbeb:
476 case llvm::Triple::mips64:
477 case llvm::Triple::mips64el:
478 case llvm::Triple::mips:
479 case llvm::Triple::mipsel:
480 case llvm::Triple::systemz:
481 case llvm::Triple::x86:
482 case llvm::Triple::x86_64:
489 if (Triple.isOSWindows()) {
490 switch (Triple.getArch()) {
491 case llvm::Triple::x86:
493 case llvm::Triple::x86_64:
494 return Triple.isOSBinFormatMachO();
495 case llvm::Triple::arm:
496 case llvm::Triple::thumb:
521 Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
522 options::OPT_fno_omit_frame_pointer);
523 bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer);
525 A && A->getOption().matches(options::OPT_fno_omit_frame_pointer);
527 Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
528 options::OPT_mno_omit_leaf_frame_pointer,
529 Triple.isAArch64() || Triple.isPS() || Triple.isVE() ||
530 (Triple.isAndroid() && Triple.isRISCV64()));
534 return CodeGenOptions::FramePointerKind::NonLeaf;
535 return CodeGenOptions::FramePointerKind::All;
537 return CodeGenOptions::FramePointerKind::None;
542 ArgStringList &CmdArgs,
543 const llvm::vfs::FileSystem &VFS) {
544 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
545 options::OPT_fdebug_compilation_dir_EQ)) {
546 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
547 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fdebug-compilation-dir=") +
550 A->render(Args, CmdArgs);
551 }
else if (llvm::ErrorOr<std::string> CWD =
552 VFS.getCurrentWorkingDirectory()) {
553 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-compilation-dir=" + *CWD));
555 StringRef Path(CmdArgs.back());
556 return Path.substr(Path.find(
'=') + 1).data();
560 const char *DebugCompilationDir,
561 const char *OutputFileName) {
563 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
564 if (StringRef(Arg->getValue()).startswith(
"-object-file-name"))
567 if (Args.hasArg(options::OPT_object_file_name_EQ))
571 if (ObjFileNameForDebug !=
"-" &&
572 !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&
573 (!DebugCompilationDir ||
574 llvm::sys::path::is_absolute(DebugCompilationDir))) {
576 llvm::sys::fs::make_absolute(ObjFileNameForDebug);
582 llvm::sys::path::Style Style =
583 llvm::sys::path::is_absolute(ObjFileNameForDebug)
584 ? llvm::sys::path::Style::native
585 : llvm::sys::path::Style::windows_backslash;
586 llvm::sys::path::remove_dots(ObjFileNameForDebug,
true,
589 Args.MakeArgString(Twine(
"-object-file-name=") + ObjFileNameForDebug));
594 const ArgList &Args, ArgStringList &CmdArgs) {
595 auto AddOneArg = [&](StringRef Map, StringRef Name) {
596 if (!Map.contains(
'='))
597 D.
Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;
599 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
602 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
603 options::OPT_fdebug_prefix_map_EQ)) {
604 AddOneArg(A->getValue(), A->getOption().getName());
608 if (GlobalRemapEntry.empty())
610 AddOneArg(GlobalRemapEntry,
"environment");
615 ArgStringList &CmdArgs) {
616 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
617 options::OPT_fmacro_prefix_map_EQ)) {
618 StringRef Map = A->getValue();
619 if (!Map.contains(
'='))
620 D.
Diag(diag::err_drv_invalid_argument_to_option)
621 << Map << A->getOption().getName();
623 CmdArgs.push_back(Args.MakeArgString(
"-fmacro-prefix-map=" + Map));
630 ArgStringList &CmdArgs) {
631 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
632 options::OPT_fcoverage_prefix_map_EQ)) {
633 StringRef Map = A->getValue();
634 if (!Map.contains(
'='))
635 D.
Diag(diag::err_drv_invalid_argument_to_option)
636 << Map << A->getOption().getName();
638 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-prefix-map=" + Map));
647 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
648 if (A->getOption().matches(options::OPT_O4) ||
649 A->getOption().matches(options::OPT_Ofast))
652 if (A->getOption().matches(options::OPT_O0))
655 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
658 StringRef S(A->getValue());
666 unsigned OptLevel = 0;
667 if (S.getAsInteger(10, OptLevel))
678 ArgStringList &CmdArgs) {
681 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
684 CmdArgs.push_back(
"-x");
685 if (Args.hasArg(options::OPT_rewrite_objc))
691 const char *ClangType;
693 case types::TY_CXXModule:
696 case types::TY_PP_CXXModule:
697 ClangType =
"c++-cpp-output";
703 CmdArgs.push_back(ClangType);
710 ArgStringList &CmdArgs) {
712 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
713 options::OPT_fprofile_generate_EQ,
714 options::OPT_fno_profile_generate);
715 if (PGOGenerateArg &&
716 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
717 PGOGenerateArg =
nullptr;
721 auto *ProfileGenerateArg = Args.getLastArg(
722 options::OPT_fprofile_instr_generate,
723 options::OPT_fprofile_instr_generate_EQ,
724 options::OPT_fno_profile_instr_generate);
725 if (ProfileGenerateArg &&
726 ProfileGenerateArg->getOption().matches(
727 options::OPT_fno_profile_instr_generate))
728 ProfileGenerateArg =
nullptr;
730 if (PGOGenerateArg && ProfileGenerateArg)
731 D.
Diag(diag::err_drv_argument_not_allowed_with)
732 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
736 if (PGOGenerateArg && ProfileUseArg)
737 D.
Diag(diag::err_drv_argument_not_allowed_with)
738 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
740 if (ProfileGenerateArg && ProfileUseArg)
741 D.
Diag(diag::err_drv_argument_not_allowed_with)
742 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
744 if (CSPGOGenerateArg && PGOGenerateArg) {
745 D.
Diag(diag::err_drv_argument_not_allowed_with)
746 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
747 PGOGenerateArg =
nullptr;
752 D.
Diag(diag::err_drv_unsupported_opt_for_target)
753 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
756 if (ProfileGenerateArg) {
757 if (ProfileGenerateArg->getOption().matches(
758 options::OPT_fprofile_instr_generate_EQ))
759 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
760 ProfileGenerateArg->getValue()));
762 CmdArgs.push_back(
"-fprofile-instrument=clang");
763 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
765 CmdArgs.push_back(Args.MakeArgString(
770 Arg *PGOGenArg =
nullptr;
771 if (PGOGenerateArg) {
772 assert(!CSPGOGenerateArg);
773 PGOGenArg = PGOGenerateArg;
774 CmdArgs.push_back(
"-fprofile-instrument=llvm");
776 if (CSPGOGenerateArg) {
777 assert(!PGOGenerateArg);
778 PGOGenArg = CSPGOGenerateArg;
779 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
782 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
784 CmdArgs.push_back(Args.MakeArgString(
787 if (PGOGenArg->getOption().matches(
788 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
789 : options::OPT_fcs_profile_generate_EQ)) {
791 llvm::sys::path::append(Path,
"default_%m.profraw");
793 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
798 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
799 CmdArgs.push_back(Args.MakeArgString(
800 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
801 else if ((ProfileUseArg->getOption().matches(
802 options::OPT_fprofile_use_EQ) ||
803 ProfileUseArg->getOption().matches(
804 options::OPT_fprofile_instr_use))) {
806 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
807 if (Path.empty() || llvm::sys::fs::is_directory(Path))
808 llvm::sys::path::append(Path,
"default.profdata");
810 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
814 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
815 options::OPT_fno_test_coverage,
false) ||
816 Args.hasArg(options::OPT_coverage);
819 if (Args.hasFlag(options::OPT_fcoverage_mapping,
820 options::OPT_fno_coverage_mapping,
false)) {
821 if (!ProfileGenerateArg)
822 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
823 <<
"-fcoverage-mapping"
824 <<
"-fprofile-instr-generate";
826 CmdArgs.push_back(
"-fcoverage-mapping");
829 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
830 options::OPT_fcoverage_compilation_dir_EQ)) {
831 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
832 CmdArgs.push_back(Args.MakeArgString(
833 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
835 A->render(Args, CmdArgs);
836 }
else if (llvm::ErrorOr<std::string> CWD =
837 D.
getVFS().getCurrentWorkingDirectory()) {
838 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
841 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
842 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
843 if (!Args.hasArg(options::OPT_coverage))
844 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
845 <<
"-fprofile-exclude-files="
848 StringRef
v = Arg->getValue();
850 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
853 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
854 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
855 if (!Args.hasArg(options::OPT_coverage))
856 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
857 <<
"-fprofile-filter-files="
860 StringRef
v = Arg->getValue();
861 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
864 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
865 StringRef Val = A->getValue();
866 if (Val ==
"atomic" || Val ==
"prefer-atomic")
867 CmdArgs.push_back(
"-fprofile-update=atomic");
868 else if (Val !=
"single")
869 D.
Diag(diag::err_drv_unsupported_option_argument)
870 << A->getSpelling() << Val;
873 int FunctionGroups = 1;
874 int SelectedFunctionGroup = 0;
875 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
876 StringRef Val = A->getValue();
877 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
878 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
881 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
882 StringRef Val = A->getValue();
883 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
884 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
885 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
887 if (FunctionGroups != 1)
888 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
889 Twine(FunctionGroups)));
890 if (SelectedFunctionGroup != 0)
891 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
892 Twine(SelectedFunctionGroup)));
898 Arg *FProfileDir =
nullptr;
899 if (Args.hasArg(options::OPT_fprofile_arcs) ||
900 Args.hasArg(options::OPT_coverage))
901 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
905 (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
910 if (EmitCovNotes || EmitCovData) {
912 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
915 CoverageFilename = DumpDir->getValue();
916 CoverageFilename += llvm::sys::path::filename(Output.
getBaseInput());
917 }
else if (Arg *FinalOutput =
918 C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
919 CoverageFilename = FinalOutput->getValue();
920 }
else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o)) {
921 CoverageFilename = FinalOutput->getValue();
923 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
925 if (llvm::sys::path::is_relative(CoverageFilename))
926 (void)D.
getVFS().makeAbsolute(CoverageFilename);
927 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
930 Args.MakeArgString(
"-coverage-notes-file=" + CoverageFilename));
936 CoverageFilename = FProfileDir->getValue();
937 llvm::sys::path::append(CoverageFilename, Gcno);
939 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
941 Args.MakeArgString(
"-coverage-data-file=" + CoverageFilename));
948 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
957 bool RelaxDefault =
true;
959 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
960 RelaxDefault = A->getOption().matches(options::OPT_O0);
963 RelaxDefault =
false;
964 for (
const auto &Act :
C.getActions()) {
972 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
978 llvm::codegenoptions::DebugInfoKind DebugInfoKind,
979 unsigned DwarfVersion,
980 llvm::DebuggerKind DebuggerTuning) {
982 if (DwarfVersion > 0)
984 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
985 switch (DebuggerTuning) {
986 case llvm::DebuggerKind::GDB:
987 CmdArgs.push_back(
"-debugger-tuning=gdb");
989 case llvm::DebuggerKind::LLDB:
990 CmdArgs.push_back(
"-debugger-tuning=lldb");
992 case llvm::DebuggerKind::SCE:
993 CmdArgs.push_back(
"-debugger-tuning=sce");
995 case llvm::DebuggerKind::DBX:
996 CmdArgs.push_back(
"-debugger-tuning=dbx");
1005 assert(A &&
"Expected non-nullptr argument.");
1008 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
1014 ArgStringList &CmdArgs,
1017 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
1021 StringRef
Value = A->getValue();
1022 if (
Value ==
"none") {
1023 CmdArgs.push_back(
"--compress-debug-sections=none");
1024 }
else if (
Value ==
"zlib") {
1025 if (llvm::compression::zlib::isAvailable()) {
1027 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1029 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
1031 }
else if (
Value ==
"zstd") {
1032 if (llvm::compression::zstd::isAvailable()) {
1034 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1036 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
1039 D.
Diag(diag::err_drv_unsupported_option_argument)
1040 << A->getSpelling() <<
Value;
1046 const ArgList &Args,
1047 ArgStringList &CmdArgs,
1048 bool IsCC1As =
false) {
1056 CmdArgs.insert(CmdArgs.begin() + 1,
1057 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
1058 Twine(CodeObjVer)));
1059 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
1062 CmdArgs.insert(CmdArgs.begin() + 1,
1063 Args.MakeArgString(Twine(
"-mcode-object-version=") +
1064 Twine(CodeObjVer)));
1069 const Driver &D,
const ArgList &Args,
1070 ArgStringList &CmdArgs,
1077 Args.AddLastArg(CmdArgs, options::OPT_C);
1078 Args.AddLastArg(CmdArgs, options::OPT_CC);
1081 Arg *ArgM = Args.getLastArg(options::OPT_MM);
1083 ArgM = Args.getLastArg(options::OPT_M);
1084 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1086 ArgMD = Args.getLastArg(options::OPT_MD);
1090 CmdArgs.push_back(
"-w");
1096 const char *DepFile;
1097 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1098 DepFile = MF->getValue();
1099 C.addFailureResultFile(DepFile, &JA);
1100 }
else if (Output.
getType() == types::TY_Dependencies) {
1102 }
else if (!ArgMD) {
1106 C.addFailureResultFile(DepFile, &JA);
1108 CmdArgs.push_back(
"-dependency-file");
1109 CmdArgs.push_back(DepFile);
1111 bool HasTarget =
false;
1112 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1115 if (A->getOption().matches(options::OPT_MT)) {
1116 A->render(Args, CmdArgs);
1118 CmdArgs.push_back(
"-MT");
1121 CmdArgs.push_back(Args.MakeArgString(Quoted));
1127 const char *DepTarget;
1131 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1132 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1133 DepTarget = OutputOpt->getValue();
1139 llvm::sys::path::replace_extension(
P,
"o");
1140 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1143 CmdArgs.push_back(
"-MT");
1146 CmdArgs.push_back(Args.MakeArgString(Quoted));
1149 if (ArgM->getOption().matches(options::OPT_M) ||
1150 ArgM->getOption().matches(options::OPT_MD))
1151 CmdArgs.push_back(
"-sys-header-deps");
1152 if (Args.hasFlag(options::OPT_canonical_prefixes,
1153 options::OPT_no_canonical_prefixes,
true))
1154 CmdArgs.push_back(
"-canonical-system-headers");
1155 if ((isa<PrecompileJobAction>(JA) &&
1156 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1157 Args.hasArg(options::OPT_fmodule_file_deps))
1158 CmdArgs.push_back(
"-module-file-deps");
1161 if (Args.hasArg(options::OPT_MG)) {
1162 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1163 ArgM->getOption().matches(options::OPT_MMD))
1164 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1165 CmdArgs.push_back(
"-MG");
1168 Args.AddLastArg(CmdArgs, options::OPT_MP);
1169 Args.AddLastArg(CmdArgs, options::OPT_MV);
1182 if (!Args.hasArg(options::OPT_nostdinc) &&
1183 !Args.hasArg(options::OPT_nogpuinc) &&
1184 !Args.hasArg(options::OPT_nobuiltininc)) {
1192 llvm::sys::path::append(
P,
"include");
1193 llvm::sys::path::append(
P,
"gpu-none-llvm");
1194 CmdArgs.push_back(
"-c-isystem");
1195 CmdArgs.push_back(Args.MakeArgString(
P));
1200 llvm::sys::path::append(
P,
"include");
1201 llvm::sys::path::append(
P,
"llvm_libc_wrappers");
1202 CmdArgs.push_back(
"-internal-isystem");
1203 CmdArgs.push_back(Args.MakeArgString(
P));
1210 !Args.hasArg(options::OPT_nostdinc) &&
1211 !Args.hasArg(options::OPT_nogpuinc) &&
1214 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1218 llvm::sys::path::append(
P,
"include");
1219 llvm::sys::path::append(
P,
"openmp_wrappers");
1220 CmdArgs.push_back(
"-internal-isystem");
1221 CmdArgs.push_back(Args.MakeArgString(
P));
1224 CmdArgs.push_back(
"-include");
1225 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1235 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1236 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1239 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1242 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1243 options::OPT_fno_pch_instantiate_templates,
true))
1244 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1246 if (YcArg || YuArg) {
1247 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1248 if (!isa<PrecompileJobAction>(JA)) {
1249 CmdArgs.push_back(
"-include-pch");
1251 C, !ThroughHeader.empty()
1253 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1256 if (ThroughHeader.empty()) {
1257 CmdArgs.push_back(Args.MakeArgString(
1258 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1261 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1266 bool RenderedImplicitInclude =
false;
1267 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1268 if (A->getOption().matches(options::OPT_include) &&
1271 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1272 RenderedImplicitInclude =
true;
1274 bool FoundPCH =
false;
1279 llvm::sys::path::replace_extension(
P,
"pch");
1284 llvm::sys::path::replace_extension(
P,
"gch");
1287 D.
Diag(diag::warn_drv_include_probe_gch) << A->getAsString(Args) <<
P;
1292 if (IsFirstImplicitInclude) {
1294 CmdArgs.push_back(
"-include-pch");
1295 CmdArgs.push_back(Args.MakeArgString(
P));
1299 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1300 << A->getAsString(Args);
1303 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1310 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1313 }
else if (A->getOption().matches(options::OPT_ibuiltininc)) {
1320 A->render(Args, CmdArgs);
1323 Args.AddAllArgs(CmdArgs,
1324 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1325 options::OPT_F, options::OPT_index_header_map});
1333 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1334 options::OPT_Xpreprocessor);
1337 if (Arg *A = Args.getLastArg(options::OPT_I_))
1338 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1342 StringRef sysroot =
C.getSysRoot();
1343 if (sysroot !=
"") {
1344 if (!Args.hasArg(options::OPT_isysroot)) {
1345 CmdArgs.push_back(
"-isysroot");
1346 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1363 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1371 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1374 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1383 [&Args, &CmdArgs](
const ToolChain &TC) {
1394 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1395 options::OPT_fno_file_reproducible);
1397 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1398 CmdArgs.push_back(
"-source-date-epoch");
1399 CmdArgs.push_back(Args.MakeArgString(Epoch));
1405 switch (Triple.getArch()) {
1409 case llvm::Triple::aarch64:
1410 case llvm::Triple::aarch64_32:
1411 case llvm::Triple::aarch64_be:
1412 case llvm::Triple::arm:
1413 case llvm::Triple::armeb:
1414 case llvm::Triple::thumb:
1415 case llvm::Triple::thumbeb:
1416 if (Triple.isOSDarwin() || Triple.isOSWindows())
1420 case llvm::Triple::ppc:
1421 case llvm::Triple::ppc64:
1422 if (Triple.isOSDarwin())
1426 case llvm::Triple::hexagon:
1427 case llvm::Triple::ppcle:
1428 case llvm::Triple::ppc64le:
1429 case llvm::Triple::riscv32:
1430 case llvm::Triple::riscv64:
1431 case llvm::Triple::systemz:
1432 case llvm::Triple::xcore:
1438 const ArgList &Args) {
1441 if (!Triple.isOSDarwin())
1445 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1449 const llvm::Triple &Triple) {
1454 bool hasExplicitOutputFile =
1455 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1457 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1458 <<
"-foptimization-record-file";
1465 const llvm::Triple &Triple,
1468 StringRef Format =
"yaml";
1469 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1470 Format = A->getValue();
1472 CmdArgs.push_back(
"-opt-record-file");
1474 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1476 CmdArgs.push_back(A->getValue());
1478 bool hasMultipleArchs =
1479 Triple.isOSDarwin() &&
1480 Args.getAllArgValues(options::OPT_arch).size() > 1;
1484 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1485 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1486 F = FinalOutput->getValue();
1488 if (Format !=
"yaml" &&
1489 Triple.isOSDarwin() &&
1503 llvm::sys::path::replace_extension(F,
"");
1505 Triple.normalize());
1515 if (hasMultipleArchs) {
1519 llvm::sys::path::replace_extension(F,
"");
1522 F += Triple.getArchName();
1524 llvm::sys::path::replace_extension(F, OldExtension);
1528 Extension +=
"opt.";
1529 Extension += Format;
1531 llvm::sys::path::replace_extension(F, Extension);
1532 CmdArgs.push_back(Args.MakeArgString(F));
1536 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1537 CmdArgs.push_back(
"-opt-record-passes");
1538 CmdArgs.push_back(A->getValue());
1541 if (!Format.empty()) {
1542 CmdArgs.push_back(
"-opt-record-format");
1543 CmdArgs.push_back(Format.data());
1548 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1549 options::OPT_fno_aapcs_bitfield_width,
true))
1550 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1552 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1553 CmdArgs.push_back(
"-faapcs-bitfield-load");
1557void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1558 const ArgList &Args, ArgStringList &CmdArgs) {
1562 const char *ABIName =
nullptr;
1563 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1564 ABIName = A->getValue();
1566 std::string CPU =
getCPUName(D, Args, Triple,
false);
1567 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1570 CmdArgs.push_back(
"-target-abi");
1571 CmdArgs.push_back(ABIName);
1574void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1575 auto StrictAlignIter =
1576 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1577 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1579 if (StrictAlignIter != CmdArgs.rend() &&
1580 StringRef(*StrictAlignIter) ==
"+strict-align")
1581 CmdArgs.push_back(
"-Wunaligned-access");
1586 ArgStringList &CmdArgs,
bool isAArch64) {
1587 const Arg *A = isAArch64
1588 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1589 options::OPT_mbranch_protection_EQ)
1590 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1596 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1597 D.
Diag(diag::warn_incompatible_branch_protection_option)
1598 << Triple.getArchName();
1600 StringRef
Scope, Key;
1601 bool IndirectBranches;
1603 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1604 Scope = A->getValue();
1606 D.
Diag(diag::err_drv_unsupported_option_argument)
1607 << A->getSpelling() <<
Scope;
1609 IndirectBranches =
false;
1612 llvm::ARM::ParsedBranchProtection PBP;
1613 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg))
1614 D.
Diag(diag::err_drv_unsupported_option_argument)
1615 << A->getSpelling() << DiagMsg;
1616 if (!isAArch64 && PBP.Key ==
"b_key")
1617 D.
Diag(diag::warn_unsupported_branch_protection)
1618 <<
"b-key" << A->getAsString(Args);
1621 IndirectBranches = PBP.BranchTargetEnforcement;
1625 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1626 if (!
Scope.equals(
"none"))
1628 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1629 if (IndirectBranches)
1630 CmdArgs.push_back(
"-mbranch-target-enforce");
1633void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1634 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1635 RenderARMABI(
getToolChain().getDriver(), Triple, Args, CmdArgs);
1642 CmdArgs.push_back(
"-msoft-float");
1643 CmdArgs.push_back(
"-mfloat-abi");
1644 CmdArgs.push_back(
"soft");
1647 CmdArgs.push_back(
"-mfloat-abi");
1648 CmdArgs.push_back(
"soft");
1652 CmdArgs.push_back(
"-mfloat-abi");
1653 CmdArgs.push_back(
"hard");
1657 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1658 options::OPT_mno_global_merge)) {
1659 CmdArgs.push_back(
"-mllvm");
1660 if (A->getOption().matches(options::OPT_mno_global_merge))
1661 CmdArgs.push_back(
"-arm-global-merge=false");
1663 CmdArgs.push_back(
"-arm-global-merge=true");
1666 if (!Args.hasFlag(options::OPT_mimplicit_float,
1667 options::OPT_mno_implicit_float,
true))
1668 CmdArgs.push_back(
"-no-implicit-float");
1670 if (Args.getLastArg(options::OPT_mcmse))
1671 CmdArgs.push_back(
"-mcmse");
1678 AddUnalignedAccessWarning(CmdArgs);
1681void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1682 const ArgList &Args,
bool KernelOrKext,
1683 ArgStringList &CmdArgs)
const {
1694 case llvm::Triple::arm:
1695 case llvm::Triple::armeb:
1696 case llvm::Triple::thumb:
1697 case llvm::Triple::thumbeb:
1699 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1702 case llvm::Triple::aarch64:
1703 case llvm::Triple::aarch64_32:
1704 case llvm::Triple::aarch64_be:
1705 AddAArch64TargetArgs(Args, CmdArgs);
1708 case llvm::Triple::loongarch32:
1709 case llvm::Triple::loongarch64:
1710 AddLoongArchTargetArgs(Args, CmdArgs);
1713 case llvm::Triple::mips:
1714 case llvm::Triple::mipsel:
1715 case llvm::Triple::mips64:
1716 case llvm::Triple::mips64el:
1717 AddMIPSTargetArgs(Args, CmdArgs);
1720 case llvm::Triple::ppc:
1721 case llvm::Triple::ppcle:
1722 case llvm::Triple::ppc64:
1723 case llvm::Triple::ppc64le:
1724 AddPPCTargetArgs(Args, CmdArgs);
1727 case llvm::Triple::riscv32:
1728 case llvm::Triple::riscv64:
1729 AddRISCVTargetArgs(Args, CmdArgs);
1732 case llvm::Triple::sparc:
1733 case llvm::Triple::sparcel:
1734 case llvm::Triple::sparcv9:
1735 AddSparcTargetArgs(Args, CmdArgs);
1738 case llvm::Triple::systemz:
1739 AddSystemZTargetArgs(Args, CmdArgs);
1742 case llvm::Triple::x86:
1743 case llvm::Triple::x86_64:
1744 AddX86TargetArgs(Args, CmdArgs);
1747 case llvm::Triple::lanai:
1748 AddLanaiTargetArgs(Args, CmdArgs);
1751 case llvm::Triple::hexagon:
1752 AddHexagonTargetArgs(Args, CmdArgs);
1755 case llvm::Triple::wasm32:
1756 case llvm::Triple::wasm64:
1757 AddWebAssemblyTargetArgs(Args, CmdArgs);
1760 case llvm::Triple::ve:
1761 AddVETargetArgs(Args, CmdArgs);
1767void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1768 ArgStringList &CmdArgs) {
1769 const char *ABIName =
nullptr;
1770 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1771 ABIName = A->getValue();
1772 else if (Triple.isOSDarwin())
1773 ABIName =
"darwinpcs";
1777 CmdArgs.push_back(
"-target-abi");
1778 CmdArgs.push_back(ABIName);
1782void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1783 ArgStringList &CmdArgs)
const {
1786 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1787 Args.hasArg(options::OPT_mkernel) ||
1788 Args.hasArg(options::OPT_fapple_kext))
1789 CmdArgs.push_back(
"-disable-red-zone");
1791 if (!Args.hasFlag(options::OPT_mimplicit_float,
1792 options::OPT_mno_implicit_float,
true))
1793 CmdArgs.push_back(
"-no-implicit-float");
1795 RenderAArch64ABI(Triple, Args, CmdArgs);
1798 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1799 options::OPT_mno_global_merge)) {
1800 CmdArgs.push_back(
"-mllvm");
1801 if (A->getOption().matches(options::OPT_mno_global_merge))
1802 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1804 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1811 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1812 StringRef Val = A->getValue();
1814 if (Val.equals(
"128") || Val.equals(
"256") || Val.equals(
"512") ||
1815 Val.equals(
"1024") || Val.equals(
"2048") || Val.equals(
"128+") ||
1816 Val.equals(
"256+") || Val.equals(
"512+") || Val.equals(
"1024+") ||
1817 Val.equals(
"2048+")) {
1819 if (Val.endswith(
"+"))
1820 Val = Val.substr(0, Val.size() - 1);
1823 assert(!
Invalid &&
"Failed to parse value");
1825 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1829 assert(!
Invalid &&
"Failed to parse value");
1831 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1833 }
else if (!Val.equals(
"scalable"))
1835 D.
Diag(diag::err_drv_unsupported_option_argument)
1836 << A->getSpelling() << Val;
1841 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1842 CmdArgs.push_back(
"-tune-cpu");
1843 if (strcmp(A->getValue(),
"native") == 0)
1844 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1846 CmdArgs.push_back(A->getValue());
1849 AddUnalignedAccessWarning(CmdArgs);
1852void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1853 ArgStringList &CmdArgs)
const {
1856 CmdArgs.push_back(
"-target-abi");
1862 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1863 std::string TuneCPU = A->getValue();
1865 CmdArgs.push_back(
"-tune-cpu");
1866 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1870void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1871 ArgStringList &CmdArgs)
const {
1878 CmdArgs.push_back(
"-target-abi");
1879 CmdArgs.push_back(ABIName.data());
1884 CmdArgs.push_back(
"-msoft-float");
1885 CmdArgs.push_back(
"-mfloat-abi");
1886 CmdArgs.push_back(
"soft");
1890 CmdArgs.push_back(
"-mfloat-abi");
1891 CmdArgs.push_back(
"hard");
1894 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1895 options::OPT_mno_ldc1_sdc1)) {
1896 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1897 CmdArgs.push_back(
"-mllvm");
1898 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1902 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1903 options::OPT_mno_check_zero_division)) {
1904 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1905 CmdArgs.push_back(
"-mllvm");
1906 CmdArgs.push_back(
"-mno-check-zero-division");
1910 if (Args.getLastArg(options::OPT_mfix4300)) {
1911 CmdArgs.push_back(
"-mllvm");
1912 CmdArgs.push_back(
"-mfix4300");
1915 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1916 StringRef
v = A->getValue();
1917 CmdArgs.push_back(
"-mllvm");
1918 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1922 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1924 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1937 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1939 llvm::Reloc::Model RelocationModel;
1942 std::tie(RelocationModel, PICLevel, IsPIE) =
1945 NoABICalls = NoABICalls ||
1946 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1948 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1950 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1951 CmdArgs.push_back(
"-mllvm");
1952 CmdArgs.push_back(
"-mgpopt");
1954 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1955 options::OPT_mno_local_sdata);
1956 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1957 options::OPT_mno_extern_sdata);
1958 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1959 options::OPT_mno_embedded_data);
1961 CmdArgs.push_back(
"-mllvm");
1962 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1963 CmdArgs.push_back(
"-mlocal-sdata=1");
1965 CmdArgs.push_back(
"-mlocal-sdata=0");
1967 LocalSData->claim();
1971 CmdArgs.push_back(
"-mllvm");
1972 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1973 CmdArgs.push_back(
"-mextern-sdata=1");
1975 CmdArgs.push_back(
"-mextern-sdata=0");
1977 ExternSData->claim();
1981 CmdArgs.push_back(
"-mllvm");
1982 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1983 CmdArgs.push_back(
"-membedded-data=1");
1985 CmdArgs.push_back(
"-membedded-data=0");
1987 EmbeddedData->claim();
1990 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1991 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1996 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1997 StringRef Val = StringRef(A->getValue());
1999 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
2000 CmdArgs.push_back(
"-mllvm");
2001 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
2003 D.
Diag(diag::err_drv_unsupported_option_argument)
2004 << A->getSpelling() << Val;
2006 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
2009 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
2010 options::OPT_mno_relax_pic_calls)) {
2011 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
2012 CmdArgs.push_back(
"-mllvm");
2013 CmdArgs.push_back(
"-mips-jalr-reloc=0");
2018void Clang::AddPPCTargetArgs(
const ArgList &Args,
2019 ArgStringList &CmdArgs)
const {
2022 if (Args.getLastArg(options::OPT_mtune_EQ)) {
2023 CmdArgs.push_back(
"-tune-cpu");
2025 CmdArgs.push_back(Args.MakeArgString(CPU));
2029 const char *ABIName =
nullptr;
2030 if (T.isOSBinFormatELF()) {
2032 case llvm::Triple::ppc64: {
2033 if (T.isPPC64ELFv2ABI())
2039 case llvm::Triple::ppc64le:
2048 bool VecExtabi =
false;
2049 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2050 StringRef
V = A->getValue();
2051 if (
V ==
"ieeelongdouble") {
2052 IEEELongDouble =
true;
2054 }
else if (
V ==
"ibmlongdouble") {
2055 IEEELongDouble =
false;
2057 }
else if (
V ==
"vec-default") {
2060 }
else if (
V ==
"vec-extabi") {
2063 }
else if (
V ==
"elfv1") {
2066 }
else if (
V ==
"elfv2") {
2069 }
else if (
V !=
"altivec")
2073 ABIName = A->getValue();
2076 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2079 D.
Diag(diag::err_drv_unsupported_opt_for_target)
2080 <<
"-mabi=vec-extabi" << T.str();
2081 CmdArgs.push_back(
"-mabi=vec-extabi");
2087 CmdArgs.push_back(
"-msoft-float");
2088 CmdArgs.push_back(
"-mfloat-abi");
2089 CmdArgs.push_back(
"soft");
2093 CmdArgs.push_back(
"-mfloat-abi");
2094 CmdArgs.push_back(
"hard");
2098 CmdArgs.push_back(
"-target-abi");
2099 CmdArgs.push_back(ABIName);
2104 ArgStringList &CmdArgs) {
2106 const llvm::Triple &Triple = TC.
getTriple();
2108 const char *SmallDataLimit =
"8";
2110 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2111 options::OPT_fPIC)) {
2113 SmallDataLimit =
"0";
2114 if (Args.hasArg(options::OPT_G)) {
2115 D.
Diag(diag::warn_drv_unsupported_sdata);
2117 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2118 .equals_insensitive(
"large") &&
2119 (Triple.getArch() == llvm::Triple::riscv64)) {
2121 SmallDataLimit =
"0";
2122 if (Args.hasArg(options::OPT_G)) {
2123 D.
Diag(diag::warn_drv_unsupported_sdata);
2125 }
else if (Triple.isAndroid()) {
2127 SmallDataLimit =
"0";
2128 if (Args.hasArg(options::OPT_G)) {
2129 D.
Diag(diag::warn_drv_unsupported_sdata);
2131 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2132 SmallDataLimit = A->getValue();
2135 CmdArgs.push_back(
"-msmall-data-limit");
2136 CmdArgs.push_back(SmallDataLimit);
2139void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2140 ArgStringList &CmdArgs)
const {
2144 CmdArgs.push_back(
"-target-abi");
2145 CmdArgs.push_back(ABIName.data());
2149 if (!Args.hasFlag(options::OPT_mimplicit_float,
2150 options::OPT_mno_implicit_float,
true))
2151 CmdArgs.push_back(
"-no-implicit-float");
2153 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2154 CmdArgs.push_back(
"-tune-cpu");
2155 if (strcmp(A->getValue(),
"native") == 0)
2156 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2158 CmdArgs.push_back(A->getValue());
2162 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2163 StringRef Val = A->getValue();
2167 unsigned MinVLen = 0;
2169 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
2173 consumeError(ISAInfo.takeError());
2175 MinVLen = (*ISAInfo)->getMinVLen();
2181 if (Val.equals(
"zvl") && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
2183 }
else if (!Val.getAsInteger(10, Bits)) {
2186 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
2187 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
2193 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
2195 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
2197 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
2198 }
else if (!Val.equals(
"scalable")) {
2200 D.
Diag(diag::err_drv_unsupported_option_argument)
2201 << A->getSpelling() << Val;
2206void Clang::AddSparcTargetArgs(
const ArgList &Args,
2207 ArgStringList &CmdArgs)
const {
2213 CmdArgs.push_back(
"-msoft-float");
2214 CmdArgs.push_back(
"-mfloat-abi");
2215 CmdArgs.push_back(
"soft");
2219 CmdArgs.push_back(
"-mfloat-abi");
2220 CmdArgs.push_back(
"hard");
2223 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2224 StringRef Name = A->getValue();
2225 std::string TuneCPU;
2226 if (Name ==
"native")
2227 TuneCPU = std::string(llvm::sys::getHostCPUName());
2229 TuneCPU = std::string(Name);
2231 CmdArgs.push_back(
"-tune-cpu");
2232 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2236void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2237 ArgStringList &CmdArgs)
const {
2238 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2239 CmdArgs.push_back(
"-tune-cpu");
2240 if (strcmp(A->getValue(),
"native") == 0)
2241 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2243 CmdArgs.push_back(A->getValue());
2247 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2248 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2249 options::OPT_mno_packed_stack,
false);
2253 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2255 D.
Diag(diag::err_drv_unsupported_opt)
2256 <<
"-mpacked-stack -mbackchain -mhard-float";
2259 CmdArgs.push_back(
"-mbackchain");
2261 CmdArgs.push_back(
"-mpacked-stack");
2264 CmdArgs.push_back(
"-msoft-float");
2265 CmdArgs.push_back(
"-mfloat-abi");
2266 CmdArgs.push_back(
"soft");
2270void Clang::AddX86TargetArgs(
const ArgList &Args,
2271 ArgStringList &CmdArgs)
const {
2275 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2276 Args.hasArg(options::OPT_mkernel) ||
2277 Args.hasArg(options::OPT_fapple_kext))
2278 CmdArgs.push_back(
"-disable-red-zone");
2280 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2281 options::OPT_mno_tls_direct_seg_refs,
true))
2282 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2286 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2287 Args.hasArg(options::OPT_fapple_kext));
2288 if (Arg *A = Args.getLastArg(
2289 options::OPT_msoft_float, options::OPT_mno_soft_float,
2290 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2291 const Option &O = A->getOption();
2292 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2293 O.matches(options::OPT_msoft_float));
2295 if (NoImplicitFloat)
2296 CmdArgs.push_back(
"-no-implicit-float");
2298 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2299 StringRef
Value = A->getValue();
2301 CmdArgs.push_back(
"-mllvm");
2302 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2303 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2305 D.
Diag(diag::err_drv_unsupported_option_argument)
2306 << A->getSpelling() <<
Value;
2309 CmdArgs.push_back(
"-mllvm");
2310 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2313 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2314 options::OPT_mno_skip_rax_setup))
2315 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2316 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2319 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2320 CmdArgs.push_back(
"-mfloat-abi");
2321 CmdArgs.push_back(
"soft");
2322 CmdArgs.push_back(
"-mstack-alignment=4");
2328 std::string TuneCPU;
2329 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2331 TuneCPU =
"generic";
2334 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2335 StringRef Name = A->getValue();
2337 if (Name ==
"native") {
2338 Name = llvm::sys::getHostCPUName();
2340 TuneCPU = std::string(Name);
2342 TuneCPU = std::string(Name);
2345 if (!TuneCPU.empty()) {
2346 CmdArgs.push_back(
"-tune-cpu");
2347 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2351void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2352 ArgStringList &CmdArgs)
const {
2353 CmdArgs.push_back(
"-mqdsp6-compat");
2354 CmdArgs.push_back(
"-Wreturn-type");
2357 CmdArgs.push_back(
"-mllvm");
2359 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2362 if (!Args.hasArg(options::OPT_fno_short_enums))
2363 CmdArgs.push_back(
"-fshort-enums");
2364 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2365 CmdArgs.push_back(
"-mllvm");
2366 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2368 CmdArgs.push_back(
"-mllvm");
2369 CmdArgs.push_back(
"-machine-sink-split=0");
2372void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2373 ArgStringList &CmdArgs)
const {
2374 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2375 StringRef CPUName = A->getValue();
2377 CmdArgs.push_back(
"-target-cpu");
2378 CmdArgs.push_back(Args.MakeArgString(CPUName));
2380 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2381 StringRef
Value = A->getValue();
2385 if (
Value.getAsInteger(10, Mregparm)) {
2386 if (Mregparm != 4) {
2388 diag::err_drv_unsupported_option_argument)
2389 << A->getSpelling() <<
Value;
2395void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2396 ArgStringList &CmdArgs)
const {
2398 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2399 options::OPT_fvisibility_ms_compat))
2400 CmdArgs.push_back(
"-fvisibility=hidden");
2403void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2405 CmdArgs.push_back(
"-mfloat-abi");
2406 CmdArgs.push_back(
"hard");
2411 const InputInfo &Input,
const ArgList &Args)
const {
2413 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2416 using llvm::yaml::escape;
2419 if (!CompilationDatabase) {
2421 auto File = std::make_unique<llvm::raw_fd_ostream>(
2423 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2425 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2429 CompilationDatabase = std::move(
File);
2431 auto &CDB = *CompilationDatabase;
2432 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2435 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2436 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2438 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2443 CDB <<
", \"" << escape(Buf) <<
"\"";
2444 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2447 CDB <<
", \"" << escape(Buf) <<
"\"";
2449 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2451 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2452 for (
auto &A: Args) {
2453 auto &O = A->getOption();
2455 if (O.getID() == options::OPT_x)
2458 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2460 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2463 if (O.getKind() == Option::InputClass)
2466 if (O.getID() == options::OPT_o)
2470 A->render(Args, ASL);
2472 CDB <<
", \"" << escape(it) <<
"\"";
2476 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2479void Clang::DumpCompilationDatabaseFragmentToDir(
2481 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2483 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2486 if (CompilationDatabase)
2487 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2490 const auto &
Driver =
C.getDriver();
2492 auto Err = llvm::sys::fs::create_directory(Path,
true);
2494 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2498 llvm::sys::path::append(
2500 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2503 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2504 llvm::sys::fs::OF_Text);
2506 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2509 CompilationDatabase =
2510 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2511 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2521 CmdArgs.push_back(
"-mllvm");
2522 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2526 const ArgList &Args,
2527 ArgStringList &CmdArgs,
2530 CmdArgs.push_back(
"-mrelax-all");
2534 bool DefaultIncrementalLinkerCompatible =
2535 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2536 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2537 options::OPT_mno_incremental_linker_compatible,
2538 DefaultIncrementalLinkerCompatible))
2539 CmdArgs.push_back(
"-mincremental-linker-compatible");
2541 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2543 Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2544 options::OPT_fno_emit_compact_unwind_non_canonical);
2554 bool TakeNextArg =
false;
2556 bool UseRelaxRelocations =
C.getDefaultToolChain().useRelaxRelocations();
2557 bool UseNoExecStack =
false;
2558 const char *MipsTargetFeature =
nullptr;
2559 StringRef ImplicitIt;
2561 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2562 options::OPT_mimplicit_it_EQ)) {
2565 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2566 switch (
C.getDefaultToolChain().getArch()) {
2567 case llvm::Triple::arm:
2568 case llvm::Triple::armeb:
2569 case llvm::Triple::thumb:
2570 case llvm::Triple::thumbeb:
2572 ImplicitIt = A->getValue();
2574 D.
Diag(diag::err_drv_unsupported_option_argument)
2575 << A->getSpelling() << ImplicitIt;
2582 for (StringRef
Value : A->getValues()) {
2584 CmdArgs.push_back(
Value.data());
2585 TakeNextArg =
false;
2589 if (
C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2590 Value ==
"-mbig-obj")
2593 switch (
C.getDefaultToolChain().getArch()) {
2596 case llvm::Triple::wasm32:
2597 case llvm::Triple::wasm64:
2598 if (
Value ==
"--no-type-check") {
2599 CmdArgs.push_back(
"-mno-type-check");
2603 case llvm::Triple::thumb:
2604 case llvm::Triple::thumbeb:
2605 case llvm::Triple::arm:
2606 case llvm::Triple::armeb:
2607 if (
Value.startswith(
"-mimplicit-it=")) {
2609 ImplicitIt =
Value.split(
"=").second;
2613 if (
Value ==
"-mthumb")
2618 case llvm::Triple::mips:
2619 case llvm::Triple::mipsel:
2620 case llvm::Triple::mips64:
2621 case llvm::Triple::mips64el:
2622 if (
Value ==
"--trap") {
2623 CmdArgs.push_back(
"-target-feature");
2624 CmdArgs.push_back(
"+use-tcc-in-div");
2627 if (
Value ==
"--break") {
2628 CmdArgs.push_back(
"-target-feature");
2629 CmdArgs.push_back(
"-use-tcc-in-div");
2632 if (
Value.startswith(
"-msoft-float")) {
2633 CmdArgs.push_back(
"-target-feature");
2634 CmdArgs.push_back(
"+soft-float");
2637 if (
Value.startswith(
"-mhard-float")) {
2638 CmdArgs.push_back(
"-target-feature");
2639 CmdArgs.push_back(
"-soft-float");
2643 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2644 .Case(
"-mips1",
"+mips1")
2645 .Case(
"-mips2",
"+mips2")
2646 .Case(
"-mips3",
"+mips3")
2647 .Case(
"-mips4",
"+mips4")
2648 .Case(
"-mips5",
"+mips5")
2649 .Case(
"-mips32",
"+mips32")
2650 .Case(
"-mips32r2",
"+mips32r2")
2651 .Case(
"-mips32r3",
"+mips32r3")
2652 .Case(
"-mips32r5",
"+mips32r5")
2653 .Case(
"-mips32r6",
"+mips32r6")
2654 .Case(
"-mips64",
"+mips64")
2655 .Case(
"-mips64r2",
"+mips64r2")
2656 .Case(
"-mips64r3",
"+mips64r3")
2657 .Case(
"-mips64r5",
"+mips64r5")
2658 .Case(
"-mips64r6",
"+mips64r6")
2660 if (MipsTargetFeature)
2664 if (
Value ==
"-force_cpusubtype_ALL") {
2666 }
else if (
Value ==
"-L") {
2667 CmdArgs.push_back(
"-msave-temp-labels");
2668 }
else if (
Value ==
"--fatal-warnings") {
2669 CmdArgs.push_back(
"-massembler-fatal-warnings");
2670 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2671 CmdArgs.push_back(
"-massembler-no-warn");
2672 }
else if (
Value ==
"--noexecstack") {
2673 UseNoExecStack =
true;
2674 }
else if (
Value.startswith(
"-compress-debug-sections") ||
2675 Value.startswith(
"--compress-debug-sections") ||
2676 Value ==
"-nocompress-debug-sections" ||
2677 Value ==
"--nocompress-debug-sections") {
2678 CmdArgs.push_back(
Value.data());
2679 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2680 Value ==
"--mrelax-relocations=yes") {
2681 UseRelaxRelocations =
true;
2682 }
else if (
Value ==
"-mrelax-relocations=no" ||
2683 Value ==
"--mrelax-relocations=no") {
2684 UseRelaxRelocations =
false;
2685 }
else if (
Value.startswith(
"-I")) {
2686 CmdArgs.push_back(
Value.data());
2691 }
else if (
Value.startswith(
"-gdwarf-")) {
2694 if (DwarfVersion == 0) {
2695 CmdArgs.push_back(
Value.data());
2698 llvm::codegenoptions::DebugInfoConstructor,
2699 DwarfVersion, llvm::DebuggerKind::Default);
2701 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2702 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2704 }
else if (
Value ==
"-defsym") {
2705 if (A->getNumValues() != 2) {
2706 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2709 const char *S = A->getValue(1);
2710 auto Pair = StringRef(S).split(
'=');
2711 auto Sym = Pair.first;
2712 auto SVal = Pair.second;
2714 if (Sym.empty() || SVal.empty()) {
2715 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2719 if (SVal.getAsInteger(0, IVal)) {
2720 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2723 CmdArgs.push_back(
Value.data());
2725 }
else if (
Value ==
"-fdebug-compilation-dir") {
2726 CmdArgs.push_back(
"-fdebug-compilation-dir");
2728 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2732 CmdArgs.push_back(
"-fdebug-compilation-dir");
2733 CmdArgs.push_back(
Value.data());
2734 }
else if (
Value ==
"--version") {
2737 D.
Diag(diag::err_drv_unsupported_option_argument)
2738 << A->getSpelling() <<
Value;
2742 if (ImplicitIt.size())
2744 if (!UseRelaxRelocations)
2745 CmdArgs.push_back(
"-mrelax-relocations=no");
2747 CmdArgs.push_back(
"-mnoexecstack");
2748 if (MipsTargetFeature !=
nullptr) {
2749 CmdArgs.push_back(
"-target-feature");
2750 CmdArgs.push_back(MipsTargetFeature);
2754 if (
C.getDriver().embedBitcodeEnabled() ||
2755 C.getDriver().embedBitcodeMarkerOnly())
2756 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2758 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2759 CmdArgs.push_back(
"-as-secure-log-file");
2760 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2765 bool OFastEnabled,
const ArgList &Args,
2766 ArgStringList &CmdArgs,
2773 bool HonorINFs =
true;
2774 bool HonorNaNs =
true;
2775 bool ApproxFunc =
false;
2778 bool AssociativeMath =
false;
2779 bool ReciprocalMath =
false;
2780 bool SignedZeros =
true;
2781 bool TrappingMath =
false;
2782 bool TrappingMathPresent =
false;
2784 bool RoundingFPMath =
false;
2785 bool RoundingMathPresent =
false;
2787 StringRef FPModel =
"";
2789 StringRef FPExceptionBehavior =
"";
2791 StringRef FPEvalMethod =
"";
2792 const llvm::DenormalMode DefaultDenormalFPMath =
2794 const llvm::DenormalMode DefaultDenormalFP32Math =
2797 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
2798 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
2801 StringRef FPContract;
2802 StringRef LastSeenFfpContractOption;
2803 bool SeenUnsafeMathModeOption =
false;
2807 bool StrictFPModel =
false;
2808 StringRef Float16ExcessPrecision =
"";
2809 StringRef BFloat16ExcessPrecision =
"";
2811 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2812 CmdArgs.push_back(
"-mlimit-float-precision");
2813 CmdArgs.push_back(A->getValue());
2816 for (
const Arg *A : Args) {
2817 auto optID = A->getOption().getID();
2818 bool PreciseFPModel =
false;
2822 case options::OPT_ffp_model_EQ: {
2829 AssociativeMath =
false;
2830 ReciprocalMath =
false;
2834 DenormalFPMath = llvm::DenormalMode::getIEEE();
2838 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2840 StringRef Val = A->getValue();
2841 if (OFastEnabled && !Val.equals(
"fast")) {
2843 D.
Diag(clang::diag::warn_drv_overriding_option)
2844 << Args.MakeArgString(
"-ffp-model=" + Val) <<
"-Ofast";
2847 StrictFPModel =
false;
2848 PreciseFPModel =
true;
2852 if (!FPModel.empty() && !FPModel.equals(Val))
2853 D.
Diag(clang::diag::warn_drv_overriding_option)
2854 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2855 << Args.MakeArgString(
"-ffp-model=" + Val);
2856 if (Val.equals(
"fast")) {
2857 optID = options::OPT_ffast_math;
2859 FPContract =
"fast";
2860 }
else if (Val.equals(
"precise")) {
2861 optID = options::OPT_ffp_contract;
2864 PreciseFPModel =
true;
2865 }
else if (Val.equals(
"strict")) {
2866 StrictFPModel =
true;
2867 optID = options::OPT_frounding_math;
2868 FPExceptionBehavior =
"strict";
2871 TrappingMath =
true;
2873 D.
Diag(diag::err_drv_unsupported_option_argument)
2874 << A->getSpelling() << Val;
2884 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2885 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2886 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2887 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2888 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2889 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2890 case options::OPT_fmath_errno: MathErrno =
true;
break;
2891 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2892 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2893 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2894 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2895 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2896 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2897 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2898 case options::OPT_ftrapping_math:
2899 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2900 !FPExceptionBehavior.equals(
"strict"))
2902 D.
Diag(clang::diag::warn_drv_overriding_option)
2903 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2904 FPExceptionBehavior)
2905 <<
"-ftrapping-math";
2906 TrappingMath =
true;
2907 TrappingMathPresent =
true;
2908 FPExceptionBehavior =
"strict";
2910 case options::OPT_fno_trapping_math:
2911 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2912 !FPExceptionBehavior.equals(
"ignore"))
2914 D.
Diag(clang::diag::warn_drv_overriding_option)
2915 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2916 FPExceptionBehavior)
2917 <<
"-fno-trapping-math";
2918 TrappingMath =
false;
2919 TrappingMathPresent =
true;
2920 FPExceptionBehavior =
"ignore";
2923 case options::OPT_frounding_math:
2924 RoundingFPMath =
true;
2925 RoundingMathPresent =
true;
2928 case options::OPT_fno_rounding_math:
2929 RoundingFPMath =
false;
2930 RoundingMathPresent =
false;
2933 case options::OPT_fdenormal_fp_math_EQ:
2934 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
2935 DenormalFP32Math = DenormalFPMath;
2936 if (!DenormalFPMath.isValid()) {
2937 D.
Diag(diag::err_drv_invalid_value)
2938 << A->getAsString(Args) << A->getValue();
2942 case options::OPT_fdenormal_fp_math_f32_EQ:
2943 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
2944 if (!DenormalFP32Math.isValid()) {
2945 D.
Diag(diag::err_drv_invalid_value)
2946 << A->getAsString(Args) << A->getValue();
2951 case options::OPT_ffp_contract: {
2952 StringRef Val = A->getValue();
2953 if (PreciseFPModel) {
2958 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off") ||
2959 Val.equals(
"fast-honor-pragmas")) {
2961 LastSeenFfpContractOption = Val;
2963 D.
Diag(diag::err_drv_unsupported_option_argument)
2964 << A->getSpelling() << Val;
2969 case options::OPT_ffp_model_EQ:
2976 case options::OPT_ffp_exception_behavior_EQ: {
2977 StringRef Val = A->getValue();
2978 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2979 !FPExceptionBehavior.equals(Val))
2981 D.
Diag(clang::diag::warn_drv_overriding_option)
2982 << Args.MakeArgString(
"-ffp-exception-behavior=" +
2983 FPExceptionBehavior)
2984 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
2985 TrappingMath = TrappingMathPresent =
false;
2986 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
2987 FPExceptionBehavior = Val;
2988 else if (Val.equals(
"strict")) {
2989 FPExceptionBehavior = Val;
2990 TrappingMath = TrappingMathPresent =
true;
2992 D.
Diag(diag::err_drv_unsupported_option_argument)
2993 << A->getSpelling() << Val;
2998 case options::OPT_ffp_eval_method_EQ: {
2999 StringRef Val = A->getValue();
3000 if (Val.equals(
"double") || Val.equals(
"extended") ||
3001 Val.equals(
"source"))
3004 D.
Diag(diag::err_drv_unsupported_option_argument)
3005 << A->getSpelling() << Val;
3009 case options::OPT_fexcess_precision_EQ: {
3010 StringRef Val = A->getValue();
3011 const llvm::Triple::ArchType Arch = TC.
getArch();
3012 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
3013 if (Val.equals(
"standard") || Val.equals(
"fast"))
3014 Float16ExcessPrecision = Val;
3018 else if (Val.equals(
"16"))
3019 Float16ExcessPrecision =
"none";
3021 D.
Diag(diag::err_drv_unsupported_option_argument)
3022 << A->getSpelling() << Val;
3024 if (!(Val.equals(
"standard") || Val.equals(
"fast")))
3025 D.
Diag(diag::err_drv_unsupported_option_argument)
3026 << A->getSpelling() << Val;
3028 BFloat16ExcessPrecision = Float16ExcessPrecision;
3031 case options::OPT_ffinite_math_only:
3035 case options::OPT_fno_finite_math_only:
3040 case options::OPT_funsafe_math_optimizations:
3041 AssociativeMath =
true;
3042 ReciprocalMath =
true;
3043 SignedZeros =
false;
3045 TrappingMath =
false;
3046 FPExceptionBehavior =
"";
3047 FPContract =
"fast";
3048 SeenUnsafeMathModeOption =
true;
3050 case options::OPT_fno_unsafe_math_optimizations:
3051 AssociativeMath =
false;
3052 ReciprocalMath =
false;
3055 TrappingMath =
true;
3056 FPExceptionBehavior =
"strict";
3059 DenormalFPMath = llvm::DenormalMode::getIEEE();
3060 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3063 if (LastSeenFfpContractOption !=
"") {
3064 FPContract = LastSeenFfpContractOption;
3065 }
else if (SeenUnsafeMathModeOption)
3070 case options::OPT_Ofast:
3075 case options::OPT_ffast_math:
3079 AssociativeMath =
true;
3080 ReciprocalMath =
true;
3082 SignedZeros =
false;
3083 TrappingMath =
false;
3084 RoundingFPMath =
false;
3085 FPExceptionBehavior =
"";
3087 FPContract =
"fast";
3088 SeenUnsafeMathModeOption =
true;
3090 case options::OPT_fno_fast_math:
3097 AssociativeMath =
false;
3098 ReciprocalMath =
false;
3102 DenormalFPMath = DefaultDenormalFPMath;
3103 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3106 if (LastSeenFfpContractOption !=
"") {
3107 FPContract = LastSeenFfpContractOption;
3108 }
else if (SeenUnsafeMathModeOption)
3113 if (StrictFPModel) {
3116 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3117 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3118 DenormalFPMath == llvm::DenormalMode::getIEEE() &&
3119 DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
3120 FPContract.equals(
"off"))
3124 StrictFPModel =
false;
3126 auto RHS = (A->getNumValues() == 0)
3128 : Args.MakeArgString(A->getSpelling() + A->getValue());
3129 if (RHS !=
"-ffp-model=strict")
3130 D.
Diag(clang::diag::warn_drv_overriding_option)
3131 <<
"-ffp-model=strict" << RHS;
3140 CmdArgs.push_back(
"-menable-no-infs");
3143 CmdArgs.push_back(
"-menable-no-nans");
3146 CmdArgs.push_back(
"-fapprox-func");
3149 CmdArgs.push_back(
"-fmath-errno");
3151 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3153 CmdArgs.push_back(
"-funsafe-math-optimizations");
3156 CmdArgs.push_back(
"-fno-signed-zeros");
3158 if (AssociativeMath && !SignedZeros && !TrappingMath)
3159 CmdArgs.push_back(
"-mreassociate");
3162 CmdArgs.push_back(
"-freciprocal-math");
3166 assert(FPExceptionBehavior.equals(
"strict"));
3170 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3172 llvm::raw_svector_ostream ArgStr(DenormFlag);
3173 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3174 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3178 if (DenormalFP32Math != DenormalFPMath) {
3180 llvm::raw_svector_ostream ArgStr(DenormFlag);
3181 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3182 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3185 if (!FPContract.empty())
3186 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3188 if (!RoundingFPMath)
3189 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3191 if (RoundingFPMath && RoundingMathPresent)
3192 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3194 if (!FPExceptionBehavior.empty())
3195 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3196 FPExceptionBehavior));
3198 if (!FPEvalMethod.empty())
3199 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3201 if (!Float16ExcessPrecision.empty())
3202 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3203 Float16ExcessPrecision));
3204 if (!BFloat16ExcessPrecision.empty())
3205 CmdArgs.push_back(Args.MakeArgString(
"-fbfloat16-excess-precision=" +
3206 BFloat16ExcessPrecision));
3213 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3214 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3215 CmdArgs.push_back(
"-ffast-math");
3216 if (FPModel.equals(
"fast")) {
3217 if (FPContract.equals(
"fast"))
3220 else if (FPContract.empty())
3222 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3224 D.
Diag(clang::diag::warn_drv_overriding_option)
3225 <<
"-ffp-model=fast"
3226 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3231 if (!HonorINFs && !HonorNaNs)
3232 CmdArgs.push_back(
"-ffinite-math-only");
3234 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3235 CmdArgs.push_back(
"-mfpmath");
3236 CmdArgs.push_back(A->getValue());
3240 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3241 options::OPT_fstrict_float_cast_overflow,
false))
3242 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3246 const llvm::Triple &Triple,
3249 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3250 CmdArgs.push_back(
"-analyzer-checker=core");
3251 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3253 if (!Triple.isWindowsMSVCEnvironment()) {
3254 CmdArgs.push_back(
"-analyzer-checker=unix");
3257 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3258 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3259 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3260 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3261 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3262 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3266 if (Triple.isPS()) {
3267 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3268 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3271 if (Triple.isOSDarwin()) {
3272 CmdArgs.push_back(
"-analyzer-checker=osx");
3274 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3276 else if (Triple.isOSFuchsia())
3277 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3279 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3282 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3284 if (!Triple.isPS()) {
3285 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3286 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3287 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3288 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3289 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3290 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3294 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3295 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3299 CmdArgs.push_back(
"-analyzer-output");
3300 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3301 CmdArgs.push_back(A->getValue());
3303 CmdArgs.push_back(
"plist");
3308 CmdArgs.push_back(
"-w");
3311 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3318 if (std::isdigit(S[0]))
3321 return llvm::all_of(S, [](
char C) {
return std::isalnum(
C) ||
C ==
'_'; });
3325 const ArgList &Args, ArgStringList &CmdArgs,
3326 bool KernelOrKext) {
3331 if (EffectiveTriple.isNVPTX())
3339 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3340 options::OPT_fstack_protector_all,
3341 options::OPT_fstack_protector_strong,
3342 options::OPT_fstack_protector)) {
3343 if (A->getOption().matches(options::OPT_fstack_protector))
3344 StackProtectorLevel =
3346 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3348 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3352 D.
Diag(diag::warn_drv_unsupported_option_for_target)
3353 << A->getSpelling() << EffectiveTriple.getTriple();
3354 StackProtectorLevel = DefaultStackProtectorLevel;
3357 StackProtectorLevel = DefaultStackProtectorLevel;
3360 if (StackProtectorLevel) {
3361 CmdArgs.push_back(
"-stack-protector");
3362 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3366 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3367 StringRef Str(A->getValue());
3368 if (Str.startswith(
"ssp-buffer-size=")) {
3369 if (StackProtectorLevel) {
3370 CmdArgs.push_back(
"-stack-protector-buffer-size");
3372 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3378 const std::string &TripleStr = EffectiveTriple.getTriple();
3379 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3380 StringRef
Value = A->getValue();
3381 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3382 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3383 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3384 << A->getAsString(Args) << TripleStr;
3385 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3386 EffectiveTriple.isThumb()) &&
3388 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3389 << A->getOption().getName() <<
Value <<
"tls global";
3392 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3394 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3395 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3396 << A->getAsString(Args);
3401 D.
Diag(diag::err_target_unsupported_tp_hard)
3402 << EffectiveTriple.getArchName();
3406 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3407 StringRef
Value = A->getValue();
3408 if (
Value !=
"cp15") {
3409 D.
Diag(diag::err_drv_argument_not_allowed_with)
3410 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3414 CmdArgs.push_back(
"-target-feature");
3415 CmdArgs.push_back(
"+read-tp-tpidruro");
3417 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3418 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3419 << A->getOption().getName() <<
Value <<
"sysreg global";
3422 A->render(Args, CmdArgs);
3425 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3426 StringRef
Value = A->getValue();
3427 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3428 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3429 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3430 << A->getAsString(Args) << TripleStr;
3432 if (
Value.getAsInteger(10, Offset)) {
3433 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3436 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3437 (Offset < 0 || Offset > 0xfffff)) {
3438 D.
Diag(diag::err_drv_invalid_int_value)
3439 << A->getOption().getName() <<
Value;
3442 A->render(Args, CmdArgs);
3445 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3446 StringRef
Value = A->getValue();
3447 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3448 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3449 << A->getAsString(Args) << TripleStr;
3450 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3451 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3452 << A->getOption().getName() <<
Value <<
"fs gs";
3455 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3456 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3459 A->render(Args, CmdArgs);
3462 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3463 StringRef
Value = A->getValue();
3465 D.
Diag(diag::err_drv_argument_only_allowed_with)
3466 << A->getOption().getName() <<
"legal symbol name";
3469 A->render(Args, CmdArgs);
3474 ArgStringList &CmdArgs) {
3477 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3480 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3481 !EffectiveTriple.isPPC64())
3484 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3485 options::OPT_fno_stack_clash_protection);
3490 const ArgList &Args,
3491 ArgStringList &CmdArgs) {
3493 StringRef TrivialAutoVarInit =
"";
3495 for (
const Arg *A : Args) {
3496 switch (A->getOption().getID()) {
3499 case options::OPT_ftrivial_auto_var_init: {
3501 StringRef Val = A->getValue();
3502 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3503 TrivialAutoVarInit = Val;
3505 D.
Diag(diag::err_drv_unsupported_option_argument)
3506 << A->getSpelling() << Val;
3512 if (TrivialAutoVarInit.empty())
3513 switch (DefaultTrivialAutoVarInit) {
3517 TrivialAutoVarInit =
"pattern";
3520 TrivialAutoVarInit =
"zero";
3524 if (!TrivialAutoVarInit.empty()) {
3526 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3530 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3531 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3533 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3535 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3537 StringRef Val = A->getValue();
3538 if (std::stoi(Val.str()) <= 0)
3539 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3541 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3549 const unsigned ForwardedArguments[] = {
3550 options::OPT_cl_opt_disable,
3551 options::OPT_cl_strict_aliasing,
3552 options::OPT_cl_single_precision_constant,
3553 options::OPT_cl_finite_math_only,
3554 options::OPT_cl_kernel_arg_info,
3555 options::OPT_cl_unsafe_math_optimizations,
3556 options::OPT_cl_fast_relaxed_math,
3557 options::OPT_cl_mad_enable,
3558 options::OPT_cl_no_signed_zeros,
3559 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3560 options::OPT_cl_uniform_work_group_size
3563 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3564 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3565 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3566 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3567 std::string CLExtStr = std::string(
"-cl-ext=") + A->getValue();
3568 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3571 for (
const auto &Arg : ForwardedArguments)
3572 if (
const auto *A = Args.getLastArg(Arg))
3573 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3578 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3579 CmdArgs.push_back(
"-finclude-default-header");
3580 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3586 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3591 options::OPT_emit_llvm,
3592 options::OPT_emit_obj,
3593 options::OPT_disable_llvm_passes,
3594 options::OPT_fnative_half_type,
3595 options::OPT_hlsl_entrypoint};
3598 for (
const auto &Arg : ForwardedArguments)
3599 if (
const auto *A = Args.getLastArg(Arg))
3600 A->renderAsInput(Args, CmdArgs);
3602 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3603 !Args.hasArg(options::OPT_nostdinc))
3604 CmdArgs.push_back(
"-finclude-default-header");
3608 ArgStringList &CmdArgs) {
3609 bool ARCMTEnabled =
false;
3610 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3611 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3612 options::OPT_ccc_arcmt_modify,
3613 options::OPT_ccc_arcmt_migrate)) {
3614 ARCMTEnabled =
true;
3615 switch (A->getOption().getID()) {
3616 default: llvm_unreachable(
"missed a case");
3617 case options::OPT_ccc_arcmt_check:
3618 CmdArgs.push_back(
"-arcmt-action=check");
3620 case options::OPT_ccc_arcmt_modify:
3621 CmdArgs.push_back(
"-arcmt-action=modify");
3623 case options::OPT_ccc_arcmt_migrate:
3624 CmdArgs.push_back(
"-arcmt-action=migrate");
3625 CmdArgs.push_back(
"-mt-migrate-directory");
3626 CmdArgs.push_back(A->getValue());
3628 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3629 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3634 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3635 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3636 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3639 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3641 D.
Diag(diag::err_drv_argument_not_allowed_with)
3642 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3644 CmdArgs.push_back(
"-mt-migrate-directory");
3645 CmdArgs.push_back(A->getValue());
3647 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3648 options::OPT_objcmt_migrate_subscripting,
3649 options::OPT_objcmt_migrate_property)) {
3651 CmdArgs.push_back(
"-objcmt-migrate-literals");
3652 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3653 CmdArgs.push_back(
"-objcmt-migrate-property");
3655 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3656 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3657 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3660 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3661 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3662 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3663 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3664 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3665 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3666 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3667 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3668 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3669 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3670 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3671 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3672 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3673 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3674 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3675 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3680 const ArgList &Args, ArgStringList &CmdArgs) {
3683 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3684 !Args.hasArg(options::OPT_mkernel));
3686 CmdArgs.push_back(
"-fno-builtin");
3689 if (Args.hasArg(options::OPT_ffreestanding))
3690 UseBuiltins =
false;
3693 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3699 A->render(Args, CmdArgs);
3705 if (TC.
getArch() == llvm::Triple::le32)
3706 CmdArgs.push_back(
"-fno-math-builtin");
3710 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
3713 return Path.getSingleStringRef() !=
"";
3715 if (llvm::sys::path::cache_directory(
Result)) {
3716 llvm::sys::path::append(
Result,
"clang");
3717 llvm::sys::path::append(
Result,
"ModuleCache");
3724 const ArgList &Args,
const InputInfo &Input,
3726 ArgStringList &CmdArgs) {
3730 bool HaveStdCXXModules =
3732 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"gnu++2a") ||
3733 Std->containsValue(
"c++20") ||
Std->containsValue(
"gnu++20") ||
3734 Std->containsValue(
"c++2b") ||
Std->containsValue(
"gnu++2b") ||
3735 Std->containsValue(
"c++23") ||
Std->containsValue(
"gnu++23") ||
3736 Std->containsValue(
"c++2c") ||
Std->containsValue(
"gnu++2c") ||
3737 Std->containsValue(
"c++26") ||
Std->containsValue(
"gnu++26") ||
3738 Std->containsValue(
"c++latest") ||
Std->containsValue(
"gnu++latest"));
3739 bool HaveModules = HaveStdCXXModules;
3744 bool HaveClangModules =
false;
3745 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3746 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3747 options::OPT_fno_cxx_modules,
true);
3748 if (AllowedInCXX || !IsCXX) {
3749 CmdArgs.push_back(
"-fmodules");
3750 HaveClangModules =
true;
3754 HaveModules |= HaveClangModules;
3758 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3759 options::OPT_fno_implicit_module_maps, HaveClangModules))
3760 CmdArgs.push_back(
"-fimplicit-module-maps");
3763 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3764 options::OPT_fno_modules_decluse);
3768 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3769 options::OPT_fno_modules_strict_decluse,
false))
3770 CmdArgs.push_back(
"-fmodules-strict-decluse");
3773 bool ImplicitModules =
false;
3774 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3775 options::OPT_fno_implicit_modules, HaveClangModules)) {
3777 CmdArgs.push_back(
"-fno-implicit-modules");
3778 }
else if (HaveModules) {
3779 ImplicitModules =
true;
3783 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3784 Path = A->getValue();
3786 bool HasPath =
true;
3787 if (
C.isForDiagnostics()) {
3791 llvm::sys::path::replace_extension(Path,
".cache");
3792 llvm::sys::path::append(Path,
"modules");
3793 }
else if (Path.empty()) {
3801 const char Arg[] =
"-fmodules-cache-path=";
3802 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3803 CmdArgs.push_back(Args.MakeArgString(Path));
3808 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3809 options::OPT_fno_prebuilt_implicit_modules,
false))
3810 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3811 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3812 options::OPT_fno_modules_validate_input_files_content,
3814 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3819 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3823 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3827 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3829 llvm::sys::path::append(BuiltinModuleMap,
"include");
3830 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3831 if (llvm::sys::fs::exists(BuiltinModuleMap))
3833 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3840 if (HaveModules || Input.
getType() == clang::driver::types::TY_ModuleFile) {
3841 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3844 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3845 CmdArgs.push_back(Args.MakeArgString(
3846 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3850 Args.ClaimAllArgs(options::OPT_fmodule_file);
3854 if (HaveClangModules &&
C.isForDiagnostics()) {
3856 llvm::sys::path::replace_extension(VFSDir,
".cache");
3858 C.addTempFile(Args.MakeArgString(VFSDir));
3860 llvm::sys::path::append(VFSDir,
"vfs");
3861 CmdArgs.push_back(
"-module-dependency-dir");
3862 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3865 if (HaveClangModules)
3866 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3869 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3870 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3871 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3873 if (HaveClangModules) {
3874 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3876 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3877 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3878 D.
Diag(diag::err_drv_argument_not_allowed_with)
3879 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3881 llvm::sys::fs::file_status Status;
3882 if (llvm::sys::fs::status(A->getValue(), Status))
3883 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3884 CmdArgs.push_back(Args.MakeArgString(
3885 "-fbuild-session-timestamp=" +
3886 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3887 Status.getLastModificationTime().time_since_epoch())
3891 if (Args.getLastArg(
3892 options::OPT_fmodules_validate_once_per_build_session)) {
3893 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3894 options::OPT_fbuild_session_file))
3895 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3897 Args.AddLastArg(CmdArgs,
3898 options::OPT_fmodules_validate_once_per_build_session);
3901 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
3902 options::OPT_fno_modules_validate_system_headers,
3904 CmdArgs.push_back(
"-fmodules-validate-system-headers");
3906 Args.AddLastArg(CmdArgs,
3907 options::OPT_fmodules_disable_diagnostic_validation);
3909 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
3910 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
3911 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
3912 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
3913 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
3914 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
3918 Args.ClaimAllArgs(options::OPT_fmodule_output);
3919 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
3925 ArgStringList &CmdArgs) {
3927 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
3928 options::OPT_fno_signed_char,
3929 options::OPT_funsigned_char,
3930 options::OPT_fno_unsigned_char)) {
3931 if (A->getOption().matches(options::OPT_funsigned_char) ||
3932 A->getOption().matches(options::OPT_fno_signed_char)) {
3933 CmdArgs.push_back(
"-fno-signed-char");
3936 CmdArgs.push_back(
"-fno-signed-char");
3940 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
3942 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3943 options::OPT_fno_short_wchar)) {
3944 if (A->getOption().matches(options::OPT_fshort_wchar)) {
3945 CmdArgs.push_back(
"-fwchar-type=short");
3946 CmdArgs.push_back(
"-fno-signed-wchar");
3948 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
3949 CmdArgs.push_back(
"-fwchar-type=int");
3951 (IsARM && !(T.isOSWindows() || T.isOSNetBSD() || T.isOSOpenBSD())))
3952 CmdArgs.push_back(
"-fno-signed-wchar");
3954 CmdArgs.push_back(
"-fsigned-wchar");
3956 }
else if (T.isOSzOS())
3957 CmdArgs.push_back(
"-fno-signed-wchar");
3961 const llvm::Triple &T,
const ArgList &Args,
3963 const InputInfo &Input, ArgStringList &CmdArgs) {
3964 const llvm::Triple::ArchType Arch = TC.
getArch();
3970 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3971 options::OPT_fno_objc_legacy_dispatch,
3974 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
3976 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
3982 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
3984 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
3991 CmdArgs.push_back(
"-fobjc-arc");
3998 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
4000 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
4005 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4006 options::OPT_fno_objc_arc_exceptions,
4008 CmdArgs.push_back(
"-fobjc-arc-exceptions");
4013 if (Args.hasArg(options::OPT_fno_objc_arc)) {
4014 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4015 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4021 auto *Arg = Args.getLastArg(
4022 options::OPT_fobjc_convert_messages_to_runtime_calls,
4023 options::OPT_fno_objc_convert_messages_to_runtime_calls);
4025 Arg->getOption().matches(
4026 options::OPT_fno_objc_convert_messages_to_runtime_calls))
4027 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
4032 if (InferCovariantReturns)
4033 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4038 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4042 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4043 D.
Diag(diag::err_objc_weak_unsupported);
4045 WeakArg->render(Args, CmdArgs);
4049 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4050 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
4054 ArgStringList &CmdArgs) {
4055 bool CaretDefault =
true;
4056 bool ColumnDefault =
true;
4058 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4059 options::OPT__SLASH_diagnostics_column,
4060 options::OPT__SLASH_diagnostics_caret)) {
4061 switch (A->getOption().getID()) {
4062 case options::OPT__SLASH_diagnostics_caret:
4063 CaretDefault =
true;
4064 ColumnDefault =
true;
4066 case options::OPT__SLASH_diagnostics_column:
4067 CaretDefault =
false;
4068 ColumnDefault =
true;
4070 case options::OPT__SLASH_diagnostics_classic:
4071 CaretDefault =
false;
4072 ColumnDefault =
false;
4078 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4079 options::OPT_fno_caret_diagnostics, CaretDefault))
4080 CmdArgs.push_back(
"-fno-caret-diagnostics");
4082 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4083 options::OPT_fno_diagnostics_fixit_info);
4084 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4085 options::OPT_fno_diagnostics_show_option);
4088 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4089 CmdArgs.push_back(
"-fdiagnostics-show-category");
4090 CmdArgs.push_back(A->getValue());
4093 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4094 options::OPT_fno_diagnostics_show_hotness);
4097 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4099 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4100 CmdArgs.push_back(Args.MakeArgString(Opt));
4104 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4106 std::string(
"-fdiagnostics-misexpect-tolerance=") + A->getValue();
4107 CmdArgs.push_back(Args.MakeArgString(Opt));
4110 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4111 CmdArgs.push_back(
"-fdiagnostics-format");
4112 CmdArgs.push_back(A->getValue());
4113 if (StringRef(A->getValue()) ==
"sarif" ||
4114 StringRef(A->getValue()) ==
"SARIF")
4115 D.
Diag(diag::warn_drv_sarif_format_unstable);
4118 if (
const Arg *A = Args.getLastArg(
4119 options::OPT_fdiagnostics_show_note_include_stack,
4120 options::OPT_fno_diagnostics_show_note_include_stack)) {
4121 const Option &O = A->getOption();
4122 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4123 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4125 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4132 Args.getLastArg(options::OPT_fcolor_diagnostics,
4133 options::OPT_fno_color_diagnostics);
4134 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4135 StringRef
Value(A->getValue());
4137 D.
Diag(diag::err_drv_invalid_argument_to_option)
4138 <<
Value << A->getOption().getName();
4142 CmdArgs.push_back(
"-fcolor-diagnostics");
4144 if (Args.hasArg(options::OPT_fansi_escape_codes))
4145 CmdArgs.push_back(
"-fansi-escape-codes");
4147 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4148 options::OPT_fno_show_source_location);
4150 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4151 options::OPT_fno_diagnostics_show_line_numbers);
4153 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4154 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4156 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4158 CmdArgs.push_back(
"-fno-show-column");
4160 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4161 options::OPT_fno_spell_checking);
4165 const ArgList &Args, Arg *&Arg) {
4166 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4167 options::OPT_gno_split_dwarf);
4168 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4171 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4174 StringRef
Value = Arg->getValue();
4175 if (
Value ==
"split")
4177 if (
Value ==
"single")
4180 D.
Diag(diag::err_drv_unsupported_option_argument)
4181 << Arg->getSpelling() << Arg->getValue();
4186 const ArgList &Args, ArgStringList &CmdArgs,
4187 unsigned DwarfVersion) {
4188 auto *DwarfFormatArg =
4189 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4190 if (!DwarfFormatArg)
4193 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4194 if (DwarfVersion < 3)
4195 D.
Diag(diag::err_drv_argument_only_allowed_with)
4196 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4197 else if (!T.isArch64Bit())
4198 D.
Diag(diag::err_drv_argument_only_allowed_with)
4199 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4200 else if (!T.isOSBinFormatELF())
4201 D.
Diag(diag::err_drv_argument_only_allowed_with)
4202 << DwarfFormatArg->getAsString(Args) <<
"ELF platforms";
4205 DwarfFormatArg->render(Args, CmdArgs);
4210 const ArgList &Args,
bool IRInput, ArgStringList &CmdArgs,
4212 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
4214 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4215 options::OPT_fno_debug_info_for_profiling,
false) &&
4217 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4218 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4231 bool SplitDWARFInlining =
4232 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4233 options::OPT_fno_split_dwarf_inlining,
false);
4238 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4244 SplitDWARFInlining =
false;
4247 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4248 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4252 A->getOption().matches(options::OPT_gN_Group)) {
4258 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
4259 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
4260 (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
4261 SplitDWARFInlining))
4267 bool HasDebuggerTuning =
false;
4269 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4270 HasDebuggerTuning =
true;
4272 if (A->getOption().matches(options::OPT_glldb))
4273 DebuggerTuning = llvm::DebuggerKind::LLDB;
4274 else if (A->getOption().matches(options::OPT_gsce))
4275 DebuggerTuning = llvm::DebuggerKind::SCE;
4276 else if (A->getOption().matches(options::OPT_gdbx))
4277 DebuggerTuning = llvm::DebuggerKind::DBX;
4279 DebuggerTuning = llvm::DebuggerKind::GDB;
4284 bool EmitDwarf =
false;
4288 bool EmitCodeView =
false;
4289 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4294 if (!EmitCodeView && !EmitDwarf &&
4295 DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
4297 case llvm::codegenoptions::DIF_CodeView:
4298 EmitCodeView =
true;
4300 case llvm::codegenoptions::DIF_DWARF:
4306 unsigned RequestedDWARFVersion = 0;
4307 unsigned EffectiveDWARFVersion = 0;
4312 EffectiveDWARFVersion =
4315 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4319 if (RequestedDWARFVersion == 0 &&
4320 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
4321 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
4325 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4327 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4328 DebuggerTuning == llvm::DebuggerKind::DBX))
4329 CmdArgs.push_back(
"-gstrict-dwarf");
4332 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4340 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4342 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4344 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4345 DebuggerTuning != llvm::DebuggerKind::DBX)))
4346 CmdArgs.push_back(
"-gno-column-info");
4349 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4354 if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
4355 DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
4356 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4357 CmdArgs.push_back(
"-dwarf-ext-refs");
4358 CmdArgs.push_back(
"-fmodule-format=obj");
4363 if (T.isOSBinFormatELF() && SplitDWARFInlining)
4364 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4371 bool NeedFullDebug = Args.hasFlag(
4372 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4373 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4375 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4378 if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
4379 DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
4380 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4381 options::OPT_feliminate_unused_debug_types,
false))
4382 DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
4383 else if (NeedFullDebug)
4384 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
4387 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4393 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4394 if (RequestedDWARFVersion < 5)
4395 D.
Diag(diag::err_drv_argument_only_allowed_with)
4396 << A->getAsString(Args) <<
"-gdwarf-5";
4397 else if (EffectiveDWARFVersion < 5)
4400 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4402 << EffectiveDWARFVersion;
4404 CmdArgs.push_back(
"-gembed-source");
4408 CmdArgs.push_back(
"-gcodeview");
4410 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4411 options::OPT_gno_codeview_ghash);
4413 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4414 options::OPT_gno_codeview_command_line);
4417 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4418 options::OPT_gno_inline_line_tables);
4422 DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
4423 DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
4431 T.isOSAIX() && !HasDebuggerTuning
4432 ? llvm::DebuggerKind::Default
4436 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4440 CmdArgs.push_back(
"-debug-info-macro");
4443 const auto *PubnamesArg =
4444 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4445 options::OPT_gpubnames, options::OPT_gno_pubnames);
4449 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4450 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
4451 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4452 options::OPT_gpubnames)
4454 :
"-ggnu-pubnames");
4455 const auto *SimpleTemplateNamesArg =
4456 Args.getLastArg(options::OPT_gsimple_template_names,
4457 options::OPT_gno_simple_template_names);
4458 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4459 if (SimpleTemplateNamesArg &&
4461 const auto &Opt = SimpleTemplateNamesArg->getOption();
4462 if (Opt.matches(options::OPT_gsimple_template_names)) {
4463 ForwardTemplateParams =
true;
4464 CmdArgs.push_back(
"-gsimple-template-names=simple");
4468 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4469 StringRef
v = A->getValue();
4470 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4473 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4474 options::OPT_fno_debug_ranges_base_address);
4479 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4480 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4483 CmdArgs.push_back(
"-mllvm");
4484 CmdArgs.push_back(
"-generate-arange-section");
4487 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4488 options::OPT_fno_force_dwarf_frame);
4490 if (Args.hasFlag(options::OPT_fdebug_types_section,
4491 options::OPT_fno_debug_types_section,
false)) {
4492 if (!(T.isOSBinFormatELF() || T.isOSBinFormatWasm())) {
4493 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4494 << Args.getLastArg(options::OPT_fdebug_types_section)
4498 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4500 CmdArgs.push_back(
"-mllvm");
4501 CmdArgs.push_back(
"-generate-type-units");
4508 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4509 options::OPT_fno_dwarf_directory_asm,
4511 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4515 if (ForwardTemplateParams)
4516 CmdArgs.push_back(
"-debug-forward-template-params");
4520 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4521 CmdArgs.push_back(
"-dwarf-explicit-import");
4527 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
4529 if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
4530 CmdArgs.push_back(
"-fjmc");
4532 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"/JMC"
4535 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
4538 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
4543 const char *DebugCompilationDir =
4555 ArgStringList &CmdArgs) {
4556 unsigned RTOptionID = options::OPT__SLASH_MT;
4558 if (Args.hasArg(options::OPT__SLASH_LDd))
4561 RTOptionID = options::OPT__SLASH_MTd;
4563 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4564 RTOptionID = A->getOption().getID();
4566 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4567 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4568 .Case(
"static", options::OPT__SLASH_MT)
4569 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4570 .Case(
"dll", options::OPT__SLASH_MD)
4571 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4572 .Default(options::OPT__SLASH_MT);
4575 StringRef FlagForCRT;
4576 switch (RTOptionID) {
4577 case options::OPT__SLASH_MD:
4578 if (Args.hasArg(options::OPT__SLASH_LDd))
4579 CmdArgs.push_back(
"-D_DEBUG");
4580 CmdArgs.push_back(
"-D_MT");
4581 CmdArgs.push_back(
"-D_DLL");
4582 FlagForCRT =
"--dependent-lib=msvcrt";
4584 case options::OPT__SLASH_MDd:
4585 CmdArgs.push_back(
"-D_DEBUG");
4586 CmdArgs.push_back(
"-D_MT");
4587 CmdArgs.push_back(
"-D_DLL");
4588 FlagForCRT =
"--dependent-lib=msvcrtd";
4590 case options::OPT__SLASH_MT:
4591 if (Args.hasArg(options::OPT__SLASH_LDd))
4592 CmdArgs.push_back(
"-D_DEBUG");
4593 CmdArgs.push_back(
"-D_MT");
4594 CmdArgs.push_back(
"-flto-visibility-public-std");
4595 FlagForCRT =
"--dependent-lib=libcmt";
4597 case options::OPT__SLASH_MTd:
4598 CmdArgs.push_back(
"-D_DEBUG");
4599 CmdArgs.push_back(
"-D_MT");
4600 CmdArgs.push_back(
"-flto-visibility-public-std");
4601 FlagForCRT =
"--dependent-lib=libcmtd";
4604 llvm_unreachable(
"Unexpected option ID.");
4607 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4608 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4610 CmdArgs.push_back(FlagForCRT.data());
4615 CmdArgs.push_back(
"--dependent-lib=oldnames");
4621 const ArgList &Args,
const char *LinkingOutput)
const {
4623 const llvm::Triple &RawTriple = TC.
getTriple();
4625 const std::string &TripleStr = Triple.getTriple();
4628 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4630 ArgStringList CmdArgs;
4632 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4644 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4647 bool IsHostOffloadingAction =
4650 Args.hasFlag(options::OPT_offload_new_driver,
4651 options::OPT_no_offload_new_driver,
false));
4654 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4655 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4656 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4660 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4664 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4668 const InputInfo *CudaDeviceInput =
nullptr;
4669 const InputInfo *OpenMPDeviceInput =
nullptr;
4671 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4673 }
else if (IsExtractAPI) {
4674 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4675 if (I.getType() != ExpectedInputType) {
4676 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4680 ExtractAPIInputs.push_back(I);
4681 }
else if (IsHostOffloadingAction) {
4682 HostOffloadingInputs.push_back(I);
4683 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4684 CudaDeviceInput = &I;
4685 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4686 OpenMPDeviceInput = &I;
4688 llvm_unreachable(
"unexpectedly given multiple inputs");
4692 const llvm::Triple *AuxTriple =
4694 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4695 bool IsIAMCU = RawTriple.isOSIAMCU();
4700 if (IsCuda || IsHIP)
4701 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4705 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4710 CmdArgs.push_back(
"-cc1");
4713 CmdArgs.push_back(
"-triple");
4714 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4716 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4717 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4718 Args.ClaimAllArgs(options::OPT_MJ);
4719 }
else if (
const Arg *GenCDBFragment =
4720 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4721 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4722 TripleStr, Output, Input, Args);
4723 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4726 if (IsCuda || IsHIP) {
4729 std::string NormalizedTriple;
4747 assert(CTC &&
"Expected valid CUDA Toolchain.");
4749 CmdArgs.push_back(Args.MakeArgString(
4750 Twine(
"-target-sdk-version=") +
4758 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4761 CmdArgs.push_back(
"-aux-triple");
4762 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4767 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4768 CmdArgs.push_back(Args.MakeArgString(
4770 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4773 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4779 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
4782 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4783 CmdArgs.push_back(
"-fsycl-is-device");
4785 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4786 A->render(Args, CmdArgs);
4789 CmdArgs.push_back(
"-sycl-std=2020");
4793 if (IsOpenMPDevice) {
4795 std::string NormalizedTriple =
4799 CmdArgs.push_back(
"-aux-triple");
4800 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4803 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4804 Triple.getArch() == llvm::Triple::thumb)) {
4805 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4806 unsigned Version = 0;
4808 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
4809 if (Failure || Version < 7)
4810 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4820 if (Triple.isSPIR() || Triple.isSPIRV())
4821 CmdArgs.push_back(
"-Wspir-compat");
4824 RewriteKind rewriteKind = RK_None;
4826 bool UnifiedLTO =
false;
4828 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
4829 options::OPT_fno_unified_lto, Triple.isPS());
4831 CmdArgs.push_back(
"-funified-lto");
4841 if (!isa<AssembleJobAction>(JA)) {
4845 Args.ClaimAllArgs(options::OPT_mrelax_all);
4846 Args.ClaimAllArgs(options::OPT_mno_relax_all);
4847 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4848 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4849 switch (
C.getDefaultToolChain().getArch()) {
4850 case llvm::Triple::arm:
4851 case llvm::Triple::armeb:
4852 case llvm::Triple::thumb:
4853 case llvm::Triple::thumbeb:
4854 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4860 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4861 Args.ClaimAllArgs(options::OPT_Xassembler);
4862 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
4865 if (isa<AnalyzeJobAction>(JA)) {
4866 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
4867 CmdArgs.push_back(
"-analyze");
4868 }
else if (isa<MigrateJobAction>(JA)) {
4869 CmdArgs.push_back(
"-migrate");
4870 }
else if (isa<PreprocessJobAction>(JA)) {
4871 if (Output.
getType() == types::TY_Dependencies)
4872 CmdArgs.push_back(
"-Eonly");
4874 CmdArgs.push_back(
"-E");
4875 if (Args.hasArg(options::OPT_rewrite_objc) &&
4876 !Args.hasArg(options::OPT_g_Group))
4877 CmdArgs.push_back(
"-P");
4878 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
4879 CmdArgs.push_back(
"-fdirectives-only");
4881 }
else if (isa<AssembleJobAction>(JA)) {
4882 CmdArgs.push_back(
"-emit-obj");
4887 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4888 }
else if (isa<PrecompileJobAction>(JA)) {
4889 if (JA.
getType() == types::TY_Nothing)
4890 CmdArgs.push_back(
"-fsyntax-only");
4891 else if (JA.
getType() == types::TY_ModuleFile)
4892 CmdArgs.push_back(
"-emit-module-interface");
4893 else if (JA.
getType() == types::TY_HeaderUnit)
4894 CmdArgs.push_back(
"-emit-header-unit");
4896 CmdArgs.push_back(
"-emit-pch");
4897 }
else if (isa<VerifyPCHJobAction>(JA)) {
4898 CmdArgs.push_back(
"-verify-pch");
4899 }
else if (isa<ExtractAPIJobAction>(JA)) {
4900 assert(JA.
getType() == types::TY_API_INFO &&
4901 "Extract API actions must generate a API information.");
4902 CmdArgs.push_back(
"-extract-api");
4903 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
4904 ProductNameArg->render(Args, CmdArgs);
4905 if (Arg *ExtractAPIIgnoresFileArg =
4906 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
4907 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
4909 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
4910 "Invalid action for clang tool.");
4911 if (JA.
getType() == types::TY_Nothing) {
4912 CmdArgs.push_back(
"-fsyntax-only");
4913 }
else if (JA.
getType() == types::TY_LLVM_IR ||
4914 JA.
getType() == types::TY_LTO_IR) {
4915 CmdArgs.push_back(
"-emit-llvm");
4916 }
else if (JA.
getType() == types::TY_LLVM_BC ||
4917 JA.
getType() == types::TY_LTO_BC) {
4919 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
4920 Args.hasArg(options::OPT_emit_llvm)) {
4921 CmdArgs.push_back(
"-emit-llvm");
4923 CmdArgs.push_back(
"-emit-llvm-bc");
4925 }
else if (JA.
getType() == types::TY_IFS ||
4926 JA.
getType() == types::TY_IFS_CPP) {
4928 Args.hasArg(options::OPT_interface_stub_version_EQ)
4929 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
4931 CmdArgs.push_back(
"-emit-interface-stubs");
4933 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
4934 }
else if (JA.
getType() == types::TY_PP_Asm) {
4935 CmdArgs.push_back(
"-S");
4936 }
else if (JA.
getType() == types::TY_AST) {
4937 CmdArgs.push_back(
"-emit-pch");
4938 }
else if (JA.
getType() == types::TY_ModuleFile) {
4939 CmdArgs.push_back(
"-module-file-info");
4940 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
4941 CmdArgs.push_back(
"-rewrite-objc");
4942 rewriteKind = RK_NonFragile;
4943 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
4944 CmdArgs.push_back(
"-rewrite-objc");
4945 rewriteKind = RK_Fragile;
4947 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
4954 if (JA.
getType() == types::TY_LLVM_BC)
4955 CmdArgs.push_back(
"-emit-llvm-uselists");
4959 !Args.hasFlag(options::OPT_offload_new_driver,
4960 options::OPT_no_offload_new_driver,
false) &&
4961 !Triple.isAMDGPU()) {
4962 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4963 << Args.getLastArg(options::OPT_foffload_lto,
4964 options::OPT_foffload_lto_EQ)
4966 << Triple.getTriple();
4967 }
else if (Triple.isNVPTX() && !IsRDCMode &&
4969 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
4970 << Args.getLastArg(options::OPT_foffload_lto,
4971 options::OPT_foffload_lto_EQ)
4976 CmdArgs.push_back(Args.MakeArgString(
4977 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
4980 if (!RawTriple.isPS4() ||
4982 CmdArgs.push_back(
"-flto-unit");
4987 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
4989 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
4991 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
4992 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
4995 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
4996 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
4998 if (Args.getLastArg(options::OPT_save_temps_EQ))
4999 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5001 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5002 options::OPT_fmemory_profile_EQ,
5003 options::OPT_fno_memory_profile);
5005 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5006 MemProfArg->render(Args, CmdArgs);
5008 if (
auto *MemProfUseArg =
5009 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5011 D.
Diag(diag::err_drv_argument_not_allowed_with)
5012 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5013 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5014 options::OPT_fprofile_generate_EQ))
5015 D.
Diag(diag::err_drv_argument_not_allowed_with)
5016 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5017 MemProfUseArg->render(Args, CmdArgs);
5022 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5023 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
5025 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5027 CmdArgs.push_back(
"-disable-llvm-passes");
5034 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5035 options::OPT_mkernel,
5036 options::OPT_fapple_kext,
5037 options::OPT_ffunction_sections,
5038 options::OPT_fno_function_sections,
5039 options::OPT_fdata_sections,
5040 options::OPT_fno_data_sections,
5041 options::OPT_fbasic_block_sections_EQ,
5042 options::OPT_funique_internal_linkage_names,
5043 options::OPT_fno_unique_internal_linkage_names,
5044 options::OPT_funique_section_names,
5045 options::OPT_fno_unique_section_names,
5046 options::OPT_funique_basic_block_section_names,
5047 options::OPT_fno_unique_basic_block_section_names,
5048 options::OPT_mrestrict_it,
5049 options::OPT_mno_restrict_it,
5050 options::OPT_mstackrealign,
5051 options::OPT_mno_stackrealign,
5052 options::OPT_mstack_alignment,
5053 options::OPT_mcmodel_EQ,
5054 options::OPT_mlong_calls,
5055 options::OPT_mno_long_calls,
5056 options::OPT_ggnu_pubnames,
5057 options::OPT_gdwarf_aranges,
5058 options::OPT_fdebug_types_section,
5059 options::OPT_fno_debug_types_section,
5060 options::OPT_fdwarf_directory_asm,
5061 options::OPT_fno_dwarf_directory_asm,
5062 options::OPT_mrelax_all,
5063 options::OPT_mno_relax_all,
5064 options::OPT_ftrap_function_EQ,
5065 options::OPT_ffixed_r9,
5066 options::OPT_mfix_cortex_a53_835769,
5067 options::OPT_mno_fix_cortex_a53_835769,
5068 options::OPT_ffixed_x18,
5069 options::OPT_mglobal_merge,
5070 options::OPT_mno_global_merge,
5071 options::OPT_mred_zone,
5072 options::OPT_mno_red_zone,
5073 options::OPT_Wa_COMMA,
5074 options::OPT_Xassembler,
5077 for (
const auto &A : Args)
5078 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5079 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5082 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5083 options::OPT_fno_optimize_sibling_calls);
5091 case llvm::Triple::arm:
5092 case llvm::Triple::armeb:
5093 case llvm::Triple::thumbeb:
5094 RenderARMABI(D, Triple, Args, CmdArgs);
5096 case llvm::Triple::aarch64:
5097 case llvm::Triple::aarch64_32:
5098 case llvm::Triple::aarch64_be:
5099 RenderAArch64ABI(Triple, Args, CmdArgs);
5104 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5105 if (A->getOption().matches(options::OPT_O4)) {
5106 CmdArgs.push_back(
"-O3");
5107 D.
Diag(diag::warn_O4_is_O3);
5109 A->render(Args, CmdArgs);
5114 if (Output.
getType() == types::TY_Dependencies) {
5117 CmdArgs.push_back(
"-o");
5120 assert(Output.
isNothing() &&
"Input output.");
5123 for (
const auto &II : Inputs) {
5125 if (II.isFilename())
5126 CmdArgs.push_back(II.getFilename());
5128 II.getInputArg().renderAsInput(Args, CmdArgs);
5131 C.addCommand(std::make_unique<Command>(
5137 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5138 CmdArgs.push_back(
"-fembed-bitcode=marker");
5143 if (!
C.isForDiagnostics())
5144 CmdArgs.push_back(
"-disable-free");
5145 CmdArgs.push_back(
"-clear-ast-before-backend");
5148 const bool IsAssertBuild =
false;
5150 const bool IsAssertBuild =
true;
5155 CmdArgs.push_back(
"-disable-llvm-verifier");
5158 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5159 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5160 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5162 return types::isLLVMIR(II.getType());
5164 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5166 CmdArgs.push_back(
"-discard-value-names");
5171 CmdArgs.push_back(
"-main-file-name");
5176 if (Args.hasArg(options::OPT_static))
5177 CmdArgs.push_back(
"-static-define");
5179 if (Args.hasArg(options::OPT_municode))
5180 CmdArgs.push_back(
"-DUNICODE");
5182 if (isa<AnalyzeJobAction>(JA))
5185 if (isa<AnalyzeJobAction>(JA) ||
5186 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5187 CmdArgs.push_back(
"-setup-static-analyzer");
5192 bool FoundAnalyzerConfig =
false;
5193 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5194 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5195 FoundAnalyzerConfig =
true;
5198 if (!FoundAnalyzerConfig)
5199 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5200 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5201 FoundAnalyzerConfig =
true;
5204 if (FoundAnalyzerConfig)
5205 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5210 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5211 if (FunctionAlignment) {
5212 CmdArgs.push_back(
"-function-alignment");
5213 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5218 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5220 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5222 << A->getAsString(Args) << A->getValue();
5224 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5225 << A->getAsString(Args) << A->getValue();
5228 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5229 Twine(std::min(
Value, 65536u))));
5232 if (Triple.isOSzOS()) {
5241 auto findMacroDefinition = [&](
const std::string &Macro) {
5242 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5243 return std::find_if(MacroDefs.begin(), MacroDefs.end(),
5244 [&](
const std::string &M) {
5245 return M == Macro ||
5246 M.find(Macro +
'=') != std::string::npos;
5247 }) != MacroDefs.end();
5251 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5252 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5254 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5255 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5258 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5259 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5263 llvm::Reloc::Model RelocationModel;
5266 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5267 Arg *LastPICDataRelArg =
5268 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5269 options::OPT_mpic_data_is_text_relative);
5270 bool NoPICDataIsTextRelative =
false;
5271 if (LastPICDataRelArg) {
5272 if (LastPICDataRelArg->getOption().matches(
5273 options::OPT_mno_pic_data_is_text_relative)) {
5274 NoPICDataIsTextRelative =
true;
5276 D.
Diag(diag::err_drv_argument_only_allowed_with)
5277 <<
"-mno-pic-data-is-text-relative"
5280 if (!Triple.isSystemZ())
5281 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5282 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5283 :
"-mpic-data-is-text-relative")
5287 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5288 RelocationModel == llvm::Reloc::ROPI_RWPI;
5289 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5290 RelocationModel == llvm::Reloc::ROPI_RWPI;
5292 if (Args.hasArg(options::OPT_mcmse) &&
5293 !Args.hasArg(options::OPT_fallow_unsupported)) {
5295 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5297 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5301 !Args.hasArg(options::OPT_fallow_unsupported))
5302 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5306 CmdArgs.push_back(
"-mrelocation-model");
5307 CmdArgs.push_back(RMName);
5310 CmdArgs.push_back(
"-pic-level");
5311 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5313 CmdArgs.push_back(
"-pic-is-pie");
5314 if (NoPICDataIsTextRelative)
5315 CmdArgs.push_back(
"-mcmodel=medium");
5318 if (RelocationModel == llvm::Reloc::ROPI ||
5319 RelocationModel == llvm::Reloc::ROPI_RWPI)
5320 CmdArgs.push_back(
"-fropi");
5321 if (RelocationModel == llvm::Reloc::RWPI ||
5322 RelocationModel == llvm::Reloc::ROPI_RWPI)
5323 CmdArgs.push_back(
"-frwpi");
5325 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5326 CmdArgs.push_back(
"-meabi");
5327 CmdArgs.push_back(A->getValue());
5341 if (Triple.isOSBinFormatELF()) {
5342 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5343 options::OPT_fno_semantic_interposition);
5344 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5346 bool SupportsLocalAlias =
5347 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5349 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5350 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5351 A->render(Args, CmdArgs);
5352 else if (!SupportsLocalAlias)
5353 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5359 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5361 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5362 << A->getValue() << A->getAsString(Args);
5363 Model = A->getValue();
5366 if (Model !=
"posix") {
5367 CmdArgs.push_back(
"-mthread-model");
5368 CmdArgs.push_back(Args.MakeArgString(Model));
5372 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5373 StringRef Name = A->getValue();
5374 if (Name ==
"SVML") {
5375 if (Triple.getArch() != llvm::Triple::x86 &&
5376 Triple.getArch() != llvm::Triple::x86_64)
5377 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5378 << Name << Triple.getArchName();
5379 }
else if (Name ==
"LIBMVEC-X86") {
5380 if (Triple.getArch() != llvm::Triple::x86 &&
5381 Triple.getArch() != llvm::Triple::x86_64)
5382 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5383 << Name << Triple.getArchName();
5384 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5385 if (Triple.getArch() != llvm::Triple::aarch64 &&
5386 Triple.getArch() != llvm::Triple::aarch64_be)
5387 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5388 << Name << Triple.getArchName();
5390 A->render(Args, CmdArgs);
5393 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5394 options::OPT_fno_merge_all_constants,
false))
5395 CmdArgs.push_back(
"-fmerge-all-constants");
5397 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5398 options::OPT_fno_delete_null_pointer_checks);
5402 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5403 if (!Triple.isOSAIX() || Triple.isPPC32())
5404 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5405 << A->getSpelling() << RawTriple.str();
5406 CmdArgs.push_back(
"-mabi=quadword-atomics");
5409 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5412 if (Triple.isOSAIX())
5413 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5414 << A->getSpelling() << RawTriple.str();
5417 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5418 StringRef
V = A->getValue(), V1 =
V;
5420 if (V1.consumeInteger(10, Size) || !V1.empty())
5421 D.
Diag(diag::err_drv_invalid_argument_to_option)
5422 <<
V << A->getOption().getName();
5424 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5427 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5428 options::OPT_fno_jump_tables);
5429 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5430 options::OPT_fno_profile_sample_accurate);
5431 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5432 options::OPT_fno_preserve_as_comments);
5434 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5435 CmdArgs.push_back(
"-mregparm");
5436 CmdArgs.push_back(A->getValue());
5439 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5440 options::OPT_msvr4_struct_return)) {
5442 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5443 << A->getSpelling() << RawTriple.str();
5444 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5445 CmdArgs.push_back(
"-maix-struct-return");
5447 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5448 CmdArgs.push_back(
"-msvr4-struct-return");
5452 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5453 options::OPT_freg_struct_return)) {
5454 if (TC.
getArch() != llvm::Triple::x86) {
5455 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5456 << A->getSpelling() << RawTriple.str();
5457 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5458 CmdArgs.push_back(
"-fpcc-struct-return");
5460 assert(A->getOption().matches(options::OPT_freg_struct_return));
5461 CmdArgs.push_back(
"-freg-struct-return");
5465 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
5466 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5468 if (Args.hasArg(options::OPT_fenable_matrix)) {
5470 CmdArgs.push_back(
"-fenable-matrix");
5471 CmdArgs.push_back(
"-mllvm");
5472 CmdArgs.push_back(
"-enable-matrix");
5477 const char *FPKeepKindStr =
nullptr;
5478 switch (FPKeepKind) {
5480 FPKeepKindStr =
"-mframe-pointer=none";
5483 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5486 FPKeepKindStr =
"-mframe-pointer=all";
5489 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5490 CmdArgs.push_back(FPKeepKindStr);
5492 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5493 options::OPT_fno_zero_initialized_in_bss);
5498 OptSpecifier StrictAliasingAliasOption =
5499 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5502 bool TBAAOnByDefault = !D.
IsCLMode();
5503 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5504 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5505 CmdArgs.push_back(
"-relaxed-aliasing");
5506 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5507 options::OPT_fno_struct_path_tbaa,
true))
5508 CmdArgs.push_back(
"-no-struct-path-tbaa");
5509 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5510 options::OPT_fno_strict_enums);
5511 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5512 options::OPT_fno_strict_return);
5513 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5514 options::OPT_fno_allow_editor_placeholders);
5515 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5516 options::OPT_fno_strict_vtable_pointers);
5517 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5518 options::OPT_fno_force_emit_vtables);
5519 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5520 options::OPT_fno_optimize_sibling_calls);
5521 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5522 options::OPT_fno_escaping_block_tail_calls);
5524 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5525 options::OPT_fno_fine_grained_bitfield_accesses);
5527 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5528 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5530 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5531 options::OPT_fno_experimental_omit_vtable_rtti);
5534 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5535 options::OPT_fno_split_stack);
5538 if (Args.hasFlag(options::OPT_fprotect_parens,
5539 options::OPT_fno_protect_parens,
false))
5540 CmdArgs.push_back(
"-fprotect-parens");
5544 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5545 const llvm::Triple::ArchType Arch = TC.
getArch();
5546 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5547 StringRef
V = A->getValue();
5549 CmdArgs.push_back(
"-fextend-arguments=64");
5551 D.
Diag(diag::err_drv_invalid_argument_to_option)
5552 << A->getValue() << A->getOption().getName();
5554 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5555 << A->getOption().getName() << TripleStr;
5558 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5559 if (TC.
getArch() == llvm::Triple::avr)
5560 A->render(Args, CmdArgs);
5562 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5563 << A->getAsString(Args) << TripleStr;
5566 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5568 A->render(Args, CmdArgs);
5570 (A->getOption().getID() != options::OPT_mlong_double_80))
5571 A->render(Args, CmdArgs);
5573 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5574 << A->getAsString(Args) << TripleStr;
5580 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5581 IsIntegratedAssemblerDefault))
5582 CmdArgs.push_back(
"-fno-verbose-asm");
5586 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5587 StringRef
V = A->getValue();
5590 A->render(Args, CmdArgs);
5591 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5592 (
V.empty() || (
V.consume_front(
".") &&
5593 !
V.consumeInteger(10, Num) &&
V.empty())))
5594 A->render(Args, CmdArgs);
5596 D.
Diag(diag::err_drv_invalid_argument_to_option)
5597 << A->getValue() << A->getOption().getName();
5603 CmdArgs.push_back(
"-no-integrated-as");
5605 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5606 CmdArgs.push_back(
"-mdebug-pass");
5607 CmdArgs.push_back(
"Structure");
5609 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5610 CmdArgs.push_back(
"-mdebug-pass");
5611 CmdArgs.push_back(
"Arguments");
5617 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5618 CmdArgs.push_back(
"-mconstructor-aliases");
5622 if (KernelOrKext && RawTriple.isOSDarwin())
5623 CmdArgs.push_back(
"-fforbid-guard-variables");
5625 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5626 Triple.isWindowsGNUEnvironment())) {
5627 CmdArgs.push_back(
"-mms-bitfields");
5630 if (Triple.isWindowsGNUEnvironment()) {
5631 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5632 options::OPT_fno_auto_import);
5638 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5639 options::OPT_fno_direct_access_external_data))
5640 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5642 A->render(Args, CmdArgs);
5644 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5645 CmdArgs.push_back(
"-fno-plt");
5652 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5655 CmdArgs.push_back(
"-ffreestanding");
5657 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5664 bool IsAsyncUnwindTablesDefault =
5666 bool IsSyncUnwindTablesDefault =
5669 bool AsyncUnwindTables = Args.hasFlag(
5670 options::OPT_fasynchronous_unwind_tables,
5671 options::OPT_fno_asynchronous_unwind_tables,
5672 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5675 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5676 IsSyncUnwindTablesDefault && !Freestanding);
5677 if (AsyncUnwindTables)
5678 CmdArgs.push_back(
"-funwind-tables=2");
5679 else if (UnwindTables)
5680 CmdArgs.push_back(
"-funwind-tables=1");
5684 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5685 (IsCudaDevice || IsHIPDevice)) {
5686 const ArgList &HostArgs =
5688 std::string HostCPU =
5690 if (!HostCPU.empty()) {
5691 CmdArgs.push_back(
"-aux-target-cpu");
5692 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5700 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5701 StringRef CM = A->getValue();
5702 if (CM ==
"small" || CM ==
"kernel" || CM ==
"medium" || CM ==
"large" ||
5704 if (Triple.isOSAIX() && CM ==
"medium")
5705 CmdArgs.push_back(
"-mcmodel=large");
5706 else if (Triple.isAArch64() && (CM ==
"kernel" || CM ==
"medium"))
5707 D.
Diag(diag::err_drv_invalid_argument_to_option)
5708 << CM << A->getOption().getName();
5710 A->render(Args, CmdArgs);
5712 D.
Diag(diag::err_drv_invalid_argument_to_option)
5713 << CM << A->getOption().getName();
5717 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {
5718 if (!Triple.isX86()) {
5719 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5720 << A->getOption().getName() << TripleStr;
5722 bool IsMediumCM =
false;
5723 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ))
5724 IsMediumCM = StringRef(A->getValue()) ==
"medium";
5726 D.
Diag(diag::warn_drv_large_data_threshold_invalid_code_model)
5727 << A->getOption().getRenderName();
5729 A->render(Args, CmdArgs);
5734 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5735 StringRef
Value = A->getValue();
5736 unsigned TLSSize = 0;
5737 Value.getAsInteger(10, TLSSize);
5738 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5739 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5740 << A->getOption().getName() << TripleStr;
5741 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5742 D.
Diag(diag::err_drv_invalid_int_value)
5743 << A->getOption().getName() <<
Value;
5744 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5748 std::string CPU =
getCPUName(D, Args, Triple,
false);
5750 CmdArgs.push_back(
"-target-cpu");
5751 CmdArgs.push_back(Args.MakeArgString(CPU));
5754 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5759 AddClangCLArgs(Args, InputType, CmdArgs);
5761 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
5762 llvm::codegenoptions::NoDebugInfo;
5765 CmdArgs, Output, DebugInfoKind, DwarfFission);
5773 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5774 isa<BackendJobAction>(JA));
5776 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
5777 CmdArgs.push_back(
"-split-dwarf-file");
5778 CmdArgs.push_back(SplitDWARFOut);
5780 CmdArgs.push_back(
"-split-dwarf-output");
5781 CmdArgs.push_back(SplitDWARFOut);
5786 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5787 CmdArgs.push_back(
"-target-linker-version");
5788 CmdArgs.push_back(A->getValue());
5793 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
5795 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
5796 TC.
getArch() == llvm::Triple::x86) {
5797 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
5798 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
5799 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
5800 << Unsupported->getOption().getName();
5803 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
5804 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5805 << Unsupported->getOption().getName()
5806 <<
"please use -maltivec and include altivec.h explicitly";
5807 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
5808 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5809 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
5812 Args.AddAllArgs(CmdArgs, options::OPT_v);
5814 if (Args.getLastArg(options::OPT_H)) {
5815 CmdArgs.push_back(
"-H");
5816 CmdArgs.push_back(
"-sys-header-deps");
5818 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
5821 CmdArgs.push_back(
"-header-include-file");
5825 CmdArgs.push_back(
"-sys-header-deps");
5826 CmdArgs.push_back(Args.MakeArgString(
5827 "-header-include-format=" +
5830 Args.MakeArgString(
"-header-include-filtering=" +
5834 Args.AddLastArg(CmdArgs, options::OPT_P);
5835 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
5838 CmdArgs.push_back(
"-diagnostic-log-file");
5847 CmdArgs.push_back(
"-disable-pragma-debug-crash");
5851 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
5852 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
5853 CmdArgs.push_back(
"-mllvm");
5854 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
5859 if (Args.hasFlag(options::OPT_ffunction_sections,
5860 options::OPT_fno_function_sections, UseSeparateSections)) {
5861 CmdArgs.push_back(
"-ffunction-sections");
5864 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
5865 StringRef Val = A->getValue();
5866 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5867 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
5868 !Val.startswith(
"list="))
5869 D.
Diag(diag::err_drv_invalid_value)
5870 << A->getAsString(Args) << A->getValue();
5872 A->render(Args, CmdArgs);
5873 }
else if (Triple.isNVPTX()) {
5876 }
else if (Val !=
"none") {
5879 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5880 << A->getAsString(Args) << TripleStr;
5884 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
5885 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
5886 UseSeparateSections || HasDefaultDataSections)) {
5887 CmdArgs.push_back(
"-fdata-sections");
5890 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
5891 options::OPT_fno_unique_section_names);
5892 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
5893 options::OPT_fno_unique_internal_linkage_names);
5894 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
5895 options::OPT_fno_unique_basic_block_section_names);
5896 Args.addOptInFlag(CmdArgs, options::OPT_fconvergent_functions,
5897 options::OPT_fno_convergent_functions);
5899 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
5900 options::OPT_fno_split_machine_functions)) {
5901 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
5903 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
5904 A->render(Args, CmdArgs);
5906 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5907 << A->getAsString(Args) << TripleStr;
5911 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
5912 options::OPT_finstrument_functions_after_inlining,
5913 options::OPT_finstrument_function_entry_bare);
5918 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
5921 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
5924 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
5925 CmdArgs.push_back(
"-mllvm");
5926 CmdArgs.push_back(
"-sample-profile-use-profi");
5930 if (RawTriple.isPS() &&
5931 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
5937 if (Args.hasArg(options::OPT_nostdinc)) {
5938 CmdArgs.push_back(
"-nostdsysteminc");
5939 CmdArgs.push_back(
"-nobuiltininc");
5941 if (Args.hasArg(options::OPT_nostdlibinc))
5942 CmdArgs.push_back(
"-n