Lines Matching defs:Args
72 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
73 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
78 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
79 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
81 << A->getBaseArg().getAsString(Args)
87 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
89 if (Args.hasArg(options::OPT_static))
91 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
92 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
178 static void ParseMRecip(const Driver &D, const ArgList &Args,
185 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
192 OutStrings.push_back(Args.MakeArgString(Out + "all"));
204 OutStrings.push_back(Args.MakeArgString(Out + Val));
277 Out = Args.MakeArgString(Out + Prefix + Val);
279 Out = Args.MakeArgString(Out + ",");
282 OutStrings.push_back(Args.MakeArgString(Out));
287 static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args,
289 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
302 CmdArgs.push_back(Args.MakeArgString("-mprefer-vector-width=" + Value));
327 static bool addExceptionArgs(const ArgList &Args, types::ID InputType,
336 Args.ClaimAllArgs(options::OPT_fexceptions);
337 Args.ClaimAllArgs(options::OPT_fno_exceptions);
338 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
339 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
340 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
341 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
342 Args.ClaimAllArgs(options::OPT_fasync_exceptions);
343 Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
348 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
353 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
364 Args.hasFlag(options::OPT_fobjc_exceptions,
375 Arg *ExceptionArg = Args.getLastArg(
393 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
395 Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,
403 static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC,
415 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
420 static const char *addDebugCompDirArg(const ArgList &Args,
423 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
426 CmdArgs.push_back(Args.MakeArgString(Twine("-fdebug-compilation-dir=") +
429 A->render(Args, CmdArgs);
432 CmdArgs.push_back(Args.MakeArgString("-fdebug-compilation-dir=" + *CWD));
438 static void addDebugObjectName(const ArgList &Args, ArgStringList &CmdArgs,
442 for (auto *Arg : Args.filtered(options::OPT_Xclang))
446 if (Args.hasArg(options::OPT_object_file_name_EQ))
468 Args.MakeArgString(Twine("-object-file-name=") + ObjFileNameForDebug));
473 const ArgList &Args, ArgStringList &CmdArgs) {
478 CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));
481 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
493 static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args,
495 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
502 CmdArgs.push_back(Args.MakeArgString("-fmacro-prefix-map=" + Map));
508 static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args,
510 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
517 CmdArgs.push_back(Args.MakeArgString("-fcoverage-prefix-map=" + Map));
525 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
526 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
556 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
560 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
564 if (Args.hasArg(options::OPT_rewrite_objc))
588 const ArgList &Args, SanitizerArgs &SanArgs,
591 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
598 auto *CSPGOGenerateArg = getLastCSProfileGenerateArg(Args);
600 auto *ProfileGenerateArg = Args.getLastArg(
613 auto *ProfileUseArg = getLastProfileUseArg(Args);
630 if (Arg *ProfileSampleUseArg = getLastProfileSampleUseArg(Args))
638 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +
643 Args.hasFlag(options::OPT_frtlib_defaultlib,
646 CmdArgs.push_back(Args.MakeArgString(
647 "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));
664 Args.hasFlag(options::OPT_frtlib_defaultlib,
667 CmdArgs.push_back(Args.MakeArgString(
668 "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));
676 Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));
682 CmdArgs.push_back(Args.MakeArgString(
693 Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));
697 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
699 Args.hasArg(options::OPT_coverage);
700 bool EmitCovData = TC.needsGCovInstrumentation(Args);
702 if (Args.hasFlag(options::OPT_fcoverage_mapping,
712 if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
714 if (!Args.hasFlag(options::OPT_fcoverage_mapping,
723 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
726 CmdArgs.push_back(Args.MakeArgString(
729 A->render(Args, CmdArgs);
732 CmdArgs.push_back(Args.MakeArgString("-fcoverage-compilation-dir=" + *CWD));
735 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
736 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
737 if (!Args.hasArg(options::OPT_coverage))
744 Args.MakeArgString(Twine("-fprofile-exclude-files=" + v)));
747 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
748 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
749 if (!Args.hasArg(options::OPT_coverage))
755 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-filter-files=" + v)));
758 if (const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
769 if (const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
772 D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
775 Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
779 D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
782 CmdArgs.push_back(Args.MakeArgString("-fprofile-function-groups=" +
785 CmdArgs.push_back(Args.MakeArgString("-fprofile-selected-function-group=" +
793 if (Args.hasArg(options::OPT_fprofile_arcs) ||
794 Args.hasArg(options::OPT_coverage))
795 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
799 (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
806 if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
824 Args.MakeArgString("-coverage-notes-file=" + CoverageFilename));
835 Args.MakeArgString("-coverage-data-file=" + CoverageFilename));
841 RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
848 Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));
867 static bool checkDebugInfoOption(const Arg *A, const ArgList &Args,
873 << A->getAsString(Args) << TC.getTripleString();
877 static void RenderDebugInfoCompressionArgs(const ArgList &Args,
881 const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
884 if (checkDebugInfoOption(A, Args, D, TC)) {
891 Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
898 Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
910 const ArgList &Args,
918 if (haveAMDGPUCodeObjectVersionArgument(D, Args)) {
919 unsigned CodeObjVer = getAMDGPUCodeObjectVersion(D, Args);
921 Args.MakeArgString(Twine("--amdhsa-code-object-version=") +
927 Args.MakeArgString(Twine("-mcode-object-version=") +
972 const Driver &D, const ArgList &Args,
978 CheckPreprocessingOptions(D, Args);
980 Args.AddLastArg(CmdArgs, options::OPT_C);
981 Args.AddLastArg(CmdArgs, options::OPT_CC);
984 Arg *ArgM = Args.getLastArg(options::OPT_MM);
986 ArgM = Args.getLastArg(options::OPT_M);
987 Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
989 ArgMD = Args.getLastArg(options::OPT_MD);
1000 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1008 DepFile = getDependencyFileName(Args, Inputs);
1015 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1019 A->render(Args, CmdArgs);
1024 CmdArgs.push_back(Args.MakeArgString(Quoted));
1034 Arg *OutputOpt = Args.getLastArg(options::OPT_o, options::OPT__SLASH_Fo);
1043 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1049 CmdArgs.push_back(Args.MakeArgString(Quoted));
1056 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1057 Args.hasArg(options::OPT_fmodule_file_deps))
1061 if (Args.hasArg(options::OPT_MG)) {
1068 Args.AddLastArg(CmdArgs, options::OPT_MP);
1069 Args.AddLastArg(CmdArgs, options::OPT_MV);
1076 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1078 getToolChain().AddHIPIncludeArgs(Args, CmdArgs);
1083 !Args.hasArg(options::OPT_nostdinc) &&
1084 !Args.hasArg(options::OPT_nogpuinc) &&
1087 if (!Args.hasArg(options::OPT_nobuiltininc)) {
1094 CmdArgs.push_back(Args.MakeArgString(P));
1108 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1109 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1112 CmdArgs.push_back(Args.MakeArgString("-building-pch-with-obj"));
1115 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1117 CmdArgs.push_back(Args.MakeArgString("-fpch-instantiate-templates"));
1123 CmdArgs.push_back(Args.MakeArgString(D.GetClPchPath(
1130 CmdArgs.push_back(Args.MakeArgString(
1134 Args.MakeArgString(Twine("-pch-through-header=") + ThroughHeader));
1140 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1166 CmdArgs.push_back(Args.MakeArgString(P));
1171 << A->getAsString(Args);
1191 A->render(Args, CmdArgs);
1194 Args.addAllArgs(CmdArgs,
1205 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1209 if (Arg *A = Args.getLastArg(options::OPT_I_))
1210 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1216 if (!Args.hasArg(options::OPT_isysroot)) {
1227 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
1229 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
1231 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
1233 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
1235 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
1243 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1246 [&Args, &CmdArgs, HasStdlibxxIsystem](const ToolChain &TC) {
1247 HasStdlibxxIsystem ? TC.AddClangCXXStdlibIsystemArgs(Args, CmdArgs)
1248 : TC.AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
1256 if (!Args.hasArg(options::OPT_nostdinc) &&
1257 !Args.hasArg(options::OPT_nogpuinc) &&
1258 !Args.hasArg(options::OPT_nobuiltininc)) {
1269 CmdArgs.push_back(Args.MakeArgString(P));
1277 CmdArgs.push_back(Args.MakeArgString(P));
1284 [&Args, &CmdArgs](const ToolChain &TC) {
1285 TC.AddClangSystemIncludeArgs(Args, CmdArgs);
1289 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1292 addMacroPrefixMapArg(D, Args, CmdArgs);
1293 addCoveragePrefixMapArg(D, Args, CmdArgs);
1295 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1300 CmdArgs.push_back(Args.MakeArgString(Epoch));
1303 Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,
1342 const ArgList &Args) {
1349 return Args.getAllArgValues(options::OPT_arch).size() > 1;
1352 static bool checkRemarksOptions(const Driver &D, const ArgList &Args,
1357 bool hasMultipleInvocations = ::hasMultipleInvocations(Triple, Args);
1359 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1368 static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,
1373 if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1378 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1384 Args.getAllArgValues(options::OPT_arch).size() > 1;
1388 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1389 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1436 CmdArgs.push_back(Args.MakeArgString(F));
1440 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1451 void AddAAPCSVolatileBitfieldArgs(const ArgList &Args, ArgStringList &CmdArgs) {
1452 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1456 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1462 const ArgList &Args, ArgStringList &CmdArgs) {
1467 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1470 std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ false);
1528 static void CollectARMPACBTIOptions(const ToolChain &TC, const ArgList &Args,
1531 ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1533 : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1580 << "b-key" << A->getAsString(Args);
1589 Args.MakeArgString(Twine("-msign-return-address=") + Scope));
1593 << A->getAsString(Args) << Triple.getTriple();
1595 Args.MakeArgString(Twine("-msign-return-address-key=") + Key));
1600 << A->getAsString(Args) << Triple.getTriple();
1602 Args.MakeArgString(Twine("-mbranch-protection-pauth-lr")));
1611 << A->getAsString(Args) << Triple.getTriple();
1616 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
1618 RenderARMABI(getToolChain().getDriver(), Triple, Args, CmdArgs);
1621 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
1640 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1649 if (!Args.hasFlag(options::OPT_mimplicit_float,
1653 if (Args.getLastArg(options::OPT_mcmse))
1656 AddAAPCSVolatileBitfieldArgs(Args, CmdArgs);
1659 CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, false /*isAArch64*/);
1665 const ArgList &Args, bool KernelOrKext,
1670 getTargetFeatures(TC.getDriver(), EffectiveTriple, Args, CmdArgs, false);
1682 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1688 AddAArch64TargetArgs(Args, CmdArgs);
1693 AddLoongArchTargetArgs(Args, CmdArgs);
1700 AddMIPSTargetArgs(Args, CmdArgs);
1707 AddPPCTargetArgs(Args, CmdArgs);
1712 AddRISCVTargetArgs(Args, CmdArgs);
1718 AddSparcTargetArgs(Args, CmdArgs);
1722 AddSystemZTargetArgs(Args, CmdArgs);
1727 AddX86TargetArgs(Args, CmdArgs);
1731 AddLanaiTargetArgs(Args, CmdArgs);
1735 AddHexagonTargetArgs(Args, CmdArgs);
1740 AddWebAssemblyTargetArgs(Args, CmdArgs);
1744 AddVETargetArgs(Args, CmdArgs);
1750 void RenderAArch64ABI(const llvm::Triple &Triple, const ArgList &Args,
1753 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1767 void Clang::AddAArch64TargetArgs(const ArgList &Args,
1771 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
1772 Args.hasArg(options::OPT_mkernel) ||
1773 Args.hasArg(options::OPT_fapple_kext))
1776 if (!Args.hasFlag(options::OPT_mimplicit_float,
1780 RenderAArch64ABI(Triple, Args, CmdArgs);
1783 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1793 CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, true /*isAArch64*/);
1796 handlePAuthABI(Args, CmdArgs);
1799 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1810 Args.MakeArgString("-mvscale-max=" + llvm::Twine(Bits / 128)));
1816 Args.MakeArgString("-mvscale-min=" + llvm::Twine(Bits / 128)));
1824 AddAAPCSVolatileBitfieldArgs(Args, CmdArgs);
1826 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1829 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1836 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
1838 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_calls,
1840 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_returns,
1842 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_auth_traps,
1844 Args.addOptInFlag(
1847 Args.addOptInFlag(
1850 Args.addOptInFlag(
1853 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_init_fini,
1855 Args.addOptInFlag(
1859 Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_indirect_gotos,
1863 void Clang::AddLoongArchTargetArgs(const ArgList &Args,
1869 loongarch::getLoongArchABI(getToolChain().getDriver(), Args, Triple)
1873 if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1877 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1881 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1887 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1892 mips::FloatABI ABI = mips::getMipsFloatABI(D, Args, Triple);
1905 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1913 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1921 if (Args.getLastArg(options::OPT_mfix4300)) {
1926 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1929 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1933 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1935 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1954 ParsePICArgs(getToolChain(), Args);
1965 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1967 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1969 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
2007 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
2012 CmdArgs.push_back(Args.MakeArgString("-mips-compact-branches=" + Val));
2020 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
2029 void Clang::AddPPCTargetArgs(const ArgList &Args,
2033 if (Args.getLastArg(options::OPT_mtune_EQ)) {
2035 std::string CPU = ppc::getPPCTuneCPU(Args, T);
2036 CmdArgs.push_back(Args.MakeArgString(CPU));
2060 for (const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2095 ppc::FloatABI FloatABI = ppc::getPPCFloatABI(D, Args);
2114 static void SetRISCVSmallDataLimit(const ToolChain &TC, const ArgList &Args,
2121 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2125 if (Args.hasArg(options::OPT_G)) {
2128 } else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
2133 if (Args.hasArg(options::OPT_G)) {
2139 if (Args.hasArg(options::OPT_G)) {
2142 } else if (Arg *A = Args.getLastArg(options::OPT_G)) {
2150 void Clang::AddRISCVTargetArgs(const ArgList &Args,
2153 StringRef ABIName = riscv::getRISCVABI(Args, Triple);
2158 SetRISCVSmallDataLimit(getToolChain(), Args, CmdArgs);
2160 if (!Args.hasFlag(options::OPT_mimplicit_float,
2164 if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2167 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2173 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2179 std::string Arch = riscv::getRISCVArch(Args, Triple);
2203 Args.MakeArgString("-mvscale-max=" + llvm::Twine(VScaleMin)));
2205 Args.MakeArgString("-mvscale-min=" + llvm::Twine(VScaleMin)));
2214 void Clang::AddSparcTargetArgs(const ArgList &Args,
2217 sparc::getSparcFloatABI(getToolChain().getDriver(), Args);
2231 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2240 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2244 void Clang::AddSystemZTargetArgs(const ArgList &Args,
2246 if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2249 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2255 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false);
2256 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2259 systemz::getSystemZFloatABI(getToolChain().getDriver(), Args);
2278 void Clang::AddX86TargetArgs(const ArgList &Args,
2281 addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/false);
2283 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
2284 Args.hasArg(options::OPT_mkernel) ||
2285 Args.hasArg(options::OPT_fapple_kext))
2288 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2294 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2295 Args.hasArg(options::OPT_fapple_kext));
2296 if (Arg *A = Args.getLastArg(
2306 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2310 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
2311 CmdArgs.push_back(Args.MakeArgString("-inline-asm=" + Value));
2321 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2324 CmdArgs.push_back(Args.MakeArgString("-mskip-rax-setup"));
2327 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) {
2337 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2342 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2355 CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2359 void Clang::AddHexagonTargetArgs(const ArgList &Args,
2364 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
2367 Args.MakeArgString("-hexagon-small-data-threshold=" + Twine(*G)));
2370 if (!Args.hasArg(options::OPT_fno_short_enums))
2372 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2380 void Clang::AddLanaiTargetArgs(const ArgList &Args,
2382 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2386 CmdArgs.push_back(Args.MakeArgString(CPUName));
2388 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2403 void Clang::AddWebAssemblyTargetArgs(const ArgList &Args,
2406 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2411 void Clang::AddVETargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
2419 const InputInfo &Input, const ArgList &Args) const {
2452 if (!D.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2460 for (auto &A: Args) {
2478 A->render(Args, ASL);
2489 const InputInfo &Input, const llvm::opt::ArgList &Args) const {
2495 DumpCompilationDatabase(C, "", Target, Output, Input, Args);
2519 DumpCompilationDatabase(C, "", Target, Output, Input, Args);
2527 static void AddARMImplicitITArgs(const ArgList &Args, ArgStringList &CmdArgs,
2530 CmdArgs.push_back(Args.MakeArgString("-arm-implicit-it=" + Value));
2534 const ArgList &Args,
2545 Args.addOptInFlag(CmdArgs, options::OPT_mrelax_all,
2552 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2557 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2559 Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2579 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2728 RenderDebugEnablingArgs(Args, CmdArgs,
2774 AddARMImplicitITArgs(Args, CmdArgs, ImplicitIt);
2797 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2801 CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2846 bool OFastEnabled, const ArgList &Args,
2873 TC.getDefaultDenormalModeForType(Args, JA);
2875 TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEsingle());
2922 if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2927 for (const Arg *A : Args) {
3029 << Args.MakeArgString("-ffp-model=" + Val) << "-Ofast";
3035 << Args.MakeArgString("-ffp-model=" + FPModel)
3036 << Args.MakeArgString("-ffp-model=" + Val);
3076 << Args.MakeArgString("-ffp-exception-behavior=" +
3088 << Args.MakeArgString("-ffp-exception-behavior=" +
3109 << A->getAsString(Args) << A->getValue();
3117 << A->getAsString(Args) << A->getValue();
3141 << Args.MakeArgString("-ffp-exception-behavior=" +
3143 << Args.MakeArgString("-ffp-exception-behavior=" + Val);
3272 : Args.MakeArgString(A->getSpelling() + A->getValue());
3318 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3326 CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3330 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
3333 CmdArgs.push_back(Args.MakeArgString("-frounding-math"));
3335 CmdArgs.push_back(Args.MakeArgString("-fno-rounding-math"));
3338 CmdArgs.push_back(Args.MakeArgString("-ffp-exception-behavior=" +
3342 CmdArgs.push_back(Args.MakeArgString("-ffp-eval-method=" + FPEvalMethod));
3345 CmdArgs.push_back(Args.MakeArgString("-ffloat16-excess-precision=" +
3348 CmdArgs.push_back(Args.MakeArgString("-fbfloat16-excess-precision=" +
3351 ParseMRecip(D, Args, CmdArgs);
3365 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3369 << Args.MakeArgString("-ffp-contract=" + FPContract);
3377 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3383 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3390 CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
3391 if (Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))
3392 CmdArgs.push_back(Args.MakeArgString("-fcomplex-arithmetic=" +
3395 if (Args.hasArg(options::OPT_fcx_limited_range))
3397 if (Args.hasArg(options::OPT_fcx_fortran_rules))
3399 if (Args.hasArg(options::OPT_fno_cx_limited_range))
3401 if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
3405 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs,
3409 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3460 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3471 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3485 const ArgList &Args, ArgStringList &CmdArgs,
3499 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3522 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3526 for (const Arg *A : Args.filtered(options::OPT__param)) {
3532 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3539 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3544 << A->getAsString(Args) << TripleStr;
3554 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3556 << A->getAsString(Args);
3566 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3570 << A->getAsString(Args) << "-mstack-protector-guard=tls";
3582 A->render(Args, CmdArgs);
3585 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3590 << A->getAsString(Args) << TripleStr;
3602 A->render(Args, CmdArgs);
3605 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3609 << A->getAsString(Args) << TripleStr;
3619 A->render(Args, CmdArgs);
3622 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3629 A->render(Args, CmdArgs);
3633 static void RenderSCPOptions(const ToolChain &TC, const ArgList &Args,
3644 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3650 const ArgList &Args,
3655 for (const Arg *A : Args) {
3686 Args.MakeArgString("-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3690 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3691 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3693 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3701 Args.MakeArgString("-ftrivial-auto-var-init-stop-after=" + Val));
3704 if (Arg *A = Args.getLastArg(options::OPT_ftrivial_auto_var_init_max_size)) {
3705 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3707 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3715 Args.MakeArgString("-ftrivial-auto-var-init-max-size=" + Val));
3719 static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs,
3737 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3739 CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3740 } else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3742 CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3746 if (const auto *A = Args.getLastArg(Arg))
3747 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3751 (Args.hasArg(options::OPT_cl_std_EQ) && types::isSrcFile(InputType))) &&
3752 !Args.hasArg(options::OPT_cl_no_stdinc)) {
3758 static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs,
3772 if (const auto *A = Args.getLastArg(Arg))
3773 A->renderAsInput(Args, CmdArgs);
3775 if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3776 !Args.hasArg(options::OPT_nostdinc))
3780 static void RenderOpenACCOptions(const Driver &D, const ArgList &Args,
3782 if (!Args.hasArg(options::OPT_fopenacc))
3787 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override)) {
3791 A->renderAsInput(Args, CmdArgs);
3797 static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args,
3800 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3801 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3818 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3819 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3824 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3825 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3826 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3829 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3832 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3837 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3845 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3846 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3847 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3850 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3851 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3852 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3853 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3854 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3855 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3856 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3857 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3858 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3859 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3860 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3861 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3862 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3863 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3864 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3865 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
3870 const ArgList &Args, ArgStringList &CmdArgs) {
3873 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3874 !Args.hasArg(options::OPT_mkernel));
3879 if (Args.hasArg(options::OPT_ffreestanding))
3883 for (const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
3889 A->render(Args, CmdArgs);
3914 clang::driver::tools::getCXX20NamedModuleOutputPath(const ArgList &Args,
3916 if (Arg *ModuleOutputEQ = Args.getLastArg(options::OPT_fmodule_output_EQ))
3920 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o);
3921 FinalOutput && Args.hasArg(options::OPT_c))
3932 const ArgList &Args, const InputInfo &Input,
3943 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3944 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3956 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3961 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
3966 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3972 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3981 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4001 CmdArgs.push_back(Args.MakeArgString(Path));
4006 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
4009 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
4017 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
4021 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
4025 if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
4031 Args.MakeArgString("-fmodule-map-file=" + BuiltinModuleMap));
4039 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4042 for (const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
4043 CmdArgs.push_back(Args.MakeArgString(
4048 Args.ClaimAllArgs(options::OPT_fmodule_file);
4056 C.addTempFile(Args.MakeArgString(VFSDir));
4060 CmdArgs.push_back(Args.MakeArgString(VFSDir));
4064 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
4067 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
4068 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4069 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
4072 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4074 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4075 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4077 << A->getAsString(Args) << "-fbuild-session-timestamp";
4082 CmdArgs.push_back(Args.MakeArgString(
4089 if (Args.getLastArg(
4091 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4095 Args.AddLastArg(CmdArgs,
4099 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
4104 Args.AddLastArg(CmdArgs,
4107 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
4108 Args.ClaimAllArgs(options::OPT_fbuild_session_file);
4109 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
4110 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
4111 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
4112 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
4119 if (Args.hasArg(options::OPT_modules_reduced_bmi) &&
4124 if (Args.hasArg(options::OPT_fmodule_output_EQ))
4125 Args.AddLastArg(CmdArgs, options::OPT_fmodule_output_EQ);
4127 CmdArgs.push_back(Args.MakeArgString(
4129 getCXX20NamedModuleOutputPath(Args, Input.getBaseInput())));
4135 Args.ClaimAllArgs(options::OPT_modules_reduced_bmi);
4146 Args.ClaimAllArgs(options::OPT_fmodule_output);
4147 Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
4153 static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T,
4156 if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
4169 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
4171 if (const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4190 const llvm::Triple &T, const ArgList &Args,
4199 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4217 if (isObjCAutoRefCount(Args)) {
4226 if (TC.GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4234 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4242 if (Args.hasArg(options::OPT_fno_objc_arc)) {
4243 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4244 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4250 auto *Arg = Args.getLastArg(
4267 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4274 WeakArg->render(Args, CmdArgs);
4278 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4282 static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args,
4287 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4307 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4311 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4313 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4317 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4322 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4326 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4329 CmdArgs.push_back(Args.MakeArgString(Opt));
4333 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4336 CmdArgs.push_back(Args.MakeArgString(Opt));
4339 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4347 if (const Arg *A = Args.getLastArg(
4361 Args.getLastArg(options::OPT_fcolor_diagnostics,
4363 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
4373 if (Args.hasArg(options::OPT_fansi_escape_codes))
4376 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4379 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4382 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4385 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4389 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4394 const ArgList &Args, Arg *&Arg) {
4395 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4415 const ArgList &Args, ArgStringList &CmdArgs,
4418 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4425 << DwarfFormatArg->getAsString(Args) << "DWARFv3 or greater";
4428 << DwarfFormatArg->getAsString(Args) << "64 bit architecture";
4431 << DwarfFormatArg->getAsString(Args) << "ELF platforms";
4434 DwarfFormatArg->render(Args, CmdArgs);
4439 const ArgList &Args, bool IRInput, ArgStringList &CmdArgs,
4443 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4446 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4461 Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4467 if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4469 DwarfFission = getDebugFissionKind(D, Args, SplitDWARFArg);
4471 !checkDebugInfoOption(SplitDWARFArg, Args, D, TC)) {
4476 if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4480 if (checkDebugInfoOption(A, Args, D, TC) &&
4498 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4500 if (checkDebugInfoOption(A, Args, D, TC)) {
4514 if (const Arg *A = getDwarfNArg(Args))
4515 EmitDwarf = checkDebugInfoOption(A, Args, D, TC);
4518 if (const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4519 EmitCodeView = checkDebugInfoOption(A, Args, D, TC);
4539 RequestedDWARFVersion = getDwarfVersion(TC, Args);
4544 Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4554 if (const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4555 (void)checkDebugInfoOption(A, Args, D, TC);
4556 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4561 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4569 if (const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4570 (void)checkDebugInfoOption(A, Args, D, TC);
4571 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4578 if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules, false)) {
4581 if (checkDebugInfoOption(Args.getLastArg(options::OPT_gmodules), Args, D,
4600 bool NeedFullDebug = Args.hasFlag(
4604 if (const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4605 (void)checkDebugInfoOption(A, Args, D, TC);
4609 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4616 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4622 const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4625 << A->getAsString(Args) << "-gdwarf-5";
4630 << A->getAsString(Args) << TC.getTripleString() << 5
4632 else if (checkDebugInfoOption(A, Args, D, TC))
4639 Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4642 Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4646 Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4650 if (willEmitRemarks(Args) &&
4655 TC.adjustDebugInfoKind(DebugInfoKind, Args);
4659 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, EffectiveDWARFVersion,
4665 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4667 if (checkDebugInfoOption(Args.getLastArg(options::OPT_fdebug_macro), Args,
4673 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4676 (PubnamesArg && checkDebugInfoOption(PubnamesArg, Args, D, TC))) {
4691 Args.getLastArg(options::OPT_gsimple_template_names,
4695 checkDebugInfoOption(SimpleTemplateNamesArg, Args, D, TC)) {
4706 if (const auto *DebugTemplateAlias = Args.getLastArg(
4710 if (checkDebugInfoOption(DebugTemplateAlias, Args, D, TC)) {
4718 if (const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4720 CmdArgs.push_back(Args.MakeArgString("-gsrc-hash=" + v));
4723 Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4730 if (const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
4731 NeedAranges = checkDebugInfoOption(A, Args, D, TC) || NeedAranges;
4737 Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4741 if (Args.hasFlag(options::OPT_fdebug_types_section,
4745 << Args.getLastArg(options::OPT_fdebug_types_section)
4746 ->getAsString(Args)
4749 Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4758 Args.getLastArg(options::OPT_gomit_unreferenced_methods,
4760 (void)checkDebugInfoOption(A, Args, D, TC);
4761 if (Args.hasFlag(options::OPT_gomit_unreferenced_methods,
4772 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4787 renderDwarfFormat(D, T, Args, CmdArgs, EffectiveDWARFVersion);
4788 RenderDebugInfoCompressionArgs(Args, CmdArgs, D, TC);
4791 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {
4808 addDebugCompDirArg(Args, CmdArgs, D.getVFS());
4810 addDebugPrefixMapArg(D, TC, Args, CmdArgs);
4814 addDebugObjectName(Args, CmdArgs, DebugCompilationDir,
4818 static void ProcessVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args,
4822 if (Args.hasArg(options::OPT__SLASH_LDd))
4827 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4830 if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4842 if (Args.hasArg(options::OPT__SLASH_LDd))
4855 if (Args.hasArg(options::OPT__SLASH_LDd))
4871 if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
4891 const ArgList &Args, const char *LinkingOutput) const {
4898 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4920 Args.hasFlag(options::OPT_offload_new_driver,
4924 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc, false);
4984 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4986 if (const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4987 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
4988 Args.ClaimAllArgs(options::OPT_MJ);
4990 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4992 TripleStr, Output, Input, Args);
4993 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
5019 CmdArgs.push_back(Args.MakeArgString(
5032 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5039 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
5040 CmdArgs.push_back(Args.MakeArgString(
5042 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
5045 Args.MakeArgString("-Werror=format-invalid-specifier"));
5051 if (const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
5054 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl, false)) {
5057 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
5058 A->render(Args, CmdArgs);
5072 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5100 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5117 Args.ClaimAllArgs(options::OPT_mrelax_all);
5118 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5119 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5120 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5126 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5132 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5133 Args.ClaimAllArgs(options::OPT_Xassembler);
5134 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5147 if (Args.hasArg(options::OPT_rewrite_objc) &&
5148 !Args.hasArg(options::OPT_g_Group))
5156 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
5159 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5176 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5177 PrettySGFArg->render(Args, CmdArgs);
5179 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5181 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5182 ProductNameArg->render(Args, CmdArgs);
5184 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5185 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5187 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5191 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5194 SymbolGraphDirArg->render(Args, CmdArgs);
5206 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5207 Args.hasArg(options::OPT_emit_llvm)) {
5215 Args.hasArg(options::OPT_interface_stub_version_EQ)
5216 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5220 Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str()));
5246 !Args.hasFlag(options::OPT_offload_new_driver,
5250 << Args.getLastArg(options::OPT_foffload_lto,
5252 ->getAsString(Args)
5257 << Args.getLastArg(options::OPT_foffload_lto,
5259 ->getAsString(Args)
5263 CmdArgs.push_back(Args.MakeArgString(
5274 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5276 if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5278 D.Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5279 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5283 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5286 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5287 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5289 if (Args.getLastArg(options::OPT_save_temps_EQ))
5290 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5292 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5297 MemProfArg->render(Args, CmdArgs);
5300 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5303 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5304 if (auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5307 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5308 MemProfUseArg->render(Args, CmdArgs);
5316 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5321 TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind());
5368 for (const auto &A : Args)
5373 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5376 RenderFloatingPointOptions(TC, D, isOptimizationLevelFast(Args), Args,
5385 RenderARMABI(D, Triple, Args, CmdArgs);
5390 RenderAArch64ABI(Triple, Args, CmdArgs);
5395 if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5400 A->render(Args, CmdArgs);
5415 addDashXForInput(Args, II, CmdArgs);
5419 II.getInputArg().renderAsInput(Args, CmdArgs);
5445 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5451 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5453 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5465 CmdArgs.push_back(getBaseInputName(Args, Input));
5469 if (Args.hasArg(options::OPT_static))
5472 if (Args.hasArg(options::OPT_municode))
5476 RenderAnalyzerOptions(Args, CmdArgs, Triple, Input);
5479 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5486 for (auto *Arg : Args.filtered(options::OPT_Xclang))
5492 for (auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5500 CheckCodeGenerationOptions(D, Args);
5502 unsigned FunctionAlignment = ParseFunctionAlignment(TC, Args);
5506 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5511 if (const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5515 << A->getAsString(Args) << A->getValue();
5518 << A->getAsString(Args) << A->getValue();
5521 CmdArgs.push_back(Args.MakeArgString("-falign-loops=" +
5535 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5557 std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(TC, Args);
5559 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5583 if (Args.hasArg(options::OPT_mcmse) &&
5584 !Args.hasArg(options::OPT_fallow_unsupported)) {
5592 !Args.hasArg(options::OPT_fallow_unsupported))
5616 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5633 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5642 A->render(Args, CmdArgs);
5650 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5653 << A->getValue() << A->getAsString(Args);
5659 CmdArgs.push_back(Args.MakeArgString(Model));
5663 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5681 A->render(Args, CmdArgs);
5684 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5688 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5693 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5700 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5708 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5715 CmdArgs.push_back(Args.MakeArgString("-fwarn-stack-size=" + V));
5718 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5720 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5722 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5725 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5730 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5743 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5756 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) {
5763 if (Args.hasArg(options::OPT_fenable_matrix)) {
5771 getFramePointerKind(Args, RawTriple);
5790 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5793 bool OFastEnabled = isOptimizationLevelFast(Args);
5802 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5805 if (Args.hasFlag(options::OPT_fpointer_tbaa, options::OPT_fno_pointer_tbaa,
5808 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5811 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5813 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5815 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5817 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5819 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5821 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5823 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5826 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5829 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5832 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5835 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
5839 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5843 if (Args.hasFlag(options::OPT_fprotect_parens,
5847 RenderFloatingPointOptions(TC, D, OFastEnabled, Args, CmdArgs, JA);
5849 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5863 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5865 A->render(Args, CmdArgs);
5868 << A->getAsString(Args) << TripleStr;
5871 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5873 A->render(Args, CmdArgs);
5876 A->render(Args, CmdArgs);
5879 << A->getAsString(Args) << TripleStr;
5885 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5891 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5895 A->render(Args, CmdArgs);
5899 A->render(Args, CmdArgs);
5910 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5914 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5930 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5936 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5940 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5947 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5951 A->render(Args, CmdArgs);
5958 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt, false)) {
5966 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
5971 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5976 auto SanitizeArgs = TC.getSanitizerArgs(Args);
5979 TC.getDefaultUnwindTableLevel(Args) == ToolChain::UnwindTableLevel::Asynchronous;
5981 TC.getDefaultUnwindTableLevel(Args) == ToolChain::UnwindTableLevel::Synchronous;
5983 bool AsyncUnwindTables = Args.hasFlag(
5989 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5998 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
6006 CmdArgs.push_back(Args.MakeArgString(HostCPU));
6012 TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind());
6014 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
6016 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
6026 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6029 if (isTLSDESCEnabled(TC, Args))
6033 std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ false);
6036 CmdArgs.push_back(Args.MakeArgString(CPU));
6039 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6044 AddClangCLArgs(Args, InputType, CmdArgs);
6049 renderDebugOptions(TC, D, RawTriple, Args, types::isLLVMIR(InputType),
6061 const char *SplitDWARFOut = SplitDebugName(JA, Args, Input, Output);
6071 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6078 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6082 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6083 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6088 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6092 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6097 Args.AddAllArgs(CmdArgs, options::OPT_v);
6099 if (Args.getLastArg(options::OPT_H)) {
6103 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6111 CmdArgs.push_back(Args.MakeArgString(
6115 Args.MakeArgString("-header-include-filtering=" +
6119 Args.AddLastArg(CmdArgs, options::OPT_P);
6120 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6136 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6137 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6139 CmdArgs.push_back(Args.MakeArgString("-crash-diagnostics-dir=" + Dir));
6144 if (Args.hasFlag(options::OPT_ffunction_sections,
6149 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6153 A->render(Args, CmdArgs);
6156 << A->getAsString(Args) << TripleStr;
6160 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6166 << A->getAsString(Args) << A->getValue();
6168 A->render(Args, CmdArgs);
6174 << A->getAsString(Args) << A->getValue();
6176 A->render(Args, CmdArgs);
6184 << A->getAsString(Args) << TripleStr;
6189 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6194 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6196 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6198 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6200 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6202 Args.addOptInFlag(CmdArgs, options::OPT_fconvergent_functions,
6205 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6210 A->render(Args, CmdArgs);
6213 << A->getAsString(Args) << TripleStr;
6217 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6225 addPGOAndCoverageFlags(TC, C, JA, Output, Args, SanitizeArgs, CmdArgs);
6227 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6229 if (getLastProfileSampleUseArg(Args) &&
6230 Args.hasArg(options::OPT_fsample_profile_use_profi)) {
6237 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6238 PScpu::addProfileRTArgs(TC, Args, CmdArgs);
6239 PScpu::addSanitizerArgs(TC, Args, CmdArgs);
6243 if (Args.hasArg(options::OPT_nostdinc)) {
6247 if (Args.hasArg(options::OPT_nostdlibinc))
6249 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6250 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6257 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6259 RenderARCMigrateToolOptions(D, Args, CmdArgs);
6266 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
6272 Args.ClaimAllArgs(options::OPT_D);
6275 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
6280 A->render(Args, CmdArgs);
6286 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6287 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6292 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6293 D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6297 claimNoWarnArgs(Args);
6299 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6302 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6308 << A->getAsString(Args) << A->getValue();
6313 CmdArgs.push_back(Args.MakeArgString(
6318 A->render(Args, CmdArgs);
6321 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6323 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
6325 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6326 Args.AddLastArg(CmdArgs, options::OPT_w);
6328 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6331 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6332 A->render(Args, CmdArgs);
6334 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6337 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6340 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6341 A->render(Args, CmdArgs);
6350 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6358 Std->render(Args, CmdArgs);
6361 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6365 A->render(Args, CmdArgs);
6374 if (!Args.hasArg(options::OPT__SLASH_std)) {
6375 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
6383 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6400 Args.getLastArg(options::OPT_Wwrite_strings,
6411 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6417 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6424 if (!ShouldEnableAutolink(Args, TC, JA))
6427 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6428 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6429 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6430 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6432 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6434 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6437 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6442 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6446 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
6451 if (Args.hasArg(options::OPT_relocatable_pch))
6454 if (const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6462 A->render(Args, CmdArgs);
6465 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6470 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6475 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6478 if (Args.hasArg(options::OPT_fstack_usage)) {
6481 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6484 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6487 Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".su"));
6491 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6496 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6497 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6498 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6499 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6500 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6504 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6516 Args.MakeArgString("-fmessage-length=" + Twine(MessageLength)));
6518 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6520 Args.MakeArgString("-frandomize-layout-seed=" + Twine(A->getValue(0))));
6522 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6523 CmdArgs.push_back(Args.MakeArgString("-frandomize-layout-seed-file=" +
6527 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6530 A->render(Args, CmdArgs);
6546 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6551 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6552 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6553 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6554 Args.AddLastArg(CmdArgs,
6560 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6564 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6570 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6572 << A->getAsString(Args) << /*hasReplacement=*/true
6577 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6580 A->render(Args, CmdArgs);
6588 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6590 if (Args.hasFlag(options::OPT_fnew_infallible,
6594 if (Args.hasFlag(options::OPT_fno_operator_names,
6599 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6600 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6601 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6602 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6603 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
6606 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6610 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6613 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6619 << A->getAsString(Args) << TripleStr;
6624 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6626 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6627 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6631 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6635 switch (D.getOpenMPRuntime(Args)) {
6644 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6647 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6649 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6650 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6651 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6654 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6655 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6656 Args.AddAllArgs(CmdArgs,
6658 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6665 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6670 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6671 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6677 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6681 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6685 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6687 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6689 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6691 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6704 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6706 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6707 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6712 if (Args.hasFlag(options::OPT_offload_new_driver,
6716 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
6719 XRay.addArgs(TC, Args, CmdArgs, InputType);
6722 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6724 CmdArgs.push_back(Args.MakeArgString("-fprofile-list=" + Filename));
6729 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6737 << A->getAsString(Args) << TripleStr;
6746 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6747 CmdArgs.push_back(Args.MakeArgString(
6752 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6755 Args.AddLastArg(CmdArgs, options::OPT_pg);
6758 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6760 A->render(Args, CmdArgs);
6763 << A->getAsString(Args) << TripleStr;
6765 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6767 A->render(Args, CmdArgs);
6770 << A->getAsString(Args) << TripleStr;
6772 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6774 A->render(Args, CmdArgs);
6777 << A->getAsString(Args) << TripleStr;
6781 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6784 << A->getAsString(Args) << TripleStr;
6787 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6790 << A->getAsString(Args) << TripleStr;
6793 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6796 if (TC.getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6803 for (const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6810 if (Args.getLastArg(options::OPT_fapple_kext) ||
6811 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
6814 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6815 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6816 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6817 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6818 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6819 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6820 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6821 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6822 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6823 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6826 CmdArgs.push_back(Args.MakeArgString("-ftime-trace=" + Twine(Name)));
6827 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6828 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
6831 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6836 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6840 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
6843 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
6849 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6852 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6853 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6856 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6858 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6860 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6863 RenderSSPOptions(D, TC, Args, CmdArgs, KernelOrKext);
6864 RenderSCPOptions(TC, Args, CmdArgs);
6865 RenderTrivialAutoVarInitOptions(D, TC, Args, CmdArgs);
6867 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6869 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6872 if (Args.hasArg(options::OPT_mstack_alignment)) {
6873 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
6874 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
6877 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6878 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6881 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
6886 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6889 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6901 RenderOpenCLOptions(Args, CmdArgs, InputType);
6904 RenderHLSLOptions(Args, CmdArgs, InputType);
6907 RenderOpenACCOptions(D, Args, CmdArgs, InputType);
6910 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6913 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6915 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6916 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6917 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6924 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6926 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6935 if (Args.hasArg(options::OPT_nogpulib))
6938 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6940 Args.MakeArgString(Twine("-fcf-protection=") + A->getValue()));
6943 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6945 Args.MakeArgString(Twine("-mfunction-return=") + A->getValue()));
6947 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6953 if (Arg *A = getLastProfileSampleUseArg(Args)) {
6954 auto *PGOArg = Args.getLastArg(
6967 A->render(Args, CmdArgs);
6969 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6971 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6976 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6981 RenderBuiltinOptions(TC, RawTriple, Args, CmdArgs);
6983 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6986 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes, false))
6988 if (Args.hasFlag(options::OPT_fapinotes_modules,
6991 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
6994 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
6996 (Args.hasArg(options::OPT_fgnu_runtime) &&
6997 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
6998 !Args.hasArg(options::OPT_fno_blocks))) {
7001 if (!Args.hasArg(options::OPT_fgnu_runtime) && !TC.hasBlocksRuntime())
7009 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7014 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7017 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7019 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7029 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7033 RenderCharacterOptions(Args, AuxTriple ? *AuxTriple : RawTriple, CmdArgs);
7036 if (!Args.hasFlag(
7044 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7049 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7053 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7063 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7073 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7078 bool IsMSVCCompat = Args.hasFlag(
7080 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7085 Args.hasArg(options::OPT_fms_define_stdc))
7090 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7091 ProcessVSRuntimeLibrary(getToolChain(), Args, CmdArgs);
7095 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7105 << A->getAsString(Args) << A->getValue();
7113 Args.MakeArgString("-fgnuc-version=" + GNUCVer.getAsString()));
7116 VersionTuple MSVT = TC.computeMSVCVersion(&D, Args);
7119 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
7124 if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7132 << StdArg->getAsString(Args);
7138 if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7149 << StdArg->getAsString(Args);
7162 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7166 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7169 else if (Args.hasArg(options::OPT_fno_declspec))
7174 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7181 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7187 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7190 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7193 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7196 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7198 A->render(Args, CmdArgs);
7200 InlineArg->render(Args, CmdArgs);
7203 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7216 RenderModulesOptions(C, D, Args, Input, Output, HaveCxx20, CmdArgs);
7229 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7238 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7241 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7244 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7247 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7251 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7252 RenderObjCOptions(TC, D, RawTriple, Args, Runtime, rewriteKind != RK_None,
7256 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7261 if (Args.hasFlag(options::OPT_fapplication_extension,
7268 EH = addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7271 Arg *A = Args.getLastArg(
7285 switch (TC.GetExceptionModel(Args)) {
7301 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7305 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7310 Args.getLastArg(options::OPT_frelaxed_template_template_args,
7318 << A->getAsString(Args) << /*hasReplacement=*/false;
7324 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
7329 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7340 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7343 Args.MakeArgString(Twine("-fnew-alignment=") + A->getValue()));
7347 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7349 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7353 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7358 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7361 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7362 } else if (Args.hasFlag(options::OPT_fpack_struct,
7368 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7369 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7373 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7378 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7382 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true))
7386 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7390 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7393 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7396 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope, true))
7398 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7401 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7404 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7409 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7412 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7416 RenderDiagnosticsOptions(D, Args, CmdArgs);
7418 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7421 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7427 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
7430 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
7435 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
7438 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
7442 ParseMPreferVectorWidth(D, Args, CmdArgs);
7444 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7445 Args.AddLastArg(CmdArgs,
7450 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7458 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7462 if (willEmitRemarks(Args) && checkRemarksOptions(D, Args, Triple))
7463 renderRemarksOptions(Args, CmdArgs, Triple, Input, Output, JA);
7465 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7470 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7477 if (Args.hasFlag(options::OPT_frewrite_includes,
7483 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7488 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7491 Args.AddLastArg(CmdArgs, options::OPT_dM);
7492 Args.AddLastArg(CmdArgs, options::OPT_dD);
7493 Args.AddLastArg(CmdArgs, options::OPT_dI);
7495 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7498 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7500 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7503 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7507 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7509 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7512 for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7526 for (const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7535 D.Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7538 << PluginName << A->getAsString(Args);
7543 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-arg-") + PluginName));
7544 CmdArgs.push_back(Args.MakeArgString(Arg));
7548 for (const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7550 Args.MakeArgString(Twine("-fpass-plugin=") + A->getValue()));
7555 for (const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7561 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7564 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7568 SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D);
7570 CmdArgs.push_back(Args.MakeArgString(Twine("-stats-file=") + StatsFile));
7577 for (auto Arg : Args.filtered(options::OPT_Xclang)) {
7588 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
7597 A->render(Args, CmdArgs);
7615 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7625 Args.hasFlag(options::OPT_grecord_command_line,
7628 Args.hasFlag(options::OPT_frecord_command_line,
7633 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
7637 for (const auto &Arg : Args)
7638 Arg->render(Args, OriginalArgs);
7648 auto FlagsArgString = Args.MakeArgString(Flags);
7672 CmdArgs.push_back(Args.MakeArgString("-fembed-offload-object=" +
7678 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7692 CmdArgs.push_back(Args.MakeArgString(Twine("-cuid=") + Twine(CUID)));
7696 bool UseApproxTranscendentals = Args.hasFlag(
7698 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7703 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7709 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7712 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7715 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7720 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7724 CmdArgs.append({"-mllvm", Args.MakeArgStringRef(ArgStr)});
7729 Args.addOptOutFlag(CmdArgs,
7742 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->getFilename()));
7747 handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs);
7749 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7751 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7764 CmdArgs.push_back(Args.MakeArgString(Targets + llvm::join(Triples, ",")));
7768 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7782 bool WholeProgramVTables = Args.hasFlag(
7817 Args.hasFlag(options::OPT_fsplit_lto_unit,
7825 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7831 << A->getAsString(Args) << TC.getTripleString();
7833 CmdArgs.push_back(Args.MakeArgString(
7837 A->render(Args, CmdArgs);
7841 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7853 Arg *A = Args.getLastArg(options::OPT_O_Group);
7872 if (Args.hasArg(options::OPT_forder_file_instrumentation)) {
7883 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7889 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7891 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7893 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7895 Args.addOptOutFlag(CmdArgs, options::OPT_fcxx_static_destructors,
7898 addMachineOutlinerArgs(D, Args, CmdArgs, Triple, /*IsLTO=*/false);
7900 addOutlineAtomicsArgs(D, getToolChain(), Args, CmdArgs, Triple);
7903 (Args.hasArg(options::OPT_mno_fmv) ||
7905 getToolChain().GetRuntimeLibType(Args) != ToolChain::RLT_CompilerRT)) {
7911 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7925 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7926 std::string Str = A->getAsString(Args);
7930 CmdArgs.push_back(Args.MakeArgString(Str));
7943 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7952 addDashXForInput(Args, Input, CmdArgs);
7964 Input.getInputArg().renderAsInput(Args, CmdArgs);
7980 Args.hasFlag(options::OPT__SLASH_showFilenames,
7985 if (Arg *A = Args.getLastArg(options::OPT_pg))
7987 !Args.hasArg(options::OPT_mfentry))
7989 << A->getAsString(Args);
7995 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
7999 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8000 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8003 Args.ClaimAllArgs(options::OPT_emit_llvm);
8171 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args,
8176 Args.getAllArgValues(options::OPT__SLASH_EH);
8210 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
8216 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8225 void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
8229 ProcessVSRuntimeLibrary(getToolChain(), Args, CmdArgs);
8232 Args.getLastArg(options::OPT__SLASH_showIncludes,
8240 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8246 if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
8249 CmdArgs.push_back(Args.MakeArgString(Twine(LangOptions::SSPStrong)));
8255 EHFlags EH = parseClangCLEHFlags(D, Args, IsWindowsMSVC);
8267 if (Args.hasArg(options::OPT__SLASH_EP)) {
8272 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
8278 if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
8283 if (Args.hasArg(options::OPT__SLASH_kernel)) {
8286 Args.getAllArgValues(options::OPT__SLASH_arch);
8299 if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_, false))
8304 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
8305 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
8308 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
8311 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
8312 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
8313 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
8319 << FirstConflict->getAsString(Args)
8320 << SecondConflict->getAsString(Args);
8330 if (Args.hasArg(options::OPT_regcall4))
8335 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
8369 if (Args.hasArg(options::OPT__SLASH_Gregcall4))
8372 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
8374 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
8379 if (Args.hasArg(options::OPT__SLASH_kernel))
8382 for (const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
8405 const char *Clang::getBaseInputName(const ArgList &Args,
8407 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
8410 const char *Clang::getBaseInputStem(const ArgList &Args,
8412 const char *Str = getBaseInputName(Args, Inputs[0]);
8415 return Args.MakeArgString(std::string(Str, End));
8420 const char *Clang::getDependencyFileName(const ArgList &Args,
8424 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
8427 return Args.MakeArgString(OutputFilename);
8430 return Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".d");
8435 void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
8440 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
8446 void ClangAs::AddX86TargetArgs(const ArgList &Args,
8448 addX86AlignBranchArgs(getToolChain().getDriver(), Args, CmdArgs,
8451 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
8455 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
8463 void ClangAs::AddLoongArchTargetArgs(const ArgList &Args,
8466 CmdArgs.push_back(loongarch::getLoongArchABI(getToolChain().getDriver(), Args,
8471 void ClangAs::AddRISCVTargetArgs(const ArgList &Args,
8474 StringRef ABIName = riscv::getRISCVABI(Args, Triple);
8479 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8488 const ArgList &Args,
8500 Args.ClaimAllArgs(options::OPT_w);
8502 Args.ClaimAllArgs(options::OPT_emit_llvm);
8504 claimNoWarnArgs(Args);
8513 CmdArgs.push_back(Args.MakeArgString(TripleStr));
8515 getToolChain().addClangCC1ASTargetOptions(Args, CmdArgs);
8525 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
8528 std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ true);
8531 CmdArgs.push_back(Args.MakeArgString(CPU));
8535 getTargetFeatures(D, Triple, Args, CmdArgs, true);
8538 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
8541 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
8544 Args.AddAllArgs(CmdArgs, options::OPT_embed_dir_EQ);
8559 Args.ClaimAllArgs(options::OPT_g_Group);
8560 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8566 if (const Arg *A = getDwarfNArg(Args))
8567 EmitDwarf = checkDebugInfoOption(A, Args, D, getToolChain());
8570 if (const Arg *A = Args.getLastArg(options::OPT_gcodeview))
8571 EmitCodeView = checkDebugInfoOption(A, Args, D, getToolChain());
8595 addDebugCompDirArg(Args, CmdArgs, C.getDriver().getVFS());
8606 addDebugPrefixMapArg(getToolChain().getDriver(), getToolChain(), Args,
8612 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
8615 Args.AddAllArgs(CmdArgs, options::OPT_I);
8617 const unsigned DwarfVersion = getDwarfVersion(getToolChain(), Args);
8618 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
8620 renderDwarfFormat(D, Triple, Args, CmdArgs, DwarfVersion);
8621 RenderDebugInfoCompressionArgs(Args, CmdArgs, D, getToolChain());
8629 ParsePICArgs(getToolChain(), Args);
8641 for (const auto &Arg : Args)
8642 Arg->render(Args, OriginalArgs);
8654 CmdArgs.push_back(Args.MakeArgString(Flags));
8668 AddMIPSTargetArgs(Args, CmdArgs);
8673 AddX86TargetArgs(Args, CmdArgs);
8682 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8692 if (Args.hasArg(options::OPT_mmark_bti_property)) {
8700 AddLoongArchTargetArgs(Args, CmdArgs);
8705 AddRISCVTargetArgs(Args, CmdArgs);
8709 if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8722 Args.ClaimAllArgs(options::OPT_W_Group);
8724 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
8727 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
8730 addDebugObjectName(Args, CmdArgs, DebugCompilationDir,
8743 addDebugObjectName(Args, NewArgs, DebugCompilationDir,
8758 if (getDebugFissionKind(D, Args, A) == DwarfFissionKind::Split &&
8761 CmdArgs.push_back(SplitDebugName(JA, Args, Input, Output));
8765 handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs, /*IsCC1As=*/true);
8978 const llvm::opt::ArgList &Args,
9011 Args.MakeArgString(Feature.take_back() + Feature.drop_back()));
9029 CmdArgs.push_back(Args.MakeArgString("--image=" + llvm::join(Parts, ",")));
9034 Args.MakeArgString(getToolChain().GetProgramPath(getShortName())),
9041 const ArgList &Args,
9053 CudaInstallationDetector CudaInstallation(D, TheTriple, Args);
9055 CmdArgs.push_back(Args.MakeArgString(
9063 if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
9077 CmdArgs.push_back(Args.MakeArgString(Twine("--opt-level=O") + OOpt));
9081 Args.MakeArgString("--host-triple=" + TheTriple.getTriple()));
9082 if (Args.hasArg(options::OPT_v))
9085 if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
9092 if (const Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
9093 CmdArgs.push_back(Args.MakeArgString("-mllvm"));
9094 CmdArgs.push_back(Args.MakeArgString(
9098 for (const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
9099 CmdArgs.push_back(Args.MakeArgString("--ptxas-arg=" + A));
9102 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
9103 CmdArgs.push_back(Args.MakeArgString(Twine("--offload-opt=-pass-remarks=") +
9105 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
9106 CmdArgs.push_back(Args.MakeArgString(
9108 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
9109 CmdArgs.push_back(Args.MakeArgString(
9111 if (Args.getLastArg(options::OPT_save_temps_EQ))
9115 Linker->ConstructJob(C, JA, Output, Inputs, Args, LinkingOutput);
9119 for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) {
9123 Args.MakeArgString(Twine("--device-linker=") + A->getValue(1)));
9125 CmdArgs.push_back(Args.MakeArgString(
9130 Args.ClaimAllArgs(options::OPT_Xoffload_linker);
9133 if (Args.hasFlag(options::OPT_fopenmp_target_jit,
9138 for (Arg *A : Args.filtered(options::OPT_mllvm)) {
9145 CmdArgs.push_back(Args.MakeArgString(Twine("--linker-path=") +
9150 addOffloadCompressArgs(Args, CmdArgs);
9153 Args.MakeArgString(getToolChain().GetProgramPath("clang-linker-wrapper"));