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/RISCVTargetParser.h"
68 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
69 options::OPT_fminimize_whitespace,
70 options::OPT_fno_minimize_whitespace)) {
71 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
72 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
73 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
74 << A->getBaseArg().getAsString(Args)
75 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
82 if (Args.hasArg(options::OPT_static))
84 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
85 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
112 llvm::function_ref<
void(
const ToolChain &)> Work) {
114 Work(RegularToolChain);
129 for (
auto II = TCs.first, IE = TCs.second; II != IE; ++II)
144 const Arg &A,
size_t &Position) {
145 const char RefinementStepToken =
':';
146 Position = In.find(RefinementStepToken);
147 if (Position != StringRef::npos) {
148 StringRef Option = A.getOption().getName();
149 StringRef RefStep = In.substr(Position + 1);
157 if (RefStep.size() != 1) {
158 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
161 char RefStepChar = RefStep[0];
162 if (RefStepChar <
'0' || RefStepChar >
'9') {
163 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
172 ArgStringList &OutStrings) {
173 StringRef DisabledPrefixIn =
"!";
174 StringRef DisabledPrefixOut =
"!";
175 StringRef EnabledPrefixOut =
"";
176 StringRef Out =
"-mrecip=";
178 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
182 unsigned NumOptions = A->getNumValues();
183 if (NumOptions == 0) {
185 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
190 if (NumOptions == 1) {
191 StringRef Val = A->getValue(0);
195 StringRef ValBase = Val.slice(0, RefStepLoc);
196 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
197 OutStrings.push_back(Args.MakeArgString(Out + Val));
206 llvm::StringMap<bool> OptionStrings;
207 OptionStrings.insert(std::make_pair(
"divd",
false));
208 OptionStrings.insert(std::make_pair(
"divf",
false));
209 OptionStrings.insert(std::make_pair(
"divh",
false));
210 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
211 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
212 OptionStrings.insert(std::make_pair(
"vec-divh",
false));
213 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
214 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
215 OptionStrings.insert(std::make_pair(
"sqrth",
false));
216 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
217 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
218 OptionStrings.insert(std::make_pair(
"vec-sqrth",
false));
220 for (
unsigned i = 0; i != NumOptions; ++i) {
221 StringRef Val = A->getValue(i);
223 bool IsDisabled = Val.startswith(DisabledPrefixIn);
232 StringRef ValBase = Val.slice(0, RefStep);
233 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
234 if (OptionIter == OptionStrings.end()) {
236 OptionIter = OptionStrings.find(ValBase.str() +
'f');
237 if (OptionIter == OptionStrings.end()) {
239 D.
Diag(diag::err_drv_unknown_argument) << Val;
245 if (OptionStrings[ValBase.str() +
'd'] ||
246 OptionStrings[ValBase.str() +
'h']) {
247 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
252 if (OptionIter->second ==
true) {
254 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
259 OptionIter->second =
true;
263 if (ValBase.back() !=
'f' && ValBase.back() !=
'd' && ValBase.back() !=
'h') {
264 OptionStrings[ValBase.str() +
'd'] =
true;
265 OptionStrings[ValBase.str() +
'h'] =
true;
269 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
270 Out = Args.MakeArgString(Out + Prefix + Val);
271 if (i != NumOptions - 1)
272 Out = Args.MakeArgString(Out +
",");
275 OutStrings.push_back(Args.MakeArgString(Out));
281 ArgStringList &CmdArgs) {
282 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
286 StringRef
Value = A->getValue();
287 if (
Value ==
"none") {
288 CmdArgs.push_back(
"-mprefer-vector-width=none");
291 if (
Value.getAsInteger(10, Width)) {
292 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
295 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" +
Value));
301 const llvm::Triple &Triple) {
308 if (!Triple.isMacOSX())
311 return (!Triple.isMacOSXVersionLT(10, 5) &&
312 (Triple.getArch() == llvm::Triple::x86_64 ||
313 Triple.getArch() == llvm::Triple::arm));
323 ArgStringList &CmdArgs) {
324 const llvm::Triple &Triple = TC.
getTriple();
329 Args.ClaimAllArgs(options::OPT_fexceptions);
330 Args.ClaimAllArgs(options::OPT_fno_exceptions);
331 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
332 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
333 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
334 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
335 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
336 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
341 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
344 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
345 options::OPT_fno_async_exceptions,
false);
347 CmdArgs.push_back(
"-fasync-exceptions");
354 Args.hasFlag(options::OPT_fobjc_exceptions,
355 options::OPT_fno_objc_exceptions,
true)) {
356 CmdArgs.push_back(
"-fobjc-exceptions");
363 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
364 !Triple.isPS() && !Triple.isDriverKit();
365 Arg *ExceptionArg = Args.getLastArg(
366 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
367 options::OPT_fexceptions, options::OPT_fno_exceptions);
369 CXXExceptionsEnabled =
370 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
371 ExceptionArg->getOption().matches(options::OPT_fexceptions);
373 if (CXXExceptionsEnabled) {
374 CmdArgs.push_back(
"-fcxx-exceptions");
383 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
386 CmdArgs.push_back(
"-fexceptions");
402 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
407 switch (Triple.getArch()){
410 case llvm::Triple::arm:
411 case llvm::Triple::thumb:
414 return Triple.isOSDarwin();
419 const llvm::Triple &Triple) {
420 if (Args.hasArg(options::OPT_pg) && !Args.hasArg(options::OPT_mfentry))
423 if (Triple.isAndroid()) {
424 switch (Triple.getArch()) {
425 case llvm::Triple::aarch64:
426 case llvm::Triple::arm:
427 case llvm::Triple::armeb:
428 case llvm::Triple::thumb:
429 case llvm::Triple::thumbeb:
430 case llvm::Triple::riscv64:
437 switch (Triple.getArch()) {
438 case llvm::Triple::xcore:
439 case llvm::Triple::wasm32:
440 case llvm::Triple::wasm64:
441 case llvm::Triple::msp430:
445 case llvm::Triple::ppc:
446 case llvm::Triple::ppcle:
447 case llvm::Triple::ppc64:
448 case llvm::Triple::ppc64le:
449 case llvm::Triple::riscv32:
450 case llvm::Triple::riscv64:
451 case llvm::Triple::sparc:
452 case llvm::Triple::sparcel:
453 case llvm::Triple::sparcv9:
454 case llvm::Triple::amdgcn:
455 case llvm::Triple::r600:
456 case llvm::Triple::csky:
457 case llvm::Triple::loongarch32:
458 case llvm::Triple::loongarch64:
464 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
468 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI ||
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;
719 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
720 options::OPT_fcs_profile_generate_EQ,
721 options::OPT_fno_profile_generate);
722 if (CSPGOGenerateArg &&
723 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
724 CSPGOGenerateArg =
nullptr;
726 auto *ProfileGenerateArg = Args.getLastArg(
727 options::OPT_fprofile_instr_generate,
728 options::OPT_fprofile_instr_generate_EQ,
729 options::OPT_fno_profile_instr_generate);
730 if (ProfileGenerateArg &&
731 ProfileGenerateArg->getOption().matches(
732 options::OPT_fno_profile_instr_generate))
733 ProfileGenerateArg =
nullptr;
735 if (PGOGenerateArg && ProfileGenerateArg)
736 D.
Diag(diag::err_drv_argument_not_allowed_with)
737 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
741 if (PGOGenerateArg && ProfileUseArg)
742 D.
Diag(diag::err_drv_argument_not_allowed_with)
743 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
745 if (ProfileGenerateArg && ProfileUseArg)
746 D.
Diag(diag::err_drv_argument_not_allowed_with)
747 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
749 if (CSPGOGenerateArg && PGOGenerateArg) {
750 D.
Diag(diag::err_drv_argument_not_allowed_with)
751 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
752 PGOGenerateArg =
nullptr;
757 D.
Diag(diag::err_drv_unsupported_opt_for_target)
758 << ProfileSampleUseArg->getSpelling() << TC.
getTriple().str();
761 if (ProfileGenerateArg) {
762 if (ProfileGenerateArg->getOption().matches(
763 options::OPT_fprofile_instr_generate_EQ))
764 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instrument-path=") +
765 ProfileGenerateArg->getValue()));
767 CmdArgs.push_back(
"-fprofile-instrument=clang");
768 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
770 CmdArgs.push_back(Args.MakeArgString(
775 Arg *PGOGenArg =
nullptr;
776 if (PGOGenerateArg) {
777 assert(!CSPGOGenerateArg);
778 PGOGenArg = PGOGenerateArg;
779 CmdArgs.push_back(
"-fprofile-instrument=llvm");
781 if (CSPGOGenerateArg) {
782 assert(!PGOGenerateArg);
783 PGOGenArg = CSPGOGenerateArg;
784 CmdArgs.push_back(
"-fprofile-instrument=csllvm");
787 if (TC.
getTriple().isWindowsMSVCEnvironment()) {
789 CmdArgs.push_back(Args.MakeArgString(
792 if (PGOGenArg->getOption().matches(
793 PGOGenerateArg ? options::OPT_fprofile_generate_EQ
794 : options::OPT_fcs_profile_generate_EQ)) {
796 llvm::sys::path::append(Path,
"default_%m.profraw");
798 Args.MakeArgString(Twine(
"-fprofile-instrument-path=") + Path));
803 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
804 CmdArgs.push_back(Args.MakeArgString(
805 Twine(
"-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
806 else if ((ProfileUseArg->getOption().matches(
807 options::OPT_fprofile_use_EQ) ||
808 ProfileUseArg->getOption().matches(
809 options::OPT_fprofile_instr_use))) {
811 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
812 if (Path.empty() || llvm::sys::fs::is_directory(Path))
813 llvm::sys::path::append(Path,
"default.profdata");
815 Args.MakeArgString(Twine(
"-fprofile-instrument-use-path=") + Path));
819 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
820 options::OPT_fno_test_coverage,
false) ||
821 Args.hasArg(options::OPT_coverage);
824 if (Args.hasFlag(options::OPT_fcoverage_mapping,
825 options::OPT_fno_coverage_mapping,
false)) {
826 if (!ProfileGenerateArg)
827 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
828 <<
"-fcoverage-mapping"
829 <<
"-fprofile-instr-generate";
831 CmdArgs.push_back(
"-fcoverage-mapping");
834 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
835 options::OPT_fcoverage_compilation_dir_EQ)) {
836 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
837 CmdArgs.push_back(Args.MakeArgString(
838 Twine(
"-fcoverage-compilation-dir=") + A->getValue()));
840 A->render(Args, CmdArgs);
841 }
else if (llvm::ErrorOr<std::string> CWD =
842 D.
getVFS().getCurrentWorkingDirectory()) {
843 CmdArgs.push_back(Args.MakeArgString(
"-fcoverage-compilation-dir=" + *CWD));
846 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
847 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
848 if (!Args.hasArg(options::OPT_coverage))
849 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
850 <<
"-fprofile-exclude-files="
853 StringRef
v = Arg->getValue();
855 Args.MakeArgString(Twine(
"-fprofile-exclude-files=" +
v)));
858 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
859 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
860 if (!Args.hasArg(options::OPT_coverage))
861 D.
Diag(clang::diag::err_drv_argument_only_allowed_with)
862 <<
"-fprofile-filter-files="
865 StringRef
v = Arg->getValue();
866 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-filter-files=" +
v)));
869 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
870 StringRef Val = A->getValue();
871 if (Val ==
"atomic" || Val ==
"prefer-atomic")
872 CmdArgs.push_back(
"-fprofile-update=atomic");
873 else if (Val !=
"single")
874 D.
Diag(diag::err_drv_unsupported_option_argument)
875 << A->getSpelling() << Val;
877 CmdArgs.push_back(
"-fprofile-update=atomic");
880 int FunctionGroups = 1;
881 int SelectedFunctionGroup = 0;
882 if (
const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
883 StringRef Val = A->getValue();
884 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
885 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
888 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
889 StringRef Val = A->getValue();
890 if (Val.getAsInteger(0, SelectedFunctionGroup) ||
891 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
892 D.
Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
894 if (FunctionGroups != 1)
895 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-function-groups=" +
896 Twine(FunctionGroups)));
897 if (SelectedFunctionGroup != 0)
898 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-selected-function-group=" +
899 Twine(SelectedFunctionGroup)));
905 Arg *FProfileDir =
nullptr;
906 if (Args.hasArg(options::OPT_fprofile_arcs) ||
907 Args.hasArg(options::OPT_coverage))
908 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
912 (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
917 if (EmitCovNotes || EmitCovData) {
919 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
922 CoverageFilename = DumpDir->getValue();
923 CoverageFilename += llvm::sys::path::filename(Output.
getBaseInput());
924 }
else if (Arg *FinalOutput =
925 C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
926 CoverageFilename = FinalOutput->getValue();
927 }
else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT_o)) {
928 CoverageFilename = FinalOutput->getValue();
930 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
932 if (llvm::sys::path::is_relative(CoverageFilename))
933 (void)D.
getVFS().makeAbsolute(CoverageFilename);
934 llvm::sys::path::replace_extension(CoverageFilename,
"gcno");
936 CmdArgs.push_back(
"-coverage-notes-file");
937 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
943 CoverageFilename = FProfileDir->getValue();
944 llvm::sys::path::append(CoverageFilename, Gcno);
946 llvm::sys::path::replace_extension(CoverageFilename,
"gcda");
947 CmdArgs.push_back(
"-coverage-data-file");
948 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
955 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
964 bool RelaxDefault =
true;
966 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
967 RelaxDefault = A->getOption().matches(options::OPT_O0);
970 RelaxDefault =
false;
971 for (
const auto &Act :
C.getActions()) {
979 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
985 llvm::codegenoptions::DebugInfoKind DebugInfoKind,
986 unsigned DwarfVersion,
987 llvm::DebuggerKind DebuggerTuning) {
989 if (DwarfVersion > 0)
991 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
992 switch (DebuggerTuning) {
993 case llvm::DebuggerKind::GDB:
994 CmdArgs.push_back(
"-debugger-tuning=gdb");
996 case llvm::DebuggerKind::LLDB:
997 CmdArgs.push_back(
"-debugger-tuning=lldb");
999 case llvm::DebuggerKind::SCE:
1000 CmdArgs.push_back(
"-debugger-tuning=sce");
1002 case llvm::DebuggerKind::DBX:
1003 CmdArgs.push_back(
"-debugger-tuning=dbx");
1012 assert(A &&
"Expected non-nullptr argument.");
1015 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
1021 ArgStringList &CmdArgs,
1024 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
1028 StringRef
Value = A->getValue();
1029 if (
Value ==
"none") {
1030 CmdArgs.push_back(
"--compress-debug-sections=none");
1031 }
else if (
Value ==
"zlib") {
1032 if (llvm::compression::zlib::isAvailable()) {
1034 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1036 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zlib";
1038 }
else if (
Value ==
"zstd") {
1039 if (llvm::compression::zstd::isAvailable()) {
1041 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
1043 D.
Diag(diag::warn_debug_compression_unavailable) <<
"zstd";
1046 D.
Diag(diag::err_drv_unsupported_option_argument)
1047 << A->getSpelling() <<
Value;
1053 const ArgList &Args,
1054 ArgStringList &CmdArgs,
1055 bool IsCC1As =
false) {
1063 CmdArgs.insert(CmdArgs.begin() + 1,
1064 Args.MakeArgString(Twine(
"--amdhsa-code-object-version=") +
1065 Twine(CodeObjVer)));
1066 CmdArgs.insert(CmdArgs.begin() + 1,
"-mllvm");
1069 CmdArgs.insert(CmdArgs.begin() + 1,
1070 Args.MakeArgString(Twine(
"-mcode-object-version=") +
1071 Twine(CodeObjVer)));
1076 const Driver &D,
const ArgList &Args,
1077 ArgStringList &CmdArgs,
1084 Args.AddLastArg(CmdArgs, options::OPT_C);
1085 Args.AddLastArg(CmdArgs, options::OPT_CC);
1088 Arg *ArgM = Args.getLastArg(options::OPT_MM);
1090 ArgM = Args.getLastArg(options::OPT_M);
1091 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1093 ArgMD = Args.getLastArg(options::OPT_MD);
1097 CmdArgs.push_back(
"-w");
1103 const char *DepFile;
1104 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1105 DepFile = MF->getValue();
1106 C.addFailureResultFile(DepFile, &JA);
1107 }
else if (Output.
getType() == types::TY_Dependencies) {
1109 }
else if (!ArgMD) {
1113 C.addFailureResultFile(DepFile, &JA);
1115 CmdArgs.push_back(
"-dependency-file");
1116 CmdArgs.push_back(DepFile);
1118 bool HasTarget =
false;
1119 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1122 if (A->getOption().matches(options::OPT_MT)) {
1123 A->render(Args, CmdArgs);
1125 CmdArgs.push_back(
"-MT");
1128 CmdArgs.push_back(Args.MakeArgString(Quoted));
1134 const char *DepTarget;
1138 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1139 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
1140 DepTarget = OutputOpt->getValue();
1146 llvm::sys::path::replace_extension(
P,
"o");
1147 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
1150 CmdArgs.push_back(
"-MT");
1153 CmdArgs.push_back(Args.MakeArgString(Quoted));
1156 if (ArgM->getOption().matches(options::OPT_M) ||
1157 ArgM->getOption().matches(options::OPT_MD))
1158 CmdArgs.push_back(
"-sys-header-deps");
1159 if (Args.hasFlag(options::OPT_canonical_prefixes,
1160 options::OPT_no_canonical_prefixes,
true))
1161 CmdArgs.push_back(
"-canonical-system-headers");
1162 if ((isa<PrecompileJobAction>(JA) &&
1163 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1164 Args.hasArg(options::OPT_fmodule_file_deps))
1165 CmdArgs.push_back(
"-module-file-deps");
1168 if (Args.hasArg(options::OPT_MG)) {
1169 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1170 ArgM->getOption().matches(options::OPT_MMD))
1171 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
1172 CmdArgs.push_back(
"-MG");
1175 Args.AddLastArg(CmdArgs, options::OPT_MP);
1176 Args.AddLastArg(CmdArgs, options::OPT_MV);
1189 if (!Args.hasArg(options::OPT_nostdinc) &&
1190 !Args.hasArg(options::OPT_nogpuinc) &&
1191 !Args.hasArg(options::OPT_nobuiltininc) &&
1200 llvm::sys::path::append(
P,
"include");
1201 llvm::sys::path::append(
P,
"gpu-none-llvm");
1202 CmdArgs.push_back(
"-c-isystem");
1203 CmdArgs.push_back(Args.MakeArgString(
P));
1209 !Args.hasArg(options::OPT_nostdinc) &&
1210 !Args.hasArg(options::OPT_nogpuinc) &&
1213 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1217 llvm::sys::path::append(
P,
"include");
1218 llvm::sys::path::append(
P,
"openmp_wrappers");
1219 CmdArgs.push_back(
"-internal-isystem");
1220 CmdArgs.push_back(Args.MakeArgString(
P));
1223 CmdArgs.push_back(
"-include");
1224 CmdArgs.push_back(
"__clang_openmp_device_functions.h");
1234 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1235 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1238 CmdArgs.push_back(Args.MakeArgString(
"-building-pch-with-obj"));
1241 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1242 options::OPT_fno_pch_instantiate_templates,
true))
1243 CmdArgs.push_back(Args.MakeArgString(
"-fpch-instantiate-templates"));
1245 if (YcArg || YuArg) {
1246 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1247 if (!isa<PrecompileJobAction>(JA)) {
1248 CmdArgs.push_back(
"-include-pch");
1250 C, !ThroughHeader.empty()
1252 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1255 if (ThroughHeader.empty()) {
1256 CmdArgs.push_back(Args.MakeArgString(
1257 Twine(
"-pch-through-hdrstop-") + (YcArg ?
"create" :
"use")));
1260 Args.MakeArgString(Twine(
"-pch-through-header=") + ThroughHeader));
1265 bool RenderedImplicitInclude =
false;
1266 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1267 if (A->getOption().matches(options::OPT_include) &&
1270 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1271 RenderedImplicitInclude =
true;
1273 bool FoundPCH =
false;
1278 llvm::sys::path::replace_extension(
P,
"pch");
1283 llvm::sys::path::replace_extension(
P,
"gch");
1290 if (IsFirstImplicitInclude) {
1292 CmdArgs.push_back(
"-include-pch");
1293 CmdArgs.push_back(Args.MakeArgString(
P));
1297 D.
Diag(diag::warn_drv_pch_not_first_include) <<
P
1298 << A->getAsString(Args);
1301 }
else if (A->getOption().matches(options::OPT_isystem_after)) {
1308 }
else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1315 A->render(Args, CmdArgs);
1318 Args.AddAllArgs(CmdArgs,
1319 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1320 options::OPT_F, options::OPT_index_header_map});
1328 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1329 options::OPT_Xpreprocessor);
1332 if (Arg *A = Args.getLastArg(options::OPT_I_))
1333 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1337 StringRef sysroot =
C.getSysRoot();
1338 if (sysroot !=
"") {
1339 if (!Args.hasArg(options::OPT_isysroot)) {
1340 CmdArgs.push_back(
"-isysroot");
1341 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
1358 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
1366 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1369 [&Args, &CmdArgs, HasStdlibxxIsystem](
const ToolChain &TC) {
1378 [&Args, &CmdArgs](
const ToolChain &TC) {
1389 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1390 options::OPT_fno_file_reproducible);
1392 if (
const char *Epoch = std::getenv(
"SOURCE_DATE_EPOCH")) {
1393 CmdArgs.push_back(
"-source-date-epoch");
1394 CmdArgs.push_back(Args.MakeArgString(Epoch));
1400 switch (Triple.getArch()) {
1404 case llvm::Triple::aarch64:
1405 case llvm::Triple::aarch64_32:
1406 case llvm::Triple::aarch64_be:
1407 case llvm::Triple::arm:
1408 case llvm::Triple::armeb:
1409 case llvm::Triple::thumb:
1410 case llvm::Triple::thumbeb:
1411 if (Triple.isOSDarwin() || Triple.isOSWindows())
1415 case llvm::Triple::ppc:
1416 case llvm::Triple::ppc64:
1417 if (Triple.isOSDarwin())
1421 case llvm::Triple::hexagon:
1422 case llvm::Triple::ppcle:
1423 case llvm::Triple::ppc64le:
1424 case llvm::Triple::riscv32:
1425 case llvm::Triple::riscv64:
1426 case llvm::Triple::systemz:
1427 case llvm::Triple::xcore:
1433 const ArgList &Args) {
1436 if (!Triple.isOSDarwin())
1440 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1444 const llvm::Triple &Triple) {
1449 bool hasExplicitOutputFile =
1450 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1452 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
1453 <<
"-foptimization-record-file";
1460 const llvm::Triple &Triple,
1463 StringRef Format =
"yaml";
1464 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1465 Format = A->getValue();
1467 CmdArgs.push_back(
"-opt-record-file");
1469 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1471 CmdArgs.push_back(A->getValue());
1473 bool hasMultipleArchs =
1474 Triple.isOSDarwin() &&
1475 Args.getAllArgValues(options::OPT_arch).size() > 1;
1479 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1480 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1481 F = FinalOutput->getValue();
1483 if (Format !=
"yaml" &&
1484 Triple.isOSDarwin() &&
1498 llvm::sys::path::replace_extension(F,
"");
1500 Triple.normalize());
1510 if (hasMultipleArchs) {
1514 llvm::sys::path::replace_extension(F,
"");
1517 F += Triple.getArchName();
1519 llvm::sys::path::replace_extension(F, OldExtension);
1523 Extension +=
"opt.";
1524 Extension += Format;
1526 llvm::sys::path::replace_extension(F, Extension);
1527 CmdArgs.push_back(Args.MakeArgString(F));
1531 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1532 CmdArgs.push_back(
"-opt-record-passes");
1533 CmdArgs.push_back(A->getValue());
1536 if (!Format.empty()) {
1537 CmdArgs.push_back(
"-opt-record-format");
1538 CmdArgs.push_back(Format.data());
1543 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1544 options::OPT_fno_aapcs_bitfield_width,
true))
1545 CmdArgs.push_back(
"-fno-aapcs-bitfield-width");
1547 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1548 CmdArgs.push_back(
"-faapcs-bitfield-load");
1552void RenderARMABI(
const Driver &D,
const llvm::Triple &Triple,
1553 const ArgList &Args, ArgStringList &CmdArgs) {
1557 const char *ABIName =
nullptr;
1558 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1559 ABIName = A->getValue();
1561 std::string CPU =
getCPUName(D, Args, Triple,
false);
1562 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1565 CmdArgs.push_back(
"-target-abi");
1566 CmdArgs.push_back(ABIName);
1569void AddUnalignedAccessWarning(ArgStringList &CmdArgs) {
1570 auto StrictAlignIter =
1571 llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {
1572 return Arg ==
"+strict-align" || Arg ==
"-strict-align";
1574 if (StrictAlignIter != CmdArgs.rend() &&
1575 StringRef(*StrictAlignIter) ==
"+strict-align")
1576 CmdArgs.push_back(
"-Wunaligned-access");
1581 ArgStringList &CmdArgs,
bool isAArch64) {
1582 const Arg *A = isAArch64
1583 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1584 options::OPT_mbranch_protection_EQ)
1585 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1591 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))
1592 D.
Diag(diag::warn_incompatible_branch_protection_option)
1593 << Triple.getArchName();
1595 StringRef
Scope, Key;
1596 bool IndirectBranches;
1598 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1599 Scope = A->getValue();
1601 D.
Diag(diag::err_drv_unsupported_option_argument)
1602 << A->getSpelling() <<
Scope;
1604 IndirectBranches =
false;
1607 llvm::ARM::ParsedBranchProtection PBP;
1608 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg))
1609 D.
Diag(diag::err_drv_unsupported_option_argument)
1610 << A->getSpelling() << DiagMsg;
1611 if (!isAArch64 && PBP.Key ==
"b_key")
1612 D.
Diag(diag::warn_unsupported_branch_protection)
1613 <<
"b-key" << A->getAsString(Args);
1616 IndirectBranches = PBP.BranchTargetEnforcement;
1620 Args.MakeArgString(Twine(
"-msign-return-address=") +
Scope));
1621 if (!
Scope.equals(
"none"))
1623 Args.MakeArgString(Twine(
"-msign-return-address-key=") + Key));
1624 if (IndirectBranches)
1625 CmdArgs.push_back(
"-mbranch-target-enforce");
1628void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
1629 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
1630 RenderARMABI(
getToolChain().getDriver(), Triple, Args, CmdArgs);
1637 CmdArgs.push_back(
"-msoft-float");
1638 CmdArgs.push_back(
"-mfloat-abi");
1639 CmdArgs.push_back(
"soft");
1642 CmdArgs.push_back(
"-mfloat-abi");
1643 CmdArgs.push_back(
"soft");
1647 CmdArgs.push_back(
"-mfloat-abi");
1648 CmdArgs.push_back(
"hard");
1652 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1653 options::OPT_mno_global_merge)) {
1654 CmdArgs.push_back(
"-mllvm");
1655 if (A->getOption().matches(options::OPT_mno_global_merge))
1656 CmdArgs.push_back(
"-arm-global-merge=false");
1658 CmdArgs.push_back(
"-arm-global-merge=true");
1661 if (!Args.hasFlag(options::OPT_mimplicit_float,
1662 options::OPT_mno_implicit_float,
true))
1663 CmdArgs.push_back(
"-no-implicit-float");
1665 if (Args.getLastArg(options::OPT_mcmse))
1666 CmdArgs.push_back(
"-mcmse");
1673 AddUnalignedAccessWarning(CmdArgs);
1676void Clang::RenderTargetOptions(
const llvm::Triple &EffectiveTriple,
1677 const ArgList &Args,
bool KernelOrKext,
1678 ArgStringList &CmdArgs)
const {
1689 case llvm::Triple::arm:
1690 case llvm::Triple::armeb:
1691 case llvm::Triple::thumb:
1692 case llvm::Triple::thumbeb:
1694 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1697 case llvm::Triple::aarch64:
1698 case llvm::Triple::aarch64_32:
1699 case llvm::Triple::aarch64_be:
1700 AddAArch64TargetArgs(Args, CmdArgs);
1703 case llvm::Triple::loongarch32:
1704 case llvm::Triple::loongarch64:
1705 AddLoongArchTargetArgs(Args, CmdArgs);
1708 case llvm::Triple::mips:
1709 case llvm::Triple::mipsel:
1710 case llvm::Triple::mips64:
1711 case llvm::Triple::mips64el:
1712 AddMIPSTargetArgs(Args, CmdArgs);
1715 case llvm::Triple::ppc:
1716 case llvm::Triple::ppcle:
1717 case llvm::Triple::ppc64:
1718 case llvm::Triple::ppc64le:
1719 AddPPCTargetArgs(Args, CmdArgs);
1722 case llvm::Triple::riscv32:
1723 case llvm::Triple::riscv64:
1724 AddRISCVTargetArgs(Args, CmdArgs);
1727 case llvm::Triple::sparc:
1728 case llvm::Triple::sparcel:
1729 case llvm::Triple::sparcv9:
1730 AddSparcTargetArgs(Args, CmdArgs);
1733 case llvm::Triple::systemz:
1734 AddSystemZTargetArgs(Args, CmdArgs);
1737 case llvm::Triple::x86:
1738 case llvm::Triple::x86_64:
1739 AddX86TargetArgs(Args, CmdArgs);
1742 case llvm::Triple::lanai:
1743 AddLanaiTargetArgs(Args, CmdArgs);
1746 case llvm::Triple::hexagon:
1747 AddHexagonTargetArgs(Args, CmdArgs);
1750 case llvm::Triple::wasm32:
1751 case llvm::Triple::wasm64:
1752 AddWebAssemblyTargetArgs(Args, CmdArgs);
1755 case llvm::Triple::ve:
1756 AddVETargetArgs(Args, CmdArgs);
1762void RenderAArch64ABI(
const llvm::Triple &Triple,
const ArgList &Args,
1763 ArgStringList &CmdArgs) {
1764 const char *ABIName =
nullptr;
1765 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1766 ABIName = A->getValue();
1767 else if (Triple.isOSDarwin())
1768 ABIName =
"darwinpcs";
1772 CmdArgs.push_back(
"-target-abi");
1773 CmdArgs.push_back(ABIName);
1777void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1778 ArgStringList &CmdArgs)
const {
1781 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1782 Args.hasArg(options::OPT_mkernel) ||
1783 Args.hasArg(options::OPT_fapple_kext))
1784 CmdArgs.push_back(
"-disable-red-zone");
1786 if (!Args.hasFlag(options::OPT_mimplicit_float,
1787 options::OPT_mno_implicit_float,
true))
1788 CmdArgs.push_back(
"-no-implicit-float");
1790 RenderAArch64ABI(Triple, Args, CmdArgs);
1793 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1794 options::OPT_mno_global_merge)) {
1795 CmdArgs.push_back(
"-mllvm");
1796 if (A->getOption().matches(options::OPT_mno_global_merge))
1797 CmdArgs.push_back(
"-aarch64-enable-global-merge=false");
1799 CmdArgs.push_back(
"-aarch64-enable-global-merge=true");
1806 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1807 StringRef Val = A->getValue();
1809 if (Val.equals(
"128") || Val.equals(
"256") || Val.equals(
"512") ||
1810 Val.equals(
"1024") || Val.equals(
"2048") || Val.equals(
"128+") ||
1811 Val.equals(
"256+") || Val.equals(
"512+") || Val.equals(
"1024+") ||
1812 Val.equals(
"2048+")) {
1814 if (Val.endswith(
"+"))
1815 Val = Val.substr(0, Val.size() - 1);
1818 assert(!
Invalid &&
"Failed to parse value");
1820 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
1824 assert(!
Invalid &&
"Failed to parse value");
1826 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
1828 }
else if (!Val.equals(
"scalable"))
1830 D.
Diag(diag::err_drv_unsupported_option_argument)
1831 << A->getSpelling() << Val;
1836 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1837 CmdArgs.push_back(
"-tune-cpu");
1838 if (strcmp(A->getValue(),
"native") == 0)
1839 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1841 CmdArgs.push_back(A->getValue());
1844 AddUnalignedAccessWarning(CmdArgs);
1847void Clang::AddLoongArchTargetArgs(
const ArgList &Args,
1848 ArgStringList &CmdArgs)
const {
1849 CmdArgs.push_back(
"-target-abi");
1855void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1856 ArgStringList &CmdArgs)
const {
1863 CmdArgs.push_back(
"-target-abi");
1864 CmdArgs.push_back(ABIName.data());
1869 CmdArgs.push_back(
"-msoft-float");
1870 CmdArgs.push_back(
"-mfloat-abi");
1871 CmdArgs.push_back(
"soft");
1875 CmdArgs.push_back(
"-mfloat-abi");
1876 CmdArgs.push_back(
"hard");
1879 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1880 options::OPT_mno_ldc1_sdc1)) {
1881 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1882 CmdArgs.push_back(
"-mllvm");
1883 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1887 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1888 options::OPT_mno_check_zero_division)) {
1889 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1890 CmdArgs.push_back(
"-mllvm");
1891 CmdArgs.push_back(
"-mno-check-zero-division");
1895 if (Args.getLastArg(options::OPT_mfix4300)) {
1896 CmdArgs.push_back(
"-mllvm");
1897 CmdArgs.push_back(
"-mfix4300");
1900 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1901 StringRef
v = A->getValue();
1902 CmdArgs.push_back(
"-mllvm");
1903 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" +
v));
1907 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1909 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1922 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1924 llvm::Reloc::Model RelocationModel;
1927 std::tie(RelocationModel, PICLevel, IsPIE) =
1930 NoABICalls = NoABICalls ||
1931 (RelocationModel == llvm::Reloc::Static && ABIName ==
"n64");
1933 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1935 if (NoABICalls && (!GPOpt || WantGPOpt)) {
1936 CmdArgs.push_back(
"-mllvm");
1937 CmdArgs.push_back(
"-mgpopt");
1939 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1940 options::OPT_mno_local_sdata);
1941 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1942 options::OPT_mno_extern_sdata);
1943 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1944 options::OPT_mno_embedded_data);
1946 CmdArgs.push_back(
"-mllvm");
1947 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1948 CmdArgs.push_back(
"-mlocal-sdata=1");
1950 CmdArgs.push_back(
"-mlocal-sdata=0");
1952 LocalSData->claim();
1956 CmdArgs.push_back(
"-mllvm");
1957 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1958 CmdArgs.push_back(
"-mextern-sdata=1");
1960 CmdArgs.push_back(
"-mextern-sdata=0");
1962 ExternSData->claim();
1966 CmdArgs.push_back(
"-mllvm");
1967 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1968 CmdArgs.push_back(
"-membedded-data=1");
1970 CmdArgs.push_back(
"-membedded-data=0");
1972 EmbeddedData->claim();
1975 }
else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1976 D.
Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1981 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1982 StringRef Val = StringRef(A->getValue());
1984 if (Val ==
"never" || Val ==
"always" || Val ==
"optimal") {
1985 CmdArgs.push_back(
"-mllvm");
1986 CmdArgs.push_back(Args.MakeArgString(
"-mips-compact-branches=" + Val));
1988 D.
Diag(diag::err_drv_unsupported_option_argument)
1989 << A->getSpelling() << Val;
1991 D.
Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1994 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1995 options::OPT_mno_relax_pic_calls)) {
1996 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1997 CmdArgs.push_back(
"-mllvm");
1998 CmdArgs.push_back(
"-mips-jalr-reloc=0");
2003void Clang::AddPPCTargetArgs(
const ArgList &Args,
2004 ArgStringList &CmdArgs)
const {
2007 if (Args.getLastArg(options::OPT_mtune_EQ)) {
2008 CmdArgs.push_back(
"-tune-cpu");
2010 CmdArgs.push_back(Args.MakeArgString(CPU));
2014 const char *ABIName =
nullptr;
2015 if (T.isOSBinFormatELF()) {
2017 case llvm::Triple::ppc64: {
2018 if (T.isPPC64ELFv2ABI())
2024 case llvm::Triple::ppc64le:
2033 bool VecExtabi =
false;
2034 for (
const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2035 StringRef
V = A->getValue();
2036 if (
V ==
"ieeelongdouble") {
2037 IEEELongDouble =
true;
2039 }
else if (
V ==
"ibmlongdouble") {
2040 IEEELongDouble =
false;
2042 }
else if (
V ==
"vec-default") {
2045 }
else if (
V ==
"vec-extabi") {
2048 }
else if (
V !=
"altivec")
2052 ABIName = A->getValue();
2055 CmdArgs.push_back(
"-mabi=ieeelongdouble");
2058 D.
Diag(diag::err_drv_unsupported_opt_for_target)
2059 <<
"-mabi=vec-extabi" << T.str();
2060 CmdArgs.push_back(
"-mabi=vec-extabi");
2066 CmdArgs.push_back(
"-msoft-float");
2067 CmdArgs.push_back(
"-mfloat-abi");
2068 CmdArgs.push_back(
"soft");
2072 CmdArgs.push_back(
"-mfloat-abi");
2073 CmdArgs.push_back(
"hard");
2077 CmdArgs.push_back(
"-target-abi");
2078 CmdArgs.push_back(ABIName);
2083 ArgStringList &CmdArgs) {
2085 const llvm::Triple &Triple = TC.
getTriple();
2087 const char *SmallDataLimit =
"8";
2089 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2090 options::OPT_fPIC)) {
2092 SmallDataLimit =
"0";
2093 if (Args.hasArg(options::OPT_G)) {
2094 D.
Diag(diag::warn_drv_unsupported_sdata);
2096 }
else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2097 .equals_insensitive(
"large") &&
2098 (Triple.getArch() == llvm::Triple::riscv64)) {
2100 SmallDataLimit =
"0";
2101 if (Args.hasArg(options::OPT_G)) {
2102 D.
Diag(diag::warn_drv_unsupported_sdata);
2104 }
else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2105 SmallDataLimit = A->getValue();
2108 CmdArgs.push_back(
"-msmall-data-limit");
2109 CmdArgs.push_back(SmallDataLimit);
2112void Clang::AddRISCVTargetArgs(
const ArgList &Args,
2113 ArgStringList &CmdArgs)
const {
2117 CmdArgs.push_back(
"-target-abi");
2118 CmdArgs.push_back(ABIName.data());
2122 if (!Args.hasFlag(options::OPT_mimplicit_float,
2123 options::OPT_mno_implicit_float,
true))
2124 CmdArgs.push_back(
"-no-implicit-float");
2126 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2127 CmdArgs.push_back(
"-tune-cpu");
2128 if (strcmp(A->getValue(),
"native") == 0)
2129 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2131 CmdArgs.push_back(A->getValue());
2135 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2136 StringRef Val = A->getValue();
2140 unsigned MinVLen = 0;
2142 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
2146 consumeError(ISAInfo.takeError());
2148 MinVLen = (*ISAInfo)->getMinVLen();
2154 if (Val.equals(
"zvl") && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
2156 }
else if (!Val.getAsInteger(10, Bits)) {
2159 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
2160 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
2166 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
2168 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
2170 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
2171 }
else if (!Val.equals(
"scalable")) {
2173 D.
Diag(diag::err_drv_unsupported_option_argument)
2174 << A->getSpelling() << Val;
2179void Clang::AddSparcTargetArgs(
const ArgList &Args,
2180 ArgStringList &CmdArgs)
const {
2186 CmdArgs.push_back(
"-msoft-float");
2187 CmdArgs.push_back(
"-mfloat-abi");
2188 CmdArgs.push_back(
"soft");
2192 CmdArgs.push_back(
"-mfloat-abi");
2193 CmdArgs.push_back(
"hard");
2196 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2197 StringRef Name = A->getValue();
2198 std::string TuneCPU;
2199 if (Name ==
"native")
2200 TuneCPU = std::string(llvm::sys::getHostCPUName());
2202 TuneCPU = std::string(Name);
2204 CmdArgs.push_back(
"-tune-cpu");
2205 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2209void Clang::AddSystemZTargetArgs(
const ArgList &Args,
2210 ArgStringList &CmdArgs)
const {
2211 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2212 CmdArgs.push_back(
"-tune-cpu");
2213 if (strcmp(A->getValue(),
"native") == 0)
2214 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2216 CmdArgs.push_back(A->getValue());
2220 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,
false);
2221 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2222 options::OPT_mno_packed_stack,
false);
2226 if (HasBackchain && HasPackedStack && !HasSoftFloat) {
2228 D.
Diag(diag::err_drv_unsupported_opt)
2229 <<
"-mpacked-stack -mbackchain -mhard-float";
2232 CmdArgs.push_back(
"-mbackchain");
2234 CmdArgs.push_back(
"-mpacked-stack");
2237 CmdArgs.push_back(
"-msoft-float");
2238 CmdArgs.push_back(
"-mfloat-abi");
2239 CmdArgs.push_back(
"soft");
2243void Clang::AddX86TargetArgs(
const ArgList &Args,
2244 ArgStringList &CmdArgs)
const {
2248 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2249 Args.hasArg(options::OPT_mkernel) ||
2250 Args.hasArg(options::OPT_fapple_kext))
2251 CmdArgs.push_back(
"-disable-red-zone");
2253 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2254 options::OPT_mno_tls_direct_seg_refs,
true))
2255 CmdArgs.push_back(
"-mno-tls-direct-seg-refs");
2259 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2260 Args.hasArg(options::OPT_fapple_kext));
2261 if (Arg *A = Args.getLastArg(
2262 options::OPT_msoft_float, options::OPT_mno_soft_float,
2263 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2264 const Option &O = A->getOption();
2265 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2266 O.matches(options::OPT_msoft_float));
2268 if (NoImplicitFloat)
2269 CmdArgs.push_back(
"-no-implicit-float");
2271 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2272 StringRef
Value = A->getValue();
2274 CmdArgs.push_back(
"-mllvm");
2275 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
2276 CmdArgs.push_back(Args.MakeArgString(
"-inline-asm=" +
Value));
2278 D.
Diag(diag::err_drv_unsupported_option_argument)
2279 << A->getSpelling() <<
Value;
2282 CmdArgs.push_back(
"-mllvm");
2283 CmdArgs.push_back(
"-x86-asm-syntax=intel");
2286 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2287 options::OPT_mno_skip_rax_setup))
2288 if (A->getOption().matches(options::OPT_mskip_rax_setup))
2289 CmdArgs.push_back(Args.MakeArgString(
"-mskip-rax-setup"));
2292 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,
false)) {
2293 CmdArgs.push_back(
"-mfloat-abi");
2294 CmdArgs.push_back(
"soft");
2295 CmdArgs.push_back(
"-mstack-alignment=4");
2301 std::string TuneCPU;
2302 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2304 TuneCPU =
"generic";
2307 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2308 StringRef Name = A->getValue();
2310 if (Name ==
"native") {
2311 Name = llvm::sys::getHostCPUName();
2313 TuneCPU = std::string(Name);
2315 TuneCPU = std::string(Name);
2318 if (!TuneCPU.empty()) {
2319 CmdArgs.push_back(
"-tune-cpu");
2320 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2324void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2325 ArgStringList &CmdArgs)
const {
2326 CmdArgs.push_back(
"-mqdsp6-compat");
2327 CmdArgs.push_back(
"-Wreturn-type");
2330 CmdArgs.push_back(
"-mllvm");
2332 Args.MakeArgString(
"-hexagon-small-data-threshold=" + Twine(*G)));
2335 if (!Args.hasArg(options::OPT_fno_short_enums))
2336 CmdArgs.push_back(
"-fshort-enums");
2337 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2338 CmdArgs.push_back(
"-mllvm");
2339 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2341 CmdArgs.push_back(
"-mllvm");
2342 CmdArgs.push_back(
"-machine-sink-split=0");
2345void Clang::AddLanaiTargetArgs(
const ArgList &Args,
2346 ArgStringList &CmdArgs)
const {
2347 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2348 StringRef CPUName = A->getValue();
2350 CmdArgs.push_back(
"-target-cpu");
2351 CmdArgs.push_back(Args.MakeArgString(CPUName));
2353 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2354 StringRef
Value = A->getValue();
2358 if (
Value.getAsInteger(10, Mregparm)) {
2359 if (Mregparm != 4) {
2361 diag::err_drv_unsupported_option_argument)
2362 << A->getSpelling() <<
Value;
2368void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2369 ArgStringList &CmdArgs)
const {
2371 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2372 options::OPT_fvisibility_ms_compat))
2373 CmdArgs.push_back(
"-fvisibility=hidden");
2376void Clang::AddVETargetArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
2378 CmdArgs.push_back(
"-mfloat-abi");
2379 CmdArgs.push_back(
"hard");
2384 const InputInfo &Input,
const ArgList &Args)
const {
2386 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2389 using llvm::yaml::escape;
2392 if (!CompilationDatabase) {
2394 auto File = std::make_unique<llvm::raw_fd_ostream>(
2396 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);
2398 D.
Diag(clang::diag::err_drv_compilationdatabase) <<
Filename
2402 CompilationDatabase = std::move(
File);
2404 auto &CDB = *CompilationDatabase;
2405 auto CWD = D.
getVFS().getCurrentWorkingDirectory();
2408 CDB <<
"{ \"directory\": \"" << escape(*CWD) <<
"\"";
2409 CDB <<
", \"file\": \"" << escape(Input.
getFilename()) <<
"\"";
2410 CDB <<
", \"output\": \"" << escape(Output.
getFilename()) <<
"\"";
2415 CDB <<
", \"" << escape(Buf) <<
"\"";
2416 if (!D.
SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2419 CDB <<
", \"" << escape(Buf) <<
"\"";
2421 CDB <<
", \"" << escape(Input.
getFilename()) <<
"\"";
2422 CDB <<
", \"-o\", \"" << escape(Output.
getFilename()) <<
"\"";
2423 for (
auto &A: Args) {
2424 auto &O = A->getOption();
2426 if (O.getID() == options::OPT_x)
2429 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2431 if (O.getID() == options::OPT_gen_cdb_fragment_path)
2434 if (O.getKind() == Option::InputClass)
2437 if (O.getID() == options::OPT_o)
2441 A->render(Args, ASL);
2443 CDB <<
", \"" << escape(it) <<
"\"";
2447 CDB <<
", \"" << escape(Buf) <<
"\"]},\n";
2450void Clang::DumpCompilationDatabaseFragmentToDir(
2452 const InputInfo &Input,
const llvm::opt::ArgList &Args)
const {
2454 if (
C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2457 if (CompilationDatabase)
2458 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2461 const auto &
Driver =
C.getDriver();
2463 auto Err = llvm::sys::fs::create_directory(Path,
true);
2465 Driver.
Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2469 llvm::sys::path::append(
2471 Twine(llvm::sys::path::filename(Input.
getFilename())) +
".%%%%.json");
2474 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath,
2475 llvm::sys::fs::OF_Text);
2477 Driver.
Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2480 CompilationDatabase =
2481 std::make_unique<llvm::raw_fd_ostream>(FD,
true);
2482 DumpCompilationDatabase(
C,
"",
Target, Output, Input, Args);
2492 CmdArgs.push_back(
"-mllvm");
2493 CmdArgs.push_back(Args.MakeArgString(
"-arm-implicit-it=" +
Value));
2497 const ArgList &Args,
2498 ArgStringList &CmdArgs,
2501 CmdArgs.push_back(
"-mrelax-all");
2505 bool DefaultIncrementalLinkerCompatible =
2506 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2507 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2508 options::OPT_mno_incremental_linker_compatible,
2509 DefaultIncrementalLinkerCompatible))
2510 CmdArgs.push_back(
"-mincremental-linker-compatible");
2512 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2522 bool TakeNextArg =
false;
2524 bool UseRelaxRelocations =
C.getDefaultToolChain().useRelaxRelocations();
2525 bool UseNoExecStack =
false;
2526 const char *MipsTargetFeature =
nullptr;
2527 StringRef ImplicitIt;
2529 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2530 options::OPT_mimplicit_it_EQ)) {
2533 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) {
2534 switch (
C.getDefaultToolChain().getArch()) {
2535 case llvm::Triple::arm:
2536 case llvm::Triple::armeb:
2537 case llvm::Triple::thumb:
2538 case llvm::Triple::thumbeb:
2540 ImplicitIt = A->getValue();
2542 D.
Diag(diag::err_drv_unsupported_option_argument)
2543 << A->getSpelling() << ImplicitIt;
2550 for (StringRef
Value : A->getValues()) {
2552 CmdArgs.push_back(
Value.data());
2553 TakeNextArg =
false;
2557 if (
C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2558 Value ==
"-mbig-obj")
2561 switch (
C.getDefaultToolChain().getArch()) {
2564 case llvm::Triple::wasm32:
2565 case llvm::Triple::wasm64:
2566 if (
Value ==
"--no-type-check") {
2567 CmdArgs.push_back(
"-mno-type-check");
2571 case llvm::Triple::thumb:
2572 case llvm::Triple::thumbeb:
2573 case llvm::Triple::arm:
2574 case llvm::Triple::armeb:
2575 if (
Value.startswith(
"-mimplicit-it=")) {
2577 ImplicitIt =
Value.split(
"=").second;
2581 if (
Value ==
"-mthumb")
2586 case llvm::Triple::mips:
2587 case llvm::Triple::mipsel:
2588 case llvm::Triple::mips64:
2589 case llvm::Triple::mips64el:
2590 if (
Value ==
"--trap") {
2591 CmdArgs.push_back(
"-target-feature");
2592 CmdArgs.push_back(
"+use-tcc-in-div");
2595 if (
Value ==
"--break") {
2596 CmdArgs.push_back(
"-target-feature");
2597 CmdArgs.push_back(
"-use-tcc-in-div");
2600 if (
Value.startswith(
"-msoft-float")) {
2601 CmdArgs.push_back(
"-target-feature");
2602 CmdArgs.push_back(
"+soft-float");
2605 if (
Value.startswith(
"-mhard-float")) {
2606 CmdArgs.push_back(
"-target-feature");
2607 CmdArgs.push_back(
"-soft-float");
2611 MipsTargetFeature = llvm::StringSwitch<const char *>(
Value)
2612 .Case(
"-mips1",
"+mips1")
2613 .Case(
"-mips2",
"+mips2")
2614 .Case(
"-mips3",
"+mips3")
2615 .Case(
"-mips4",
"+mips4")
2616 .Case(
"-mips5",
"+mips5")
2617 .Case(
"-mips32",
"+mips32")
2618 .Case(
"-mips32r2",
"+mips32r2")
2619 .Case(
"-mips32r3",
"+mips32r3")
2620 .Case(
"-mips32r5",
"+mips32r5")
2621 .Case(
"-mips32r6",
"+mips32r6")
2622 .Case(
"-mips64",
"+mips64")
2623 .Case(
"-mips64r2",
"+mips64r2")
2624 .Case(
"-mips64r3",
"+mips64r3")
2625 .Case(
"-mips64r5",
"+mips64r5")
2626 .Case(
"-mips64r6",
"+mips64r6")
2628 if (MipsTargetFeature)
2632 if (
Value ==
"-force_cpusubtype_ALL") {
2634 }
else if (
Value ==
"-L") {
2635 CmdArgs.push_back(
"-msave-temp-labels");
2636 }
else if (
Value ==
"--fatal-warnings") {
2637 CmdArgs.push_back(
"-massembler-fatal-warnings");
2638 }
else if (
Value ==
"--no-warn" ||
Value ==
"-W") {
2639 CmdArgs.push_back(
"-massembler-no-warn");
2640 }
else if (
Value ==
"--noexecstack") {
2641 UseNoExecStack =
true;
2642 }
else if (
Value.startswith(
"-compress-debug-sections") ||
2643 Value.startswith(
"--compress-debug-sections") ||
2644 Value ==
"-nocompress-debug-sections" ||
2645 Value ==
"--nocompress-debug-sections") {
2646 CmdArgs.push_back(
Value.data());
2647 }
else if (
Value ==
"-mrelax-relocations=yes" ||
2648 Value ==
"--mrelax-relocations=yes") {
2649 UseRelaxRelocations =
true;
2650 }
else if (
Value ==
"-mrelax-relocations=no" ||
2651 Value ==
"--mrelax-relocations=no") {
2652 UseRelaxRelocations =
false;
2653 }
else if (
Value.startswith(
"-I")) {
2654 CmdArgs.push_back(
Value.data());
2659 }
else if (
Value.startswith(
"-gdwarf-")) {
2662 if (DwarfVersion == 0) {
2663 CmdArgs.push_back(
Value.data());
2666 llvm::codegenoptions::DebugInfoConstructor,
2667 DwarfVersion, llvm::DebuggerKind::Default);
2669 }
else if (
Value.startswith(
"-mcpu") ||
Value.startswith(
"-mfpu") ||
2670 Value.startswith(
"-mhwdiv") ||
Value.startswith(
"-march")) {
2672 }
else if (
Value ==
"-defsym") {
2673 if (A->getNumValues() != 2) {
2674 D.
Diag(diag::err_drv_defsym_invalid_format) <<
Value;
2677 const char *S = A->getValue(1);
2678 auto Pair = StringRef(S).split(
'=');
2679 auto Sym = Pair.first;
2680 auto SVal = Pair.second;
2682 if (Sym.empty() || SVal.empty()) {
2683 D.
Diag(diag::err_drv_defsym_invalid_format) << S;
2687 if (SVal.getAsInteger(0, IVal)) {
2688 D.
Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2691 CmdArgs.push_back(
Value.data());
2693 }
else if (
Value ==
"-fdebug-compilation-dir") {
2694 CmdArgs.push_back(
"-fdebug-compilation-dir");
2696 }
else if (
Value.consume_front(
"-fdebug-compilation-dir=")) {
2700 CmdArgs.push_back(
"-fdebug-compilation-dir");
2701 CmdArgs.push_back(
Value.data());
2702 }
else if (
Value ==
"--version") {
2705 D.
Diag(diag::err_drv_unsupported_option_argument)
2706 << A->getSpelling() <<
Value;
2710 if (ImplicitIt.size())
2712 if (!UseRelaxRelocations)
2713 CmdArgs.push_back(
"-mrelax-relocations=no");
2715 CmdArgs.push_back(
"-mnoexecstack");
2716 if (MipsTargetFeature !=
nullptr) {
2717 CmdArgs.push_back(
"-target-feature");
2718 CmdArgs.push_back(MipsTargetFeature);
2722 if (
C.getDriver().embedBitcodeEnabled() ||
2723 C.getDriver().embedBitcodeMarkerOnly())
2724 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2726 if (
const char *AsSecureLogFile = getenv(
"AS_SECURE_LOG_FILE")) {
2727 CmdArgs.push_back(
"-as-secure-log-file");
2728 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2733 bool OFastEnabled,
const ArgList &Args,
2734 ArgStringList &CmdArgs,
2741 bool HonorINFs =
true;
2742 bool HonorNaNs =
true;
2743 bool ApproxFunc =
false;
2746 bool AssociativeMath =
false;
2747 bool ReciprocalMath =
false;
2748 bool SignedZeros =
true;
2749 bool TrappingMath =
false;
2750 bool TrappingMathPresent =
false;
2752 bool RoundingFPMath =
false;
2753 bool RoundingMathPresent =
false;
2755 StringRef FPModel =
"";
2757 StringRef FPExceptionBehavior =
"";
2759 StringRef FPEvalMethod =
"";
2760 const llvm::DenormalMode DefaultDenormalFPMath =
2762 const llvm::DenormalMode DefaultDenormalFP32Math =
2765 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
2766 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
2769 StringRef FPContract;
2770 StringRef LastSeenFfpContractOption;
2771 bool SeenUnsafeMathModeOption =
false;
2775 bool StrictFPModel =
false;
2776 StringRef Float16ExcessPrecision =
"";
2777 StringRef BFloat16ExcessPrecision =
"";
2779 if (
const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2780 CmdArgs.push_back(
"-mlimit-float-precision");
2781 CmdArgs.push_back(A->getValue());
2784 for (
const Arg *A : Args) {
2785 auto optID = A->getOption().getID();
2786 bool PreciseFPModel =
false;
2790 case options::OPT_ffp_model_EQ: {
2797 AssociativeMath =
false;
2798 ReciprocalMath =
false;
2802 DenormalFPMath = llvm::DenormalMode::getIEEE();
2806 DenormalFP32Math = llvm::DenormalMode::getIEEE();
2808 StringRef Val = A->getValue();
2809 if (OFastEnabled && !Val.equals(
"fast")) {
2811 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2812 << Args.MakeArgString(
"-ffp-model=" + Val)
2816 StrictFPModel =
false;
2817 PreciseFPModel =
true;
2821 if (!FPModel.empty() && !FPModel.equals(Val))
2822 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2823 << Args.MakeArgString(
"-ffp-model=" + FPModel)
2824 << Args.MakeArgString(
"-ffp-model=" + Val);
2825 if (Val.equals(
"fast")) {
2826 optID = options::OPT_ffast_math;
2828 FPContract =
"fast";
2829 }
else if (Val.equals(
"precise")) {
2830 optID = options::OPT_ffp_contract;
2833 PreciseFPModel =
true;
2834 }
else if (Val.equals(
"strict")) {
2835 StrictFPModel =
true;
2836 optID = options::OPT_frounding_math;
2837 FPExceptionBehavior =
"strict";
2840 TrappingMath =
true;
2842 D.
Diag(diag::err_drv_unsupported_option_argument)
2843 << A->getSpelling() << Val;
2853 case options::OPT_fhonor_infinities: HonorINFs =
true;
break;
2854 case options::OPT_fno_honor_infinities: HonorINFs =
false;
break;
2855 case options::OPT_fhonor_nans: HonorNaNs =
true;
break;
2856 case options::OPT_fno_honor_nans: HonorNaNs =
false;
break;
2857 case options::OPT_fapprox_func: ApproxFunc =
true;
break;
2858 case options::OPT_fno_approx_func: ApproxFunc =
false;
break;
2859 case options::OPT_fmath_errno: MathErrno =
true;
break;
2860 case options::OPT_fno_math_errno: MathErrno =
false;
break;
2861 case options::OPT_fassociative_math: AssociativeMath =
true;
break;
2862 case options::OPT_fno_associative_math: AssociativeMath =
false;
break;
2863 case options::OPT_freciprocal_math: ReciprocalMath =
true;
break;
2864 case options::OPT_fno_reciprocal_math: ReciprocalMath =
false;
break;
2865 case options::OPT_fsigned_zeros: SignedZeros =
true;
break;
2866 case options::OPT_fno_signed_zeros: SignedZeros =
false;
break;
2867 case options::OPT_ftrapping_math:
2868 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2869 !FPExceptionBehavior.equals(
"strict"))
2871 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2872 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2873 <<
"-ftrapping-math";
2874 TrappingMath =
true;
2875 TrappingMathPresent =
true;
2876 FPExceptionBehavior =
"strict";
2878 case options::OPT_fno_trapping_math:
2879 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2880 !FPExceptionBehavior.equals(
"ignore"))
2882 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2883 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2884 <<
"-fno-trapping-math";
2885 TrappingMath =
false;
2886 TrappingMathPresent =
true;
2887 FPExceptionBehavior =
"ignore";
2890 case options::OPT_frounding_math:
2891 RoundingFPMath =
true;
2892 RoundingMathPresent =
true;
2895 case options::OPT_fno_rounding_math:
2896 RoundingFPMath =
false;
2897 RoundingMathPresent =
false;
2900 case options::OPT_fdenormal_fp_math_EQ:
2901 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());
2902 DenormalFP32Math = DenormalFPMath;
2903 if (!DenormalFPMath.isValid()) {
2904 D.
Diag(diag::err_drv_invalid_value)
2905 << A->getAsString(Args) << A->getValue();
2909 case options::OPT_fdenormal_fp_math_f32_EQ:
2910 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
2911 if (!DenormalFP32Math.isValid()) {
2912 D.
Diag(diag::err_drv_invalid_value)
2913 << A->getAsString(Args) << A->getValue();
2918 case options::OPT_ffp_contract: {
2919 StringRef Val = A->getValue();
2920 if (PreciseFPModel) {
2925 }
else if (Val.equals(
"fast") || Val.equals(
"on") || Val.equals(
"off")) {
2927 LastSeenFfpContractOption = Val;
2929 D.
Diag(diag::err_drv_unsupported_option_argument)
2930 << A->getSpelling() << Val;
2935 case options::OPT_ffp_model_EQ:
2942 case options::OPT_ffp_exception_behavior_EQ: {
2943 StringRef Val = A->getValue();
2944 if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2945 !FPExceptionBehavior.equals(Val))
2947 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
2948 << Args.MakeArgString(
"-ffp-exception-behavior=" + FPExceptionBehavior)
2949 << Args.MakeArgString(
"-ffp-exception-behavior=" + Val);
2950 TrappingMath = TrappingMathPresent =
false;
2951 if (Val.equals(
"ignore") || Val.equals(
"maytrap"))
2952 FPExceptionBehavior = Val;
2953 else if (Val.equals(
"strict")) {
2954 FPExceptionBehavior = Val;
2955 TrappingMath = TrappingMathPresent =
true;
2957 D.
Diag(diag::err_drv_unsupported_option_argument)
2958 << A->getSpelling() << Val;
2963 case options::OPT_ffp_eval_method_EQ: {
2964 StringRef Val = A->getValue();
2965 if (Val.equals(
"double") || Val.equals(
"extended") ||
2966 Val.equals(
"source"))
2969 D.
Diag(diag::err_drv_unsupported_option_argument)
2970 << A->getSpelling() << Val;
2974 case options::OPT_fexcess_precision_EQ: {
2975 StringRef Val = A->getValue();
2976 const llvm::Triple::ArchType Arch = TC.
getArch();
2977 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
2978 if (Val.equals(
"standard") || Val.equals(
"fast"))
2979 Float16ExcessPrecision = Val;
2983 else if (Val.equals(
"16"))
2984 Float16ExcessPrecision =
"none";
2986 D.
Diag(diag::err_drv_unsupported_option_argument)
2987 << A->getSpelling() << Val;
2989 if (!(Val.equals(
"standard") || Val.equals(
"fast")))
2990 D.
Diag(diag::err_drv_unsupported_option_argument)
2991 << A->getSpelling() << Val;
2993 BFloat16ExcessPrecision = Float16ExcessPrecision;
2996 case options::OPT_ffinite_math_only:
3000 case options::OPT_fno_finite_math_only:
3005 case options::OPT_funsafe_math_optimizations:
3006 AssociativeMath =
true;
3007 ReciprocalMath =
true;
3008 SignedZeros =
false;
3010 TrappingMath =
false;
3011 FPExceptionBehavior =
"";
3012 FPContract =
"fast";
3013 SeenUnsafeMathModeOption =
true;
3015 case options::OPT_fno_unsafe_math_optimizations:
3016 AssociativeMath =
false;
3017 ReciprocalMath =
false;
3020 TrappingMath =
true;
3021 FPExceptionBehavior =
"strict";
3024 DenormalFPMath = llvm::DenormalMode::getIEEE();
3025 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3028 if (LastSeenFfpContractOption !=
"") {
3029 FPContract = LastSeenFfpContractOption;
3030 }
else if (SeenUnsafeMathModeOption)
3035 case options::OPT_Ofast:
3040 case options::OPT_ffast_math:
3044 AssociativeMath =
true;
3045 ReciprocalMath =
true;
3047 SignedZeros =
false;
3048 TrappingMath =
false;
3049 RoundingFPMath =
false;
3050 FPExceptionBehavior =
"";
3052 FPContract =
"fast";
3053 SeenUnsafeMathModeOption =
true;
3055 case options::OPT_fno_fast_math:
3062 AssociativeMath =
false;
3063 ReciprocalMath =
false;
3067 DenormalFPMath = DefaultDenormalFPMath;
3068 DenormalFP32Math = llvm::DenormalMode::getIEEE();
3071 if (LastSeenFfpContractOption !=
"") {
3072 FPContract = LastSeenFfpContractOption;
3073 }
else if (SeenUnsafeMathModeOption)
3078 if (StrictFPModel) {
3081 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
3082 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
3083 DenormalFPMath == llvm::DenormalMode::getIEEE() &&
3084 DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
3085 FPContract.equals(
"off"))
3089 StrictFPModel =
false;
3091 auto RHS = (A->getNumValues() == 0)
3093 : Args.MakeArgString(A->getSpelling() + A->getValue());
3094 if (RHS !=
"-ffp-model=strict")
3095 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3096 <<
"-ffp-model=strict" << RHS;
3105 CmdArgs.push_back(
"-menable-no-infs");
3108 CmdArgs.push_back(
"-menable-no-nans");
3111 CmdArgs.push_back(
"-fapprox-func");
3114 CmdArgs.push_back(
"-fmath-errno");
3116 if (AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&
3118 CmdArgs.push_back(
"-funsafe-math-optimizations");
3121 CmdArgs.push_back(
"-fno-signed-zeros");
3123 if (AssociativeMath && !SignedZeros && !TrappingMath)
3124 CmdArgs.push_back(
"-mreassociate");
3127 CmdArgs.push_back(
"-freciprocal-math");
3131 assert(FPExceptionBehavior.equals(
"strict"));
3135 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
3137 llvm::raw_svector_ostream ArgStr(DenormFlag);
3138 ArgStr <<
"-fdenormal-fp-math=" << DenormalFPMath;
3139 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3143 if (DenormalFP32Math != DenormalFPMath) {
3145 llvm::raw_svector_ostream ArgStr(DenormFlag);
3146 ArgStr <<
"-fdenormal-fp-math-f32=" << DenormalFP32Math;
3147 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3150 if (!FPContract.empty())
3151 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
3153 if (!RoundingFPMath)
3154 CmdArgs.push_back(Args.MakeArgString(
"-fno-rounding-math"));
3156 if (RoundingFPMath && RoundingMathPresent)
3157 CmdArgs.push_back(Args.MakeArgString(
"-frounding-math"));
3159 if (!FPExceptionBehavior.empty())
3160 CmdArgs.push_back(Args.MakeArgString(
"-ffp-exception-behavior=" +
3161 FPExceptionBehavior));
3163 if (!FPEvalMethod.empty())
3164 CmdArgs.push_back(Args.MakeArgString(
"-ffp-eval-method=" + FPEvalMethod));
3166 if (!Float16ExcessPrecision.empty())
3167 CmdArgs.push_back(Args.MakeArgString(
"-ffloat16-excess-precision=" +
3168 Float16ExcessPrecision));
3169 if (!BFloat16ExcessPrecision.empty())
3170 CmdArgs.push_back(Args.MakeArgString(
"-fbfloat16-excess-precision=" +
3171 BFloat16ExcessPrecision));
3178 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&
3179 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
3180 CmdArgs.push_back(
"-ffast-math");
3181 if (FPModel.equals(
"fast")) {
3182 if (FPContract.equals(
"fast"))
3185 else if (FPContract.empty())
3187 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3189 D.
Diag(clang::diag::warn_drv_overriding_flag_option)
3190 <<
"-ffp-model=fast"
3191 << Args.MakeArgString(
"-ffp-contract=" + FPContract);
3196 if (!HonorINFs && !HonorNaNs)
3197 CmdArgs.push_back(
"-ffinite-math-only");
3199 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3200 CmdArgs.push_back(
"-mfpmath");
3201 CmdArgs.push_back(A->getValue());
3205 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3206 options::OPT_fstrict_float_cast_overflow,
false))
3207 CmdArgs.push_back(
"-fno-strict-float-cast-overflow");
3211 const llvm::Triple &Triple,
3214 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3215 CmdArgs.push_back(
"-analyzer-checker=core");
3216 CmdArgs.push_back(
"-analyzer-checker=apiModeling");
3218 if (!Triple.isWindowsMSVCEnvironment()) {
3219 CmdArgs.push_back(
"-analyzer-checker=unix");
3222 CmdArgs.push_back(
"-analyzer-checker=unix.API");
3223 CmdArgs.push_back(
"-analyzer-checker=unix.Malloc");
3224 CmdArgs.push_back(
"-analyzer-checker=unix.MallocSizeof");
3225 CmdArgs.push_back(
"-analyzer-checker=unix.MismatchedDeallocator");
3226 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.BadSizeArg");
3227 CmdArgs.push_back(
"-analyzer-checker=unix.cstring.NullArg");
3231 if (Triple.isPS()) {
3232 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3233 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3236 if (Triple.isOSDarwin()) {
3237 CmdArgs.push_back(
"-analyzer-checker=osx");
3239 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
3241 else if (Triple.isOSFuchsia())
3242 CmdArgs.push_back(
"-analyzer-checker=fuchsia");
3244 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3247 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3249 if (!Triple.isPS()) {
3250 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.UncheckedReturn");
3251 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3252 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3253 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3254 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3255 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3259 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3260 CmdArgs.push_back(
"-analyzer-checker=nullability.NullReturnedFromNonnull");
3264 CmdArgs.push_back(
"-analyzer-output");
3265 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3266 CmdArgs.push_back(A->getValue());
3268 CmdArgs.push_back(
"plist");
3273 CmdArgs.push_back(
"-w");
3276 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3283 if (std::isdigit(S[0]))
3286 return llvm::all_of(S, [](
char C) {
return std::isalnum(
C) ||
C ==
'_'; });
3290 const ArgList &Args, ArgStringList &CmdArgs,
3291 bool KernelOrKext) {
3296 if (EffectiveTriple.isNVPTX())
3304 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3305 options::OPT_fstack_protector_all,
3306 options::OPT_fstack_protector_strong,
3307 options::OPT_fstack_protector)) {
3308 if (A->getOption().matches(options::OPT_fstack_protector))
3309 StackProtectorLevel =
3311 else if (A->getOption().matches(options::OPT_fstack_protector_strong))
3313 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3317 D.
Diag(diag::warn_drv_unsupported_option_for_target)
3318 << A->getSpelling() << EffectiveTriple.getTriple();
3319 StackProtectorLevel = DefaultStackProtectorLevel;
3322 StackProtectorLevel = DefaultStackProtectorLevel;
3325 if (StackProtectorLevel) {
3326 CmdArgs.push_back(
"-stack-protector");
3327 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3331 for (
const Arg *A : Args.filtered(options::OPT__param)) {
3332 StringRef Str(A->getValue());
3333 if (Str.startswith(
"ssp-buffer-size=")) {
3334 if (StackProtectorLevel) {
3335 CmdArgs.push_back(
"-stack-protector-buffer-size");
3337 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3343 const std::string &TripleStr = EffectiveTriple.getTriple();
3344 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3345 StringRef
Value = A->getValue();
3346 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3347 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3348 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3349 << A->getAsString(Args) << TripleStr;
3350 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||
3351 EffectiveTriple.isThumb()) &&
3353 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3354 << A->getOption().getName() <<
Value <<
"tls global";
3357 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3359 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3360 D.
Diag(diag::err_drv_ssp_missing_offset_argument)
3361 << A->getAsString(Args);
3366 D.
Diag(diag::err_target_unsupported_tp_hard)
3367 << EffectiveTriple.getArchName();
3371 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3372 StringRef
Value = A->getValue();
3373 if (
Value !=
"cp15") {
3374 D.
Diag(diag::err_drv_argument_not_allowed_with)
3375 << A->getAsString(Args) <<
"-mstack-protector-guard=tls";
3379 CmdArgs.push_back(
"-target-feature");
3380 CmdArgs.push_back(
"+read-tp-hard");
3382 if (EffectiveTriple.isAArch64() &&
Value !=
"sysreg" &&
Value !=
"global") {
3383 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3384 << A->getOption().getName() <<
Value <<
"sysreg global";
3387 A->render(Args, CmdArgs);
3390 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3391 StringRef
Value = A->getValue();
3392 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&
3393 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb())
3394 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3395 << A->getAsString(Args) << TripleStr;
3398 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3401 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&
3402 (Offset < 0 || Offset > 0xfffff)) {
3403 D.
Diag(diag::err_drv_invalid_int_value)
3404 << A->getOption().getName() <<
Value;
3407 A->render(Args, CmdArgs);
3410 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3411 StringRef
Value = A->getValue();
3412 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64())
3413 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3414 << A->getAsString(Args) << TripleStr;
3415 if (EffectiveTriple.isX86() && (
Value !=
"fs" &&
Value !=
"gs")) {
3416 D.
Diag(diag::err_drv_invalid_value_with_suggestion)
3417 << A->getOption().getName() <<
Value <<
"fs gs";
3420 if (EffectiveTriple.isAArch64() &&
Value !=
"sp_el0") {
3421 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<
Value;
3424 A->render(Args, CmdArgs);
3427 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3428 StringRef
Value = A->getValue();
3430 D.
Diag(diag::err_drv_argument_only_allowed_with)
3431 << A->getOption().getName() <<
"legal symbol name";
3434 A->render(Args, CmdArgs);
3439 ArgStringList &CmdArgs) {
3442 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux())
3445 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&
3446 !EffectiveTriple.isPPC64())
3449 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3450 options::OPT_fno_stack_clash_protection);
3455 const ArgList &Args,
3456 ArgStringList &CmdArgs) {
3458 StringRef TrivialAutoVarInit =
"";
3460 for (
const Arg *A : Args) {
3461 switch (A->getOption().getID()) {
3464 case options::OPT_ftrivial_auto_var_init: {
3466 StringRef Val = A->getValue();
3467 if (Val ==
"uninitialized" || Val ==
"zero" || Val ==
"pattern")
3468 TrivialAutoVarInit = Val;
3470 D.
Diag(diag::err_drv_unsupported_option_argument)
3471 << A->getSpelling() << Val;
3477 if (TrivialAutoVarInit.empty())
3478 switch (DefaultTrivialAutoVarInit) {
3482 TrivialAutoVarInit =
"pattern";
3485 TrivialAutoVarInit =
"zero";
3489 if (!TrivialAutoVarInit.empty()) {
3491 Args.MakeArgString(
"-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3495 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3496 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3498 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3500 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);
3502 StringRef Val = A->getValue();
3503 if (std::stoi(Val.str()) <= 0)
3504 D.
Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);
3506 Args.MakeArgString(
"-ftrivial-auto-var-init-stop-after=" + Val));
3514 const unsigned ForwardedArguments[] = {
3515 options::OPT_cl_opt_disable,
3516 options::OPT_cl_strict_aliasing,
3517 options::OPT_cl_single_precision_constant,
3518 options::OPT_cl_finite_math_only,
3519 options::OPT_cl_kernel_arg_info,
3520 options::OPT_cl_unsafe_math_optimizations,
3521 options::OPT_cl_fast_relaxed_math,
3522 options::OPT_cl_mad_enable,
3523 options::OPT_cl_no_signed_zeros,
3524 options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3525 options::OPT_cl_uniform_work_group_size
3528 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3529 std::string CLStdStr = std::string(
"-cl-std=") + A->getValue();
3530 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3531 }
else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3532 std::string CLExtStr = std::string(
"-cl-ext=") + A->getValue();
3533 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3536 for (
const auto &Arg : ForwardedArguments)
3537 if (
const auto *A = Args.getLastArg(Arg))
3538 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3543 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3544 CmdArgs.push_back(
"-finclude-default-header");
3545 CmdArgs.push_back(
"-fdeclare-opencl-builtins");
3551 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
3556 options::OPT_emit_llvm,
3557 options::OPT_emit_obj,
3558 options::OPT_disable_llvm_passes,
3559 options::OPT_fnative_half_type,
3560 options::OPT_hlsl_entrypoint};
3563 for (
const auto &Arg : ForwardedArguments)
3564 if (
const auto *A = Args.getLastArg(Arg))
3565 A->renderAsInput(Args, CmdArgs);
3567 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3568 !Args.hasArg(options::OPT_nostdinc))
3569 CmdArgs.push_back(
"-finclude-default-header");
3573 ArgStringList &CmdArgs) {
3574 bool ARCMTEnabled =
false;
3575 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3576 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3577 options::OPT_ccc_arcmt_modify,
3578 options::OPT_ccc_arcmt_migrate)) {
3579 ARCMTEnabled =
true;
3580 switch (A->getOption().getID()) {
3581 default: llvm_unreachable(
"missed a case");
3582 case options::OPT_ccc_arcmt_check:
3583 CmdArgs.push_back(
"-arcmt-action=check");
3585 case options::OPT_ccc_arcmt_modify:
3586 CmdArgs.push_back(
"-arcmt-action=modify");
3588 case options::OPT_ccc_arcmt_migrate:
3589 CmdArgs.push_back(
"-arcmt-action=migrate");
3590 CmdArgs.push_back(
"-mt-migrate-directory");
3591 CmdArgs.push_back(A->getValue());
3593 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3594 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3599 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3600 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3601 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3604 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3606 D.
Diag(diag::err_drv_argument_not_allowed_with)
3607 << A->getAsString(Args) <<
"-ccc-arcmt-migrate";
3609 CmdArgs.push_back(
"-mt-migrate-directory");
3610 CmdArgs.push_back(A->getValue());
3612 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3613 options::OPT_objcmt_migrate_subscripting,
3614 options::OPT_objcmt_migrate_property)) {
3616 CmdArgs.push_back(
"-objcmt-migrate-literals");
3617 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3618 CmdArgs.push_back(
"-objcmt-migrate-property");
3620 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3621 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3622 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3625 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3626 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3627 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3628 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3629 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3630 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3631 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3632 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3633 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3634 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3635 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3636 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3637 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3638 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3639 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3640 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3645 const ArgList &Args, ArgStringList &CmdArgs) {
3648 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3649 !Args.hasArg(options::OPT_mkernel));
3651 CmdArgs.push_back(
"-fno-builtin");
3654 if (Args.hasArg(options::OPT_ffreestanding))
3655 UseBuiltins =
false;
3658 for (
const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3664 A->render(Args, CmdArgs);
3670 if (TC.
getArch() == llvm::Triple::le32)
3671 CmdArgs.push_back(
"-fno-math-builtin");
3675 if (
const char *Str = std::getenv(
"CLANG_MODULE_CACHE_PATH")) {
3678 return Path.getSingleStringRef() !=
"";
3680 if (llvm::sys::path::cache_directory(
Result)) {
3681 llvm::sys::path::append(
Result,
"clang");
3682 llvm::sys::path::append(
Result,
"ModuleCache");
3689 const ArgList &Args,
const InputInfo &Input,
3691 ArgStringList &CmdArgs) {
3695 bool HaveStdCXXModules =
3697 (
Std->containsValue(
"c++2a") ||
Std->containsValue(
"gnu++2a") ||
3698 Std->containsValue(
"c++20") ||
Std->containsValue(
"gnu++20") ||
3699 Std->containsValue(
"c++2b") ||
Std->containsValue(
"gnu++2b") ||
3700 Std->containsValue(
"c++23") ||
Std->containsValue(
"gnu++23") ||
3701 Std->containsValue(
"c++2c") ||
Std->containsValue(
"gnu++2c") ||
3702 Std->containsValue(
"c++26") ||
Std->containsValue(
"gnu++26") ||
3703 Std->containsValue(
"c++latest") ||
Std->containsValue(
"gnu++latest"));
3704 bool HaveModules = HaveStdCXXModules;
3709 bool HaveClangModules =
false;
3710 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
3711 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3712 options::OPT_fno_cxx_modules,
true);
3713 if (AllowedInCXX || !IsCXX) {
3714 CmdArgs.push_back(
"-fmodules");
3715 HaveClangModules =
true;
3719 HaveModules |= HaveClangModules;
3723 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3724 options::OPT_fno_implicit_module_maps, HaveClangModules))
3725 CmdArgs.push_back(
"-fimplicit-module-maps");
3728 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3729 options::OPT_fno_modules_decluse);
3733 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3734 options::OPT_fno_modules_strict_decluse,
false))
3735 CmdArgs.push_back(
"-fmodules-strict-decluse");
3738 bool ImplicitModules =
false;
3739 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3740 options::OPT_fno_implicit_modules, HaveClangModules)) {
3742 CmdArgs.push_back(
"-fno-implicit-modules");
3743 }
else if (HaveModules) {
3744 ImplicitModules =
true;
3748 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3749 Path = A->getValue();
3751 bool HasPath =
true;
3752 if (
C.isForDiagnostics()) {
3756 llvm::sys::path::replace_extension(Path,
".cache");
3757 llvm::sys::path::append(Path,
"modules");
3758 }
else if (Path.empty()) {
3766 const char Arg[] =
"-fmodules-cache-path=";
3767 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3768 CmdArgs.push_back(Args.MakeArgString(Path));
3773 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
3774 options::OPT_fno_prebuilt_implicit_modules,
false))
3775 CmdArgs.push_back(
"-fprebuilt-implicit-modules");
3776 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3777 options::OPT_fno_modules_validate_input_files_content,
3779 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
3784 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3788 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3792 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3794 llvm::sys::path::append(BuiltinModuleMap,
"include");
3795 llvm::sys::path::append(BuiltinModuleMap,
"module.modulemap");
3796 if (llvm::sys::fs::exists(BuiltinModuleMap))
3798 Args.MakeArgString(
"-fmodule-map-file=" + BuiltinModuleMap));
3805 if (HaveModules || Input.
getType() == clang::driver::types::TY_ModuleFile) {
3806 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3809 for (
const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3810 CmdArgs.push_back(Args.MakeArgString(
3811 std::string(
"-fprebuilt-module-path=") + A->getValue()));
3815 Args.ClaimAllArgs(options::OPT_fmodule_file);
3819 if (HaveClangModules &&
C.isForDiagnostics()) {
3821 llvm::sys::path::replace_extension(VFSDir,
".cache");
3823 C.addTempFile(Args.MakeArgString(VFSDir));
3825 llvm::sys::path::append(VFSDir,
"vfs");
3826 CmdArgs.push_back(
"-module-dependency-dir");
3827 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3830 if (HaveClangModules)
3831 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3834 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3835 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3836 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3838 if (HaveClangModules) {
3839 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3841 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3842 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3843 D.
Diag(diag::err_drv_argument_not_allowed_with)
3844 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
3846 llvm::sys::fs::file_status Status;
3847 if (llvm::sys::fs::status(A->getValue(), Status))
3848 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
3849 CmdArgs.push_back(Args.MakeArgString(
3850 "-fbuild-session-timestamp=" +
3851 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(
3852 Status.getLastModificationTime().time_since_epoch())
3856 if (Args.getLastArg(
3857 options::OPT_fmodules_validate_once_per_build_session)) {
3858 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3859 options::OPT_fbuild_session_file))
3860 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3862 Args.AddLastArg(CmdArgs,
3863 options::OPT_fmodules_validate_once_per_build_session);
3866 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
3867 options::OPT_fno_modules_validate_system_headers,
3869 CmdArgs.push_back(
"-fmodules-validate-system-headers");
3871 Args.AddLastArg(CmdArgs,
3872 options::OPT_fmodules_disable_diagnostic_validation);
3874 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
3875 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
3876 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
3877 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
3878 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
3879 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
3883 Args.ClaimAllArgs(options::OPT_fmodule_output);
3884 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
3890 ArgStringList &CmdArgs) {
3892 if (
const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
3893 options::OPT_fno_signed_char,
3894 options::OPT_funsigned_char,
3895 options::OPT_fno_unsigned_char)) {
3896 if (A->getOption().matches(options::OPT_funsigned_char) ||
3897 A->getOption().matches(options::OPT_fno_signed_char)) {
3898 CmdArgs.push_back(
"-fno-signed-char");
3901 CmdArgs.push_back(
"-fno-signed-char");
3905 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
3907 if (
const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3908 options::OPT_fno_short_wchar)) {
3909 if (A->getOption().matches(options::OPT_fshort_wchar)) {
3910 CmdArgs.push_back(
"-fwchar-type=short");
3911 CmdArgs.push_back(
"-fno-signed-wchar");
3913 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
3914 CmdArgs.push_back(
"-fwchar-type=int");
3916 (IsARM && !(T.isOSWindows() || T.isOSNetBSD() || T.isOSOpenBSD())))
3917 CmdArgs.push_back(
"-fno-signed-wchar");
3919 CmdArgs.push_back(
"-fsigned-wchar");
3925 const llvm::Triple &T,
const ArgList &Args,
3927 const InputInfo &Input, ArgStringList &CmdArgs) {
3928 const llvm::Triple::ArchType Arch = TC.
getArch();
3934 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3935 options::OPT_fno_objc_legacy_dispatch,
3938 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
3940 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
3946 if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
3948 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
3955 CmdArgs.push_back(
"-fobjc-arc");
3962 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
3964 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
3969 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3970 options::OPT_fno_objc_arc_exceptions,
3972 CmdArgs.push_back(
"-fobjc-arc-exceptions");
3977 if (Args.hasArg(options::OPT_fno_objc_arc)) {
3978 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
3979 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
3985 auto *Arg = Args.getLastArg(
3986 options::OPT_fobjc_convert_messages_to_runtime_calls,
3987 options::OPT_fno_objc_convert_messages_to_runtime_calls);
3989 Arg->getOption().matches(
3990 options::OPT_fno_objc_convert_messages_to_runtime_calls))
3991 CmdArgs.push_back(
"-fno-objc-convert-messages-to-runtime-calls");
3996 if (InferCovariantReturns)
3997 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4002 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4006 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4007 D.
Diag(diag::err_objc_weak_unsupported);
4009 WeakArg->render(Args, CmdArgs);
4013 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4014 CmdArgs.push_back(
"-fobjc-disable-direct-methods-for-testing");
4018 ArgStringList &CmdArgs) {
4019 bool CaretDefault =
true;
4020 bool ColumnDefault =
true;
4022 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4023 options::OPT__SLASH_diagnostics_column,
4024 options::OPT__SLASH_diagnostics_caret)) {
4025 switch (A->getOption().getID()) {
4026 case options::OPT__SLASH_diagnostics_caret:
4027 CaretDefault =
true;
4028 ColumnDefault =
true;
4030 case options::OPT__SLASH_diagnostics_column:
4031 CaretDefault =
false;
4032 ColumnDefault =
true;
4034 case options::OPT__SLASH_diagnostics_classic:
4035 CaretDefault =
false;
4036 ColumnDefault =
false;
4042 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4043 options::OPT_fno_caret_diagnostics, CaretDefault))
4044 CmdArgs.push_back(
"-fno-caret-diagnostics");
4046 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4047 options::OPT_fno_diagnostics_fixit_info);
4048 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4049 options::OPT_fno_diagnostics_show_option);
4052 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4053 CmdArgs.push_back(
"-fdiagnostics-show-category");
4054 CmdArgs.push_back(A->getValue());
4057 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4058 options::OPT_fno_diagnostics_show_hotness);
4061 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4063 std::string(
"-fdiagnostics-hotness-threshold=") + A->getValue();
4064 CmdArgs.push_back(Args.MakeArgString(Opt));
4068 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4070 std::string(
"-fdiagnostics-misexpect-tolerance=") + A->getValue();
4071 CmdArgs.push_back(Args.MakeArgString(Opt));
4074 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4075 CmdArgs.push_back(
"-fdiagnostics-format");
4076 CmdArgs.push_back(A->getValue());
4077 if (StringRef(A->getValue()) ==
"sarif" ||
4078 StringRef(A->getValue()) ==
"SARIF")
4079 D.
Diag(diag::warn_drv_sarif_format_unstable);
4082 if (
const Arg *A = Args.getLastArg(
4083 options::OPT_fdiagnostics_show_note_include_stack,
4084 options::OPT_fno_diagnostics_show_note_include_stack)) {
4085 const Option &O = A->getOption();
4086 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
4087 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4089 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4096 Args.getLastArg(options::OPT_fcolor_diagnostics,
4097 options::OPT_fno_color_diagnostics);
4098 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4099 StringRef
Value(A->getValue());
4101 D.
Diag(diag::err_drv_invalid_argument_to_option)
4102 <<
Value << A->getOption().getName();
4106 CmdArgs.push_back(
"-fcolor-diagnostics");
4108 if (Args.hasArg(options::OPT_fansi_escape_codes))
4109 CmdArgs.push_back(
"-fansi-escape-codes");
4111 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4112 options::OPT_fno_show_source_location);
4114 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4115 options::OPT_fno_diagnostics_show_line_numbers);
4117 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4118 CmdArgs.push_back(
"-fdiagnostics-absolute-paths");
4120 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4122 CmdArgs.push_back(
"-fno-show-column");
4124 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4125 options::OPT_fno_spell_checking);
4129 const ArgList &Args, Arg *&Arg) {
4130 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4131 options::OPT_gno_split_dwarf);
4132 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))
4135 if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
4138 StringRef
Value = Arg->getValue();
4139 if (
Value ==
"split")
4141 if (
Value ==
"single")
4144 D.
Diag(diag::err_drv_unsupported_option_argument)
4145 << Arg->getSpelling() << Arg->getValue();
4150 const ArgList &Args, ArgStringList &CmdArgs,
4151 unsigned DwarfVersion) {
4152 auto *DwarfFormatArg =
4153 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4154 if (!DwarfFormatArg)
4157 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {
4158 if (DwarfVersion < 3)
4159 D.
Diag(diag::err_drv_argument_only_allowed_with)
4160 << DwarfFormatArg->getAsString(Args) <<
"DWARFv3 or greater";
4161 else if (!T.isArch64Bit())
4162 D.
Diag(diag::err_drv_argument_only_allowed_with)
4163 << DwarfFormatArg->getAsString(Args) <<
"64 bit architecture";
4164 else if (!(T.isOSBinFormatELF() || T.isOSBinFormatXCOFF()))
4165 D.
Diag(diag::err_drv_argument_only_allowed_with)
4166 << DwarfFormatArg->getAsString(Args) <<
"ELF/XCOFF platforms";
4169 DwarfFormatArg->render(Args, CmdArgs);
4174 const ArgList &Args,
bool EmitCodeView,
bool IRInput,
4175 ArgStringList &CmdArgs,
4176 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
4178 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4179 options::OPT_fno_debug_info_for_profiling,
false) &&
4181 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4182 CmdArgs.push_back(
"-fdebug-info-for-profiling");
4195 bool SplitDWARFInlining =
4196 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4197 options::OPT_fno_split_dwarf_inlining,
false);
4202 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4208 SplitDWARFInlining =
false;
4211 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4212 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4216 A->getOption().matches(options::OPT_gN_Group)) {
4222 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
4223 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
4224 (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
4225 SplitDWARFInlining))
4231 bool HasDebuggerTuning =
false;
4233 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4234 HasDebuggerTuning =
true;
4236 if (A->getOption().matches(options::OPT_glldb))
4237 DebuggerTuning = llvm::DebuggerKind::LLDB;
4238 else if (A->getOption().matches(options::OPT_gsce))
4239 DebuggerTuning = llvm::DebuggerKind::SCE;
4240 else if (A->getOption().matches(options::OPT_gdbx))
4241 DebuggerTuning = llvm::DebuggerKind::DBX;
4243 DebuggerTuning = llvm::DebuggerKind::GDB;
4248 bool EmitDwarf =
false;
4252 if (
const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4257 if (!EmitCodeView && !EmitDwarf &&
4258 DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
4260 case llvm::codegenoptions::DIF_CodeView:
4261 EmitCodeView =
true;
4263 case llvm::codegenoptions::DIF_DWARF:
4269 unsigned RequestedDWARFVersion = 0;
4270 unsigned EffectiveDWARFVersion = 0;
4275 EffectiveDWARFVersion =
4278 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4282 if (RequestedDWARFVersion == 0 &&
4283 DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
4284 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
4288 if (
const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4290 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4291 DebuggerTuning == llvm::DebuggerKind::DBX))
4292 CmdArgs.push_back(
"-gstrict-dwarf");
4295 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4303 if (
const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4305 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4307 (DebuggerTuning != llvm::DebuggerKind::SCE &&
4308 DebuggerTuning != llvm::DebuggerKind::DBX)))
4309 CmdArgs.push_back(
"-gno-column-info");
4312 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,
false)) {
4317 if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
4318 DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
4319 DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
4320 CmdArgs.push_back(
"-dwarf-ext-refs");
4321 CmdArgs.push_back(
"-fmodule-format=obj");
4326 if (T.isOSBinFormatELF() && SplitDWARFInlining)
4327 CmdArgs.push_back(
"-fsplit-dwarf-inlining");
4334 bool NeedFullDebug = Args.hasFlag(
4335 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
4336 DebuggerTuning == llvm::DebuggerKind::LLDB ||
4338 if (
const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4341 if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
4342 DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
4343 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4344 options::OPT_feliminate_unused_debug_types,
false))
4345 DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
4346 else if (NeedFullDebug)
4347 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
4350 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4356 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4357 if (RequestedDWARFVersion < 5)
4358 D.
Diag(diag::err_drv_argument_only_allowed_with)
4359 << A->getAsString(Args) <<
"-gdwarf-5";
4360 else if (EffectiveDWARFVersion < 5)
4363 D.
Diag(diag::warn_drv_dwarf_version_limited_by_target)
4365 << EffectiveDWARFVersion;
4367 CmdArgs.push_back(
"-gembed-source");
4371 CmdArgs.push_back(
"-gcodeview");
4373 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4374 options::OPT_gno_codeview_ghash);
4376 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4377 options::OPT_gno_codeview_command_line);
4380 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4381 options::OPT_gno_inline_line_tables);
4385 DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
4386 DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
4394 T.isOSAIX() && !HasDebuggerTuning
4395 ? llvm::DebuggerKind::Default
4399 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4403 CmdArgs.push_back(
"-debug-info-macro");
4406 const auto *PubnamesArg =
4407 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4408 options::OPT_gpubnames, options::OPT_gno_pubnames);
4412 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
4413 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
4414 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
4415 options::OPT_gpubnames)
4417 :
"-ggnu-pubnames");
4418 const auto *SimpleTemplateNamesArg =
4419 Args.getLastArg(options::OPT_gsimple_template_names,
4420 options::OPT_gno_simple_template_names);
4421 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;
4422 if (SimpleTemplateNamesArg &&
4424 const auto &Opt = SimpleTemplateNamesArg->getOption();
4425 if (Opt.matches(options::OPT_gsimple_template_names)) {
4426 ForwardTemplateParams =
true;
4427 CmdArgs.push_back(
"-gsimple-template-names=simple");
4431 if (
const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4432 StringRef
v = A->getValue();
4433 CmdArgs.push_back(Args.MakeArgString(
"-gsrc-hash=" +
v));
4436 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4437 options::OPT_fno_debug_ranges_base_address);
4442 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
4443 if (
const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4446 CmdArgs.push_back(
"-mllvm");
4447 CmdArgs.push_back(
"-generate-arange-section");
4450 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4451 options::OPT_fno_force_dwarf_frame);
4453 if (Args.hasFlag(options::OPT_fdebug_types_section,
4454 options::OPT_fno_debug_types_section,
false)) {
4455 if (!(T.isOSBinFormatELF() || T.isOSBinFormatWasm())) {
4456 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4457 << Args.getLastArg(options::OPT_fdebug_types_section)
4461 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4463 CmdArgs.push_back(
"-mllvm");
4464 CmdArgs.push_back(
"-generate-type-units");
4471 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4472 options::OPT_fno_dwarf_directory_asm,
4474 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4478 if (ForwardTemplateParams)
4479 CmdArgs.push_back(
"-debug-forward-template-params");
4483 if (DebuggerTuning == llvm::DebuggerKind::SCE)
4484 CmdArgs.push_back(
"-dwarf-explicit-import");
4491 ArgStringList &CmdArgs) {
4492 unsigned RTOptionID = options::OPT__SLASH_MT;
4494 if (Args.hasArg(options::OPT__SLASH_LDd))
4497 RTOptionID = options::OPT__SLASH_MTd;
4499 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4500 RTOptionID = A->getOption().getID();
4502 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4503 RTOptionID = llvm::StringSwitch<unsigned>(A->getValue())
4504 .Case(
"static", options::OPT__SLASH_MT)
4505 .Case(
"static_dbg", options::OPT__SLASH_MTd)
4506 .Case(
"dll", options::OPT__SLASH_MD)
4507 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
4508 .Default(options::OPT__SLASH_MT);
4511 StringRef FlagForCRT;
4512 switch (RTOptionID) {
4513 case options::OPT__SLASH_MD:
4514 if (Args.hasArg(options::OPT__SLASH_LDd))
4515 CmdArgs.push_back(
"-D_DEBUG");
4516 CmdArgs.push_back(
"-D_MT");
4517 CmdArgs.push_back(
"-D_DLL");
4518 FlagForCRT =
"--dependent-lib=msvcrt";
4520 case options::OPT__SLASH_MDd:
4521 CmdArgs.push_back(
"-D_DEBUG");
4522 CmdArgs.push_back(
"-D_MT");
4523 CmdArgs.push_back(
"-D_DLL");
4524 FlagForCRT =
"--dependent-lib=msvcrtd";
4526 case options::OPT__SLASH_MT:
4527 if (Args.hasArg(options::OPT__SLASH_LDd))
4528 CmdArgs.push_back(
"-D_DEBUG");
4529 CmdArgs.push_back(
"-D_MT");
4530 CmdArgs.push_back(
"-flto-visibility-public-std");
4531 FlagForCRT =
"--dependent-lib=libcmt";
4533 case options::OPT__SLASH_MTd:
4534 CmdArgs.push_back(
"-D_DEBUG");
4535 CmdArgs.push_back(
"-D_MT");
4536 CmdArgs.push_back(
"-flto-visibility-public-std");
4537 FlagForCRT =
"--dependent-lib=libcmtd";
4540 llvm_unreachable(
"Unexpected option ID.");
4543 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4544 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
4546 CmdArgs.push_back(FlagForCRT.data());
4551 CmdArgs.push_back(
"--dependent-lib=oldnames");
4557 const ArgList &Args,
const char *LinkingOutput)
const {
4559 const llvm::Triple &RawTriple = TC.
getTriple();
4561 const std::string &TripleStr = Triple.getTriple();
4564 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4566 ArgStringList CmdArgs;
4568 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4580 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
4583 bool IsHostOffloadingAction =
4586 Args.hasFlag(options::OPT_offload_new_driver,
4587 options::OPT_no_offload_new_driver,
false));
4590 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4591 bool IsUsingLTO = D.
isUsingLTO(IsDeviceOffloadAction);
4592 auto LTOMode = D.
getLTOMode(IsDeviceOffloadAction);
4596 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(),
"extract-api",
4600 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4604 const InputInfo *CudaDeviceInput =
nullptr;
4605 const InputInfo *OpenMPDeviceInput =
nullptr;
4607 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4609 }
else if (IsExtractAPI) {
4610 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4611 if (I.getType() != ExpectedInputType) {
4612 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4616 ExtractAPIInputs.push_back(I);
4617 }
else if (IsHostOffloadingAction) {
4618 HostOffloadingInputs.push_back(I);
4619 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4620 CudaDeviceInput = &I;
4621 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4622 OpenMPDeviceInput = &I;
4624 llvm_unreachable(
"unexpectedly given multiple inputs");
4628 const llvm::Triple *AuxTriple =
4630 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4631 bool IsIAMCU = RawTriple.isOSIAMCU();
4636 if (IsCuda || IsHIP)
4637 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4641 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4646 CmdArgs.push_back(
"-cc1");
4649 CmdArgs.push_back(
"-triple");
4650 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4652 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4653 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4654 Args.ClaimAllArgs(options::OPT_MJ);
4655 }
else if (
const Arg *GenCDBFragment =
4656 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4657 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4658 TripleStr, Output, Input, Args);
4659 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4662 if (IsCuda || IsHIP) {
4665 std::string NormalizedTriple;
4683 assert(CTC &&
"Expected valid CUDA Toolchain.");
4685 CmdArgs.push_back(Args.MakeArgString(
4686 Twine(
"-target-sdk-version=") +
4694 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4697 CmdArgs.push_back(
"-aux-triple");
4698 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4701 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl,
false)) {
4702 CmdArgs.push_back(
"-fsycl-is-device");
4704 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
4705 A->render(Args, CmdArgs);
4708 CmdArgs.push_back(
"-sycl-std=2020");
4712 if (IsOpenMPDevice) {
4714 std::string NormalizedTriple =
4718 CmdArgs.push_back(
"-aux-triple");
4719 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4722 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
4723 Triple.getArch() == llvm::Triple::thumb)) {
4724 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4725 unsigned Version = 0;
4727 Triple.getArchName().substr(
Offset).consumeInteger(10, Version);
4728 if (Failure || Version < 7)
4729 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4739 if (Triple.isSPIR() || Triple.isSPIRV())
4740 CmdArgs.push_back(
"-Wspir-compat");
4743 RewriteKind rewriteKind = RK_None;
4752 if (!isa<AssembleJobAction>(JA)) {
4756 Args.ClaimAllArgs(options::OPT_mrelax_all);
4757 Args.ClaimAllArgs(options::OPT_mno_relax_all);
4758 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4759 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4760 switch (
C.getDefaultToolChain().getArch()) {
4761 case llvm::Triple::arm:
4762 case llvm::Triple::armeb:
4763 case llvm::Triple::thumb:
4764 case llvm::Triple::thumbeb:
4765 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4771 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4772 Args.ClaimAllArgs(options::OPT_Xassembler);
4773 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
4776 if (isa<AnalyzeJobAction>(JA)) {
4777 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
4778 CmdArgs.push_back(
"-analyze");
4779 }
else if (isa<MigrateJobAction>(JA)) {
4780 CmdArgs.push_back(
"-migrate");
4781 }
else if (isa<PreprocessJobAction>(JA)) {
4782 if (Output.
getType() == types::TY_Dependencies)
4783 CmdArgs.push_back(
"-Eonly");
4785 CmdArgs.push_back(
"-E");
4786 if (Args.hasArg(options::OPT_rewrite_objc) &&
4787 !Args.hasArg(options::OPT_g_Group))
4788 CmdArgs.push_back(
"-P");
4789 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
4790 CmdArgs.push_back(
"-fdirectives-only");
4792 }
else if (isa<AssembleJobAction>(JA)) {
4793 CmdArgs.push_back(
"-emit-obj");
4798 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4799 }
else if (isa<PrecompileJobAction>(JA)) {
4800 if (JA.
getType() == types::TY_Nothing)
4801 CmdArgs.push_back(
"-fsyntax-only");
4802 else if (JA.
getType() == types::TY_ModuleFile)
4803 CmdArgs.push_back(
"-emit-module-interface");
4804 else if (JA.
getType() == types::TY_HeaderUnit)
4805 CmdArgs.push_back(
"-emit-header-unit");
4807 CmdArgs.push_back(
"-emit-pch");
4808 }
else if (isa<VerifyPCHJobAction>(JA)) {
4809 CmdArgs.push_back(
"-verify-pch");
4810 }
else if (isa<ExtractAPIJobAction>(JA)) {
4811 assert(JA.
getType() == types::TY_API_INFO &&
4812 "Extract API actions must generate a API information.");
4813 CmdArgs.push_back(
"-extract-api");
4814 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
4815 ProductNameArg->render(Args, CmdArgs);
4816 if (Arg *ExtractAPIIgnoresFileArg =
4817 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
4818 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
4820 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
4821 "Invalid action for clang tool.");
4822 if (JA.
getType() == types::TY_Nothing) {
4823 CmdArgs.push_back(
"-fsyntax-only");
4824 }
else if (JA.
getType() == types::TY_LLVM_IR ||
4825 JA.
getType() == types::TY_LTO_IR) {
4826 CmdArgs.push_back(
"-emit-llvm");
4827 }
else if (JA.
getType() == types::TY_LLVM_BC ||
4828 JA.
getType() == types::TY_LTO_BC) {
4830 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
4831 Args.hasArg(options::OPT_emit_llvm)) {
4832 CmdArgs.push_back(
"-emit-llvm");
4834 CmdArgs.push_back(
"-emit-llvm-bc");
4836 }
else if (JA.
getType() == types::TY_IFS ||
4837 JA.
getType() == types::TY_IFS_CPP) {
4839 Args.hasArg(options::OPT_interface_stub_version_EQ)
4840 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
4842 CmdArgs.push_back(
"-emit-interface-stubs");
4844 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
4845 }
else if (JA.
getType() == types::TY_PP_Asm) {
4846 CmdArgs.push_back(
"-S");
4847 }
else if (JA.
getType() == types::TY_AST) {
4848 CmdArgs.push_back(
"-emit-pch");
4849 }
else if (JA.
getType() == types::TY_ModuleFile) {
4850 CmdArgs.push_back(
"-module-file-info");
4851 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
4852 CmdArgs.push_back(
"-rewrite-objc");
4853 rewriteKind = RK_NonFragile;
4854 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
4855 CmdArgs.push_back(
"-rewrite-objc");
4856 rewriteKind = RK_Fragile;
4858 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
4865 if (JA.
getType() == types::TY_LLVM_BC)
4866 CmdArgs.push_back(
"-emit-llvm-uselists");
4870 !Args.hasFlag(options::OPT_offload_new_driver,
4871 options::OPT_no_offload_new_driver,
false) &&
4872 !Triple.isAMDGPU()) {
4873 D.
Diag(diag::err_drv_unsupported_opt_for_target)
4874 << Args.getLastArg(options::OPT_foffload_lto,
4875 options::OPT_foffload_lto_EQ)
4877 << Triple.getTriple();
4878 }
else if (Triple.isNVPTX() && !IsRDCMode &&
4880 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
4881 << Args.getLastArg(options::OPT_foffload_lto,
4882 options::OPT_foffload_lto_EQ)
4887 CmdArgs.push_back(Args.MakeArgString(
4888 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
4889 CmdArgs.push_back(
"-flto-unit");
4894 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
4896 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
4898 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
4899 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
4902 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
4903 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
4905 if (Args.getLastArg(options::OPT_save_temps_EQ))
4906 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
4908 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
4909 options::OPT_fmemory_profile_EQ,
4910 options::OPT_fno_memory_profile);
4912 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
4913 MemProfArg->render(Args, CmdArgs);
4917 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
4918 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
4920 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
4922 CmdArgs.push_back(
"-disable-llvm-passes");
4929 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
4930 options::OPT_mkernel,
4931 options::OPT_fapple_kext,
4932 options::OPT_ffunction_sections,
4933 options::OPT_fno_function_sections,
4934 options::OPT_fdata_sections,
4935 options::OPT_fno_data_sections,
4936 options::OPT_fbasic_block_sections_EQ,
4937 options::OPT_funique_internal_linkage_names,
4938 options::OPT_fno_unique_internal_linkage_names,
4939 options::OPT_funique_section_names,
4940 options::OPT_fno_unique_section_names,
4941 options::OPT_funique_basic_block_section_names,
4942 options::OPT_fno_unique_basic_block_section_names,
4943 options::OPT_mrestrict_it,
4944 options::OPT_mno_restrict_it,
4945 options::OPT_mstackrealign,
4946 options::OPT_mno_stackrealign,
4947 options::OPT_mstack_alignment,
4948 options::OPT_mcmodel_EQ,
4949 options::OPT_mlong_calls,
4950 options::OPT_mno_long_calls,
4951 options::OPT_ggnu_pubnames,
4952 options::OPT_gdwarf_aranges,
4953 options::OPT_fdebug_types_section,
4954 options::OPT_fno_debug_types_section,
4955 options::OPT_fdwarf_directory_asm,
4956 options::OPT_fno_dwarf_directory_asm,
4957 options::OPT_mrelax_all,
4958 options::OPT_mno_relax_all,
4959 options::OPT_ftrap_function_EQ,
4960 options::OPT_ffixed_r9,
4961 options::OPT_mfix_cortex_a53_835769,
4962 options::OPT_mno_fix_cortex_a53_835769,
4963 options::OPT_ffixed_x18,
4964 options::OPT_mglobal_merge,
4965 options::OPT_mno_global_merge,
4966 options::OPT_mred_zone,
4967 options::OPT_mno_red_zone,
4968 options::OPT_Wa_COMMA,
4969 options::OPT_Xassembler,
4972 for (
const auto &A : Args)
4973 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
4974 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
4977 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
4978 options::OPT_fno_optimize_sibling_calls);
4986 case llvm::Triple::arm:
4987 case llvm::Triple::armeb:
4988 case llvm::Triple::thumbeb:
4989 RenderARMABI(D, Triple, Args, CmdArgs);
4991 case llvm::Triple::aarch64:
4992 case llvm::Triple::aarch64_32:
4993 case llvm::Triple::aarch64_be:
4994 RenderAArch64ABI(Triple, Args, CmdArgs);
4999 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5000 if (A->getOption().matches(options::OPT_O4)) {
5001 CmdArgs.push_back(
"-O3");
5002 D.
Diag(diag::warn_O4_is_O3);
5004 A->render(Args, CmdArgs);
5009 if (Output.
getType() == types::TY_Dependencies) {
5012 CmdArgs.push_back(
"-o");
5015 assert(Output.
isNothing() &&
"Input output.");
5018 for (
const auto &II : Inputs) {
5020 if (II.isFilename())
5021 CmdArgs.push_back(II.getFilename());
5023 II.getInputArg().renderAsInput(Args, CmdArgs);
5026 C.addCommand(std::make_unique<Command>(
5032 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5033 CmdArgs.push_back(
"-fembed-bitcode=marker");
5038 if (!
C.isForDiagnostics())
5039 CmdArgs.push_back(
"-disable-free");
5040 CmdArgs.push_back(
"-clear-ast-before-backend");
5043 const bool IsAssertBuild =
false;
5045 const bool IsAssertBuild =
true;
5050 CmdArgs.push_back(
"-disable-llvm-verifier");
5053 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5054 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5055 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5057 return types::isLLVMIR(II.getType());
5059 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5061 CmdArgs.push_back(
"-discard-value-names");
5066 CmdArgs.push_back(
"-main-file-name");
5071 if (Args.hasArg(options::OPT_static))
5072 CmdArgs.push_back(
"-static-define");
5074 if (Args.hasArg(options::OPT_municode))
5075 CmdArgs.push_back(
"-DUNICODE");
5077 if (isa<AnalyzeJobAction>(JA))
5080 if (isa<AnalyzeJobAction>(JA) ||
5081 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5082 CmdArgs.push_back(
"-setup-static-analyzer");
5087 bool FoundAnalyzerConfig =
false;
5088 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5089 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5090 FoundAnalyzerConfig =
true;
5093 if (!FoundAnalyzerConfig)
5094 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5095 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5096 FoundAnalyzerConfig =
true;
5099 if (FoundAnalyzerConfig)
5100 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5105 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5106 if (FunctionAlignment) {
5107 CmdArgs.push_back(
"-function-alignment");
5108 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5113 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5115 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5117 << A->getAsString(Args) << A->getValue();
5119 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5120 << A->getAsString(Args) << A->getValue();
5123 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5124 Twine(std::min(
Value, 65536u))));
5127 llvm::Reloc::Model RelocationModel;
5130 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5131 Arg *LastPICDataRelArg =
5132 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5133 options::OPT_mpic_data_is_text_relative);
5134 bool NoPICDataIsTextRelative =
false;
5135 if (LastPICDataRelArg) {
5136 if (LastPICDataRelArg->getOption().matches(
5137 options::OPT_mno_pic_data_is_text_relative)) {
5138 NoPICDataIsTextRelative =
true;
5140 D.
Diag(diag::err_drv_argument_only_allowed_with)
5141 <<
"-mno-pic-data-is-text-relative"
5144 if (!Triple.isSystemZ())
5145 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5146 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5147 :
"-mpic-data-is-text-relative")
5151 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5152 RelocationModel == llvm::Reloc::ROPI_RWPI;
5153 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5154 RelocationModel == llvm::Reloc::ROPI_RWPI;
5156 if (Args.hasArg(options::OPT_mcmse) &&
5157 !Args.hasArg(options::OPT_fallow_unsupported)) {
5159 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5161 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5165 !Args.hasArg(options::OPT_fallow_unsupported))
5166 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5170 CmdArgs.push_back(
"-mrelocation-model");
5171 CmdArgs.push_back(RMName);
5174 CmdArgs.push_back(
"-pic-level");
5175 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5177 CmdArgs.push_back(
"-pic-is-pie");
5178 if (NoPICDataIsTextRelative)
5179 CmdArgs.push_back(
"-mcmodel=medium");
5182 if (RelocationModel == llvm::Reloc::ROPI ||
5183 RelocationModel == llvm::Reloc::ROPI_RWPI)
5184 CmdArgs.push_back(
"-fropi");
5185 if (RelocationModel == llvm::Reloc::RWPI ||
5186 RelocationModel == llvm::Reloc::ROPI_RWPI)
5187 CmdArgs.push_back(
"-frwpi");
5189 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5190 CmdArgs.push_back(
"-meabi");
5191 CmdArgs.push_back(A->getValue());
5205 if (Triple.isOSBinFormatELF()) {
5206 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5207 options::OPT_fno_semantic_interposition);
5208 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5210 bool SupportsLocalAlias =
5211 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5213 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5214 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5215 A->render(Args, CmdArgs);
5216 else if (!SupportsLocalAlias)
5217 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5223 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5225 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5226 << A->getValue() << A->getAsString(Args);
5227 Model = A->getValue();
5230 if (Model !=
"posix") {
5231 CmdArgs.push_back(
"-mthread-model");
5232 CmdArgs.push_back(Args.MakeArgString(Model));
5236 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5237 StringRef Name = A->getValue();
5238 if (Name ==
"SVML") {
5239 if (Triple.getArch() != llvm::Triple::x86 &&
5240 Triple.getArch() != llvm::Triple::x86_64)
5241 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5242 << Name << Triple.getArchName();
5243 }
else if (Name ==
"LIBMVEC-X86") {
5244 if (Triple.getArch() != llvm::Triple::x86 &&
5245 Triple.getArch() != llvm::Triple::x86_64)
5246 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5247 << Name << Triple.getArchName();
5248 }
else if (Name ==
"SLEEF") {
5249 if (Triple.getArch() != llvm::Triple::aarch64 &&
5250 Triple.getArch() != llvm::Triple::aarch64_be)
5251 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5252 << Name << Triple.getArchName();
5254 A->render(Args, CmdArgs);
5257 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5258 options::OPT_fno_merge_all_constants,
false))
5259 CmdArgs.push_back(
"-fmerge-all-constants");
5261 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5262 options::OPT_fno_delete_null_pointer_checks);
5266 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5267 if (!Triple.isOSAIX() || Triple.isPPC32())
5268 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5269 << A->getSpelling() << RawTriple.str();
5270 CmdArgs.push_back(
"-mabi=quadword-atomics");
5273 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5276 if (Triple.isOSAIX())
5277 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5278 << A->getSpelling() << RawTriple.str();
5281 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5282 StringRef
V = A->getValue(), V1 =
V;
5284 if (V1.consumeInteger(10, Size) || !V1.empty())
5285 D.
Diag(diag::err_drv_invalid_argument_to_option)
5286 <<
V << A->getOption().getName();
5288 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5291 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5292 options::OPT_fno_jump_tables);
5293 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5294 options::OPT_fno_profile_sample_accurate);
5295 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5296 options::OPT_fno_preserve_as_comments);
5298 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5299 CmdArgs.push_back(
"-mregparm");
5300 CmdArgs.push_back(A->getValue());
5303 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5304 options::OPT_msvr4_struct_return)) {
5306 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5307 << A->getSpelling() << RawTriple.str();
5308 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5309 CmdArgs.push_back(
"-maix-struct-return");
5311 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5312 CmdArgs.push_back(
"-msvr4-struct-return");
5316 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5317 options::OPT_freg_struct_return)) {
5318 if (TC.
getArch() != llvm::Triple::x86) {
5319 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5320 << A->getSpelling() << RawTriple.str();
5321 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5322 CmdArgs.push_back(
"-fpcc-struct-return");
5324 assert(A->getOption().matches(options::OPT_freg_struct_return));
5325 CmdArgs.push_back(
"-freg-struct-return");
5329 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
5330 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5332 if (Args.hasArg(options::OPT_fenable_matrix)) {
5334 CmdArgs.push_back(
"-fenable-matrix");
5335 CmdArgs.push_back(
"-mllvm");
5336 CmdArgs.push_back(
"-enable-matrix");
5341 const char *FPKeepKindStr =
nullptr;
5342 switch (FPKeepKind) {
5344 FPKeepKindStr =
"-mframe-pointer=none";
5347 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5350 FPKeepKindStr =
"-mframe-pointer=all";
5353 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5354 CmdArgs.push_back(FPKeepKindStr);
5356 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5357 options::OPT_fno_zero_initialized_in_bss);
5362 OptSpecifier StrictAliasingAliasOption =
5363 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5366 bool TBAAOnByDefault = !D.
IsCLMode();
5367 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5368 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
5369 CmdArgs.push_back(
"-relaxed-aliasing");
5370 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5371 options::OPT_fno_struct_path_tbaa,
true))
5372 CmdArgs.push_back(
"-no-struct-path-tbaa");
5373 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5374 options::OPT_fno_strict_enums);
5375 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5376 options::OPT_fno_strict_return);
5377 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5378 options::OPT_fno_allow_editor_placeholders);
5379 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5380 options::OPT_fno_strict_vtable_pointers);
5381 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5382 options::OPT_fno_force_emit_vtables);
5383 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5384 options::OPT_fno_optimize_sibling_calls);
5385 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5386 options::OPT_fno_escaping_block_tail_calls);
5388 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5389 options::OPT_fno_fine_grained_bitfield_accesses);
5391 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5392 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5395 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5396 options::OPT_fno_split_stack);
5399 if (Args.hasFlag(options::OPT_fprotect_parens,
5400 options::OPT_fno_protect_parens,
false))
5401 CmdArgs.push_back(
"-fprotect-parens");
5405 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5406 const llvm::Triple::ArchType Arch = TC.
getArch();
5407 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5408 StringRef
V = A->getValue();
5410 CmdArgs.push_back(
"-fextend-arguments=64");
5412 D.
Diag(diag::err_drv_invalid_argument_to_option)
5413 << A->getValue() << A->getOption().getName();
5415 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5416 << A->getOption().getName() << TripleStr;
5419 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5420 if (TC.
getArch() == llvm::Triple::avr)
5421 A->render(Args, CmdArgs);
5423 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5424 << A->getAsString(Args) << TripleStr;
5427 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5429 A->render(Args, CmdArgs);
5431 (A->getOption().getID() != options::OPT_mlong_double_80))
5432 A->render(Args, CmdArgs);
5434 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5435 << A->getAsString(Args) << TripleStr;
5441 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5442 IsIntegratedAssemblerDefault))
5443 CmdArgs.push_back(
"-fno-verbose-asm");
5447 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5448 StringRef
V = A->getValue();
5451 A->render(Args, CmdArgs);
5452 else if (!
V.consumeInteger(10, Num) && Num > 0 &&
5453 (
V.empty() || (
V.consume_front(
".") &&
5454 !
V.consumeInteger(10, Num) &&
V.empty())))
5455 A->render(Args, CmdArgs);
5457 D.
Diag(diag::err_drv_invalid_argument_to_option)
5458 << A->getValue() << A->getOption().getName();
5464 CmdArgs.push_back(
"-no-integrated-as");
5466 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5467 CmdArgs.push_back(
"-mdebug-pass");
5468 CmdArgs.push_back(
"Structure");
5470 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5471 CmdArgs.push_back(
"-mdebug-pass");
5472 CmdArgs.push_back(
"Arguments");
5478 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5479 CmdArgs.push_back(
"-mconstructor-aliases");
5483 if (KernelOrKext && RawTriple.isOSDarwin())
5484 CmdArgs.push_back(
"-fforbid-guard-variables");
5486 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5487 Triple.isWindowsGNUEnvironment())) {
5488 CmdArgs.push_back(
"-mms-bitfields");
5494 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5495 options::OPT_fno_direct_access_external_data))
5496 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5498 A->render(Args, CmdArgs);
5500 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt,
false)) {
5501 CmdArgs.push_back(
"-fno-plt");
5508 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5511 CmdArgs.push_back(
"-ffreestanding");
5513 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5520 bool IsAsyncUnwindTablesDefault =
5522 bool IsSyncUnwindTablesDefault =
5525 bool AsyncUnwindTables = Args.hasFlag(
5526 options::OPT_fasynchronous_unwind_tables,
5527 options::OPT_fno_asynchronous_unwind_tables,
5528 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5531 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5532 IsSyncUnwindTablesDefault && !Freestanding);
5533 if (AsyncUnwindTables)
5534 CmdArgs.push_back(
"-funwind-tables=2");
5535 else if (UnwindTables)
5536 CmdArgs.push_back(
"-funwind-tables=1");
5540 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5541 (IsCudaDevice || IsHIPDevice)) {
5542 const ArgList &HostArgs =
5544 std::string HostCPU =
5546 if (!HostCPU.empty()) {
5547 CmdArgs.push_back(
"-aux-target-cpu");
5548 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5556 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
5557 StringRef CM = A->getValue();
5558 if (CM ==
"small" || CM ==
"kernel" || CM ==
"medium" || CM ==
"large" ||
5560 if (Triple.isOSAIX() && CM ==
"medium")
5561 CmdArgs.push_back(
"-mcmodel=large");
5562 else if (Triple.isAArch64() && (CM ==
"kernel" || CM ==
"medium"))
5563 D.
Diag(diag::err_drv_invalid_argument_to_option)
5564 << CM << A->getOption().getName();
5566 A->render(Args, CmdArgs);
5568 D.
Diag(diag::err_drv_invalid_argument_to_option)
5569 << CM << A->getOption().getName();
5573 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5574 StringRef
Value = A->getValue();
5575 unsigned TLSSize = 0;
5576 Value.getAsInteger(10, TLSSize);
5577 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5578 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5579 << A->getOption().getName() << TripleStr;
5580 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5581 D.
Diag(diag::err_drv_invalid_int_value)
5582 << A->getOption().getName() <<
Value;
5583 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5587 std::string CPU =
getCPUName(D, Args, Triple,
false);
5589 CmdArgs.push_back(
"-target-cpu");
5590 CmdArgs.push_back(Args.MakeArgString(CPU));
5593 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5596 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
5597 llvm::codegenoptions::NoDebugInfo;
5598 bool EmitCodeView =
false;
5603 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
5611 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
5612 if (TC.
getTriple().isOSBinFormatELF()) {
5613 if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
5614 CmdArgs.push_back(
"-fjmc");
5616 D.
Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<
"-fjmc"
5619 D.
Diag(clang::diag::warn_drv_fjmc_for_elf_only);
5628 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5629 isa<BackendJobAction>(JA));
5631 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
5632 CmdArgs.push_back(
"-split-dwarf-file");
5633 CmdArgs.push_back(SplitDWARFOut);
5635 CmdArgs.push_back(
"-split-dwarf-output");
5636 CmdArgs.push_back(SplitDWARFOut);
5641 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5642 CmdArgs.push_back(
"-target-linker-version");
5643 CmdArgs.push_back(A->getValue());
5648 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
5650 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
5651 TC.
getArch() == llvm::Triple::x86) {
5652 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
5653 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
5654 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
5655 << Unsupported->getOption().getName();
5658 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
5659 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5660 << Unsupported->getOption().getName()
5661 <<
"please use -maltivec and include altivec.h explicitly";
5662 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
5663 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
5664 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
5667 Args.AddAllArgs(CmdArgs, options::OPT_v);
5669 if (Args.getLastArg(options::OPT_H)) {
5670 CmdArgs.push_back(
"-H");
5671 CmdArgs.push_back(
"-sys-header-deps");
5673 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
5676 CmdArgs.push_back(
"-header-include-file");
5680 CmdArgs.push_back(
"-sys-header-deps");
5681 CmdArgs.push_back(Args.MakeArgString(
5682 "-header-include-format=" +
5685 Args.MakeArgString(
"-header-include-filtering=" +
5689 Args.AddLastArg(CmdArgs, options::OPT_P);
5690 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
5693 CmdArgs.push_back(
"-diagnostic-log-file");
5702 CmdArgs.push_back(
"-disable-pragma-debug-crash");
5706 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
5707 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
5708 CmdArgs.push_back(
"-mllvm");
5709 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
5714 if (Args.hasFlag(options::OPT_ffunction_sections,
5715 options::OPT_fno_function_sections, UseSeparateSections)) {
5716 CmdArgs.push_back(
"-ffunction-sections");
5719 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
5720 StringRef Val = A->getValue();
5721 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5722 if (Val !=
"all" && Val !=
"labels" && Val !=
"none" &&
5723 !Val.startswith(
"list="))
5724 D.
Diag(diag::err_drv_invalid_value)
5725 << A->getAsString(Args) << A->getValue();
5727 A->render(Args, CmdArgs);
5728 }
else if (Triple.isNVPTX()) {
5731 }
else if (Val !=
"none") {
5734 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5735 << A->getAsString(Args) << TripleStr;
5739 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
5740 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
5741 UseSeparateSections || HasDefaultDataSections)) {
5742 CmdArgs.push_back(
"-fdata-sections");
5745 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
5746 options::OPT_fno_unique_section_names);
5747 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
5748 options::OPT_fno_unique_internal_linkage_names);
5749 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
5750 options::OPT_fno_unique_basic_block_section_names);
5751 Args.addOptInFlag(CmdArgs, options::OPT_fconvergent_functions,
5752 options::OPT_fno_convergent_functions);
5754 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
5755 options::OPT_fno_split_machine_functions)) {
5757 if (Triple.isX86() && Triple.isOSBinFormatELF()) {
5758 if (A->getOption().matches(options::OPT_fsplit_machine_functions))
5759 A->render(Args, CmdArgs);
5761 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5762 << A->getAsString(Args) << TripleStr;
5766 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
5767 options::OPT_finstrument_functions_after_inlining,
5768 options::OPT_finstrument_function_entry_bare);
5773 if (!Triple.isNVPTX() && !Triple.isAMDGCN())
5776 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
5779 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
5780 CmdArgs.push_back(
"-mllvm");
5781 CmdArgs.push_back(
"-sample-profile-use-profi");
5785 if (RawTriple.isPS() &&
5786 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
5792 if (Args.hasArg(options::OPT_nostdinc)) {
5793 CmdArgs.push_back(
"-nostdsysteminc");
5794 CmdArgs.push_back(
"-nobuiltininc");
5796 if (Args.hasArg(options::OPT_nostdlibinc))
5797 CmdArgs.push_back(
"-nostdsysteminc");
5798 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
5799 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
5803 CmdArgs.push_back(
"-resource-dir");
5806 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
5815 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
5821 Args.ClaimAllArgs(options::OPT_D);
5824 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5825 if (A->getOption().matches(options::OPT_O4)) {
5826 CmdArgs.push_back(
"-O3");
5827 D.
Diag(diag::warn_O4_is_O3);
5829 A->render(Args, CmdArgs);
5835 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
5836 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
5841 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
5842 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
5848 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
5851 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
5853 if (A->getOption().getID() == options::OPT__SLASH_wd) {
5854 unsigned WarningNumber;
5855 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
5856 D.
Diag(diag::err_drv_invalid_int_value)
5857 << A->getAsString(Args) << A->getValue();
5862 CmdArgs.push_back(Args.MakeArgString(
5867 A->render(Args, CmdArgs);
5870 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
5871 CmdArgs.push_back(
"-pedantic");
5872 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
5873 Args.AddLastArg(CmdArgs, options::OPT_w);
5875 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
5876 options::OPT_fno_fixed_point);
5878 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
5879 A->render(Args, CmdArgs);
5881 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5882 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5884 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
5885 A->render(Args, CmdArgs);
5892 bool ImplyVCPPCVer =
false;
5893 bool ImplyVCPPCXXVer =
false;
5894 const Arg *
Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
5896 if (
Std->getOption().matches(options::OPT_ansi))
5898 CmdArgs.push_back(
"-std=c++98");
5900 CmdArgs.push_back(
"-std=c89");
5902 Std->render(Args, CmdArgs);
5905 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
5906 options::OPT_ftrigraphs,
5907 options::OPT_fno_trigraphs))
5909 A->render(Args, CmdArgs);
5918 if (!Args.hasArg(options::OPT__SLASH_std)) {
5919 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
5922 ImplyVCPPCVer =
true;
5924 else if (IsWindowsMSVC)
5925 ImplyVCPPCXXVer =
true;
5927 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
5928 options::OPT_fno_trigraphs);
5944 Args.getLastArg(options::OPT_Wwrite_strings,
5945 options::OPT_Wno_write_strings, options::OPT_w);
5947 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
5948 CmdArgs.push_back(
"-fconst-strings");
5955 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
5957 CmdArgs.push_back(
"-fdeprecated-macro");
5961 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::O