Lines Matching full:args

75 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
76   if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
81     if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
82         !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
84           << A->getBaseArg().getAsString(Args)
90 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
92   if (Args.hasArg(options::OPT_static))
94             Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
95       D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
170 static void ParseMRecip(const Driver &D, const ArgList &Args,
177   Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
184     OutStrings.push_back(Args.MakeArgString(Out + "all"));
196       OutStrings.push_back(Args.MakeArgString(Out + Val));
269     Out = Args.MakeArgString(Out + Prefix + Val);
271       Out = Args.MakeArgString(Out + ",");
274   OutStrings.push_back(Args.MakeArgString(Out));
279 static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args,
281   Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
294     CmdArgs.push_back(Args.MakeArgString("-mprefer-vector-width=" + Value));
319 static bool addExceptionArgs(const ArgList &Args, types::ID InputType,
328     Args.ClaimAllArgs(options::OPT_fexceptions);
329     Args.ClaimAllArgs(options::OPT_fno_exceptions);
330     Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
331     Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
332     Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
333     Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
334     Args.ClaimAllArgs(options::OPT_fasync_exceptions);
335     Args.ClaimAllArgs(options::OPT_fno_async_exceptions);
340   bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
345     bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,
356       Args.hasFlag(options::OPT_fobjc_exceptions,
367     Arg *ExceptionArg = Args.getLastArg(
385   Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);
387   Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,
395 static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC,
407   return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
412 static const char *addDebugCompDirArg(const ArgList &Args,
415   if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
418       CmdArgs.push_back(Args.MakeArgString(Twine("-fdebug-compilation-dir=") +
421       A->render(Args, CmdArgs);
424     CmdArgs.push_back(Args.MakeArgString("-fdebug-compilation-dir=" + *CWD));
430 static void addDebugObjectName(const ArgList &Args, ArgStringList &CmdArgs,
434   for (auto *Arg : Args.filtered(options::OPT_Xclang))
438   if (Args.hasArg(options::OPT_object_file_name_EQ))
460       Args.MakeArgString(Twine("-object-file-name=") + ObjFileNameForDebug));
465                                  const ArgList &Args, ArgStringList &CmdArgs) {
470       CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));
473   for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
485 static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args,
487   for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
494       CmdArgs.push_back(Args.MakeArgString("-fmacro-prefix-map=" + Map));
500 static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args,
502   for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
509       CmdArgs.push_back(Args.MakeArgString("-fcoverage-prefix-map=" + Map));
517 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
518   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
548 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
552   if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
556   if (Args.hasArg(options::OPT_rewrite_objc))
580                                    const ArgList &Args, SanitizerArgs &SanArgs,
583   auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
590   auto *CSPGOGenerateArg = getLastCSProfileGenerateArg(Args);
592   auto *ProfileGenerateArg = Args.getLastArg(
605   auto *ProfileUseArg = getLastProfileUseArg(Args);
622     if (Arg *ProfileSampleUseArg = getLastProfileSampleUseArg(Args))
630       CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +
635         Args.hasFlag(options::OPT_frtlib_defaultlib,
638       CmdArgs.push_back(Args.MakeArgString(
639           "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));
643   if (auto *ColdFuncCoverageArg = Args.getLastArg(
657     CmdArgs.push_back(Args.MakeArgString(
665   if (auto *A = Args.getLastArg(options::OPT_ftemporal_profile)) {
686         Args.hasFlag(options::OPT_frtlib_defaultlib,
689       CmdArgs.push_back(Args.MakeArgString(
690           "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));
698           Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));
704       CmdArgs.push_back(Args.MakeArgString(
715           Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));
719   bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
721                       Args.hasArg(options::OPT_coverage);
722   bool EmitCovData = TC.needsGCovInstrumentation(Args);
724   if (Args.hasFlag(options::OPT_fcoverage_mapping,
734   if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
736     if (!Args.hasFlag(options::OPT_fcoverage_mapping,
745   if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
748       CmdArgs.push_back(Args.MakeArgString(
751       A->render(Args, CmdArgs);
754     CmdArgs.push_back(Args.MakeArgString("-fcoverage-compilation-dir=" + *CWD));
757   if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
758     auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
759     if (!Args.hasArg(options::OPT_coverage))
766         Args.MakeArgString(Twine("-fprofile-exclude-files=" + v)));
769   if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
770     auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
771     if (!Args.hasArg(options::OPT_coverage))
777     CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-filter-files=" + v)));
780   if (const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
791   if (const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
794       D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
797           Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
801       D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
804     CmdArgs.push_back(Args.MakeArgString("-fprofile-function-groups=" +
807     CmdArgs.push_back(Args.MakeArgString("-fprofile-selected-function-group=" +
815   if (Args.hasArg(options::OPT_fprofile_arcs) ||
816       Args.hasArg(options::OPT_coverage))
817     FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
824     if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
842           Args.MakeArgString("-coverage-notes-file=" + CoverageFilename));
853           Args.MakeArgString("-coverage-data-file=" + CoverageFilename));
859 RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
866         Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));
885 static bool checkDebugInfoOption(const Arg *A, const ArgList &Args,
891       << A->getAsString(Args) << TC.getTripleString();
895 static void RenderDebugInfoCompressionArgs(const ArgList &Args,
899   const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
902   if (checkDebugInfoOption(A, Args, D, TC)) {
909             Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
916             Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
928                                                  const ArgList &Args,
936   if (haveAMDGPUCodeObjectVersionArgument(D, Args)) {
937     unsigned CodeObjVer = getAMDGPUCodeObjectVersion(D, Args);
939                    Args.MakeArgString(Twine("--amdhsa-code-object-version=") +
945                      Args.MakeArgString(Twine("-mcode-object-version=") +
990                                     const Driver &D, const ArgList &Args,
996   CheckPreprocessingOptions(D, Args);
998   Args.AddLastArg(CmdArgs, options::OPT_C);
999   Args.AddLastArg(CmdArgs, options::OPT_CC);
1002   Arg *ArgM = Args.getLastArg(options::OPT_MM);
1004     ArgM = Args.getLastArg(options::OPT_M);
1005   Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1007     ArgMD = Args.getLastArg(options::OPT_MD);
1018     if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1026       DepFile = getDependencyFileName(Args, Inputs);
1033     for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1037         A->render(Args, CmdArgs);
1042         CmdArgs.push_back(Args.MakeArgString(Quoted));
1052       Arg *OutputOpt = Args.getLastArg(options::OPT_o, options::OPT__SLASH_Fo);
1061         DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1067       CmdArgs.push_back(Args.MakeArgString(Quoted));
1074          !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1075         Args.hasArg(options::OPT_fmodule_file_deps))
1079   if (Args.hasArg(options::OPT_MG)) {
1086   Args.AddLastArg(CmdArgs, options::OPT_MP);
1087   Args.AddLastArg(CmdArgs, options::OPT_MV);
1094     getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1096     getToolChain().AddHIPIncludeArgs(Args, CmdArgs);
1098     getToolChain().addSYCLIncludeArgs(Args, CmdArgs);
1103       !Args.hasArg(options::OPT_nostdinc) &&
1104       !Args.hasArg(options::OPT_nogpuinc) &&
1107     if (!Args.hasArg(options::OPT_nobuiltininc)) {
1114       CmdArgs.push_back(Args.MakeArgString(P));
1121   if (Args.hasArg(options::OPT_foffload_via_llvm)) {
1126     CmdArgs.append({"-internal-isystem", Args.MakeArgString(P), "-include"});
1140     const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1141     const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1144       CmdArgs.push_back(Args.MakeArgString("-building-pch-with-obj"));
1147       if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
1149         CmdArgs.push_back(Args.MakeArgString("-fpch-instantiate-templates"));
1155         CmdArgs.push_back(Args.MakeArgString(D.GetClPchPath(
1162         CmdArgs.push_back(Args.MakeArgString(
1166             Args.MakeArgString(Twine("-pch-through-header=") + ThroughHeader));
1172   for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1198           CmdArgs.push_back(Args.MakeArgString(P));
1203                                                        << A->getAsString(Args);
1223     A->render(Args, CmdArgs);
1226   Args.addAllArgs(CmdArgs,
1236   Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1240   if (Arg *A = Args.getLastArg(options::OPT_I_))
1241     D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1247     if (!Args.hasArg(options::OPT_isysroot)) {
1258   addDirectoryList(Args, CmdArgs, "-I", "CPATH");
1260   addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
1262   addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
1264   addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
1266   addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
1274     bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1277         [&Args, &CmdArgs, HasStdlibxxIsystem](const ToolChain &TC) {
1278           HasStdlibxxIsystem ? TC.AddClangCXXStdlibIsystemArgs(Args, CmdArgs)
1279                              : TC.AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
1287   if (!Args.hasArg(options::OPT_nostdinc) &&
1288       !Args.hasArg(options::OPT_nogpuinc) &&
1289       !Args.hasArg(options::OPT_nobuiltininc)) {
1300       CmdArgs.push_back(Args.MakeArgString(P));
1308       CmdArgs.push_back(Args.MakeArgString(P));
1315                                [&Args, &CmdArgs](const ToolChain &TC) {
1316                                  TC.AddClangSystemIncludeArgs(Args, CmdArgs);
1320     getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1323   addMacroPrefixMapArg(D, Args, CmdArgs);
1324   addCoveragePrefixMapArg(D, Args, CmdArgs);
1326   Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,
1331     CmdArgs.push_back(Args.MakeArgString(Epoch));
1334   Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,
1375                                    const ArgList &Args) {
1382   return Args.getAllArgValues(options::OPT_arch).size() > 1;
1385 static bool checkRemarksOptions(const Driver &D, const ArgList &Args,
1390   bool hasMultipleInvocations = ::hasMultipleInvocations(Triple, Args);
1392       Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1401 static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,
1406   if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1411   const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1417         Args.getAllArgValues(options::OPT_arch).size() > 1;
1421     if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1422       if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1469     CmdArgs.push_back(Args.MakeArgString(F));
1473           Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1484 void AddAAPCSVolatileBitfieldArgs(const ArgList &Args, ArgStringList &CmdArgs) {
1485   if (!Args.hasFlag(options::OPT_faapcs_bitfield_width,
1489   if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))
1495                   const ArgList &Args, ArgStringList &CmdArgs) {
1500   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1503     std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ false);
1561 static void CollectARMPACBTIOptions(const ToolChain &TC, const ArgList &Args,
1564                      ? Args.getLastArg(options::OPT_msign_return_address_EQ,
1566                      : Args.getLastArg(options::OPT_mbranch_protection_EQ);
1613           << "b-key" << A->getAsString(Args);
1622       Args.MakeArgString(Twine("-msign-return-address=") + Scope));
1626           << A->getAsString(Args) << Triple.getTriple();
1628         Args.MakeArgString(Twine("-msign-return-address-key=") + Key));
1633           << A->getAsString(Args) << Triple.getTriple();
1635         Args.MakeArgString(Twine("-mbranch-protection-pauth-lr")));
1644           << A->getAsString(Args) << Triple.getTriple();
1649 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
1651   RenderARMABI(getToolChain().getDriver(), Triple, Args, CmdArgs);
1654   arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
1673   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1682   if (!Args.hasFlag(options::OPT_mimplicit_float,
1686   if (Args.getLastArg(options::OPT_mcmse))
1689   AddAAPCSVolatileBitfieldArgs(Args, CmdArgs);
1692   CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, false /*isAArch64*/);
1698                                 const ArgList &Args, bool KernelOrKext,
1703   getTargetFeatures(TC.getDriver(), EffectiveTriple, Args, CmdArgs, false);
1715     AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1721     AddAArch64TargetArgs(Args, CmdArgs);
1726     AddLoongArchTargetArgs(Args, CmdArgs);
1733     AddMIPSTargetArgs(Args, CmdArgs);
1740     AddPPCTargetArgs(Args, CmdArgs);
1745     AddRISCVTargetArgs(Args, CmdArgs);
1751     AddSparcTargetArgs(Args, CmdArgs);
1755     AddSystemZTargetArgs(Args, CmdArgs);
1760     AddX86TargetArgs(Args, CmdArgs);
1764     AddLanaiTargetArgs(Args, CmdArgs);
1768     AddHexagonTargetArgs(Args, CmdArgs);
1773     AddWebAssemblyTargetArgs(Args, CmdArgs);
1777     AddVETargetArgs(Args, CmdArgs);
1783 void RenderAArch64ABI(const llvm::Triple &Triple, const ArgList &Args,
1786   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1800 void Clang::AddAArch64TargetArgs(const ArgList &Args,
1804   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
1805       Args.hasArg(options::OPT_mkernel) ||
1806       Args.hasArg(options::OPT_fapple_kext))
1809   if (!Args.hasFlag(options::OPT_mimplicit_float,
1813   RenderAArch64ABI(Triple, Args, CmdArgs);
1816   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1826   CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, true /*isAArch64*/);
1829     handlePAuthABI(Args, CmdArgs);
1832   if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
1843             Args.MakeArgString("-mvscale-max=" + llvm::Twine(Bits / 128)));
1849           Args.MakeArgString("-mvscale-min=" + llvm::Twine(Bits / 128)));
1857   AddAAPCSVolatileBitfieldArgs(Args, CmdArgs);
1859   if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
1862       CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
1869   Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
1871   Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_calls,
1873   Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_returns,
1875   Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_auth_traps,
1877   Args.addOptInFlag(
1880   Args.addOptInFlag(
1883   Args.addOptInFlag(
1886   Args.addOptInFlag(
1890   Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_indirect_gotos,
1892   Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_init_fini,
1894   Args.addOptInFlag(CmdArgs,
1897   Args.addOptInFlag(CmdArgs, options::OPT_faarch64_jump_table_hardening,
1901 void Clang::AddLoongArchTargetArgs(const ArgList &Args,
1907       loongarch::getLoongArchABI(getToolChain().getDriver(), Args, Triple)
1911   if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
1915     CmdArgs.push_back(Args.MakeArgString(TuneCPU));
1918   if (Arg *A = Args.getLastArg(options::OPT_mannotate_tablejump,
1927 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1933   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1938   mips::FloatABI ABI = mips::getMipsFloatABI(D, Args, Triple);
1951   if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1959   if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1967   if (Args.getLastArg(options::OPT_mfix4300)) {
1972   if (Arg *A = Args.getLastArg(options::OPT_G)) {
1975     CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1979   Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1981       Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
2000       ParsePICArgs(getToolChain(), Args);
2011     Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
2013     Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
2015     Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
2053   if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
2058         CmdArgs.push_back(Args.MakeArgString("-mips-compact-branches=" + Val));
2066   if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
2075 void Clang::AddPPCTargetArgs(const ArgList &Args,
2079   if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2082     CmdArgs.push_back(Args.MakeArgString(CPU.str()));
2106   for (const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
2141   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true))
2144   ppc::FloatABI FloatABI = ppc::getPPCFloatABI(D, Args);
2163 void Clang::AddRISCVTargetArgs(const ArgList &Args,
2166   StringRef ABIName = riscv::getRISCVABI(Args, Triple);
2171   if (Arg *A = Args.getLastArg(options::OPT_G)) {
2176   if (!Args.hasFlag(options::OPT_mimplicit_float,
2180   if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2183       CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2189   if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
2195     std::string Arch = riscv::getRISCVArch(Args, Triple);
2219           Args.MakeArgString("-mvscale-max=" + llvm::Twine(VScaleMin)));
2221           Args.MakeArgString("-mvscale-min=" + llvm::Twine(VScaleMin)));
2230 void Clang::AddSparcTargetArgs(const ArgList &Args,
2233       sparc::getSparcFloatABI(getToolChain().getDriver(), Args);
2247   if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2256     CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2260 void Clang::AddSystemZTargetArgs(const ArgList &Args,
2262   if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
2265       CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
2271       Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false);
2272   bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2275       systemz::getSystemZFloatABI(getToolChain().getDriver(), Args);
2294 void Clang::AddX86TargetArgs(const ArgList &Args,
2297   addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/false);
2299   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
2300       Args.hasArg(options::OPT_mkernel) ||
2301       Args.hasArg(options::OPT_fapple_kext))
2304   if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2310   bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2311                           Args.hasArg(options::OPT_fapple_kext));
2312   if (Arg *A = Args.getLastArg(
2322   if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2326       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
2327       CmdArgs.push_back(Args.MakeArgString("-inline-asm=" + Value));
2337   if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup,
2340       CmdArgs.push_back(Args.MakeArgString("-mskip-rax-setup"));
2343   if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) {
2353   if (!Args.hasArg(clang::driver::options::OPT_march_EQ) &&
2358   if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
2371     CmdArgs.push_back(Args.MakeArgString(TuneCPU));
2375 void Clang::AddHexagonTargetArgs(const ArgList &Args,
2380   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
2383         Args.MakeArgString("-hexagon-small-data-threshold=" + Twine(*G)));
2386   if (!Args.hasArg(options::OPT_fno_short_enums))
2388   if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2396 void Clang::AddLanaiTargetArgs(const ArgList &Args,
2398   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2402     CmdArgs.push_back(Args.MakeArgString(CPUName));
2404   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2419 void Clang::AddWebAssemblyTargetArgs(const ArgList &Args,
2422   if (!Args.hasArg(options::OPT_fvisibility_EQ,
2427 void Clang::AddVETargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
2435                                     const InputInfo &Input, const ArgList &Args) const {
2468   if (!D.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2476   for (auto &A: Args) {
2494     A->render(Args, ASL);
2505     const InputInfo &Input, const llvm::opt::ArgList &Args) const {
2511     DumpCompilationDatabase(C, "", Target, Output, Input, Args);
2535   DumpCompilationDatabase(C, "", Target, Output, Input, Args);
2543 static void AddARMImplicitITArgs(const ArgList &Args, ArgStringList &CmdArgs,
2546   CmdArgs.push_back(Args.MakeArgString("-arm-implicit-it=" + Value));
2550                                               const ArgList &Args,
2561   Args.addOptInFlag(CmdArgs, options::OPT_mrelax_all,
2568   if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2573   Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
2575   Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
2578   // If you add more args here, also add them to the block below that
2598        Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,
2776           RenderDebugEnablingArgs(Args, CmdArgs,
2822     AddARMImplicitITArgs(Args, CmdArgs, ImplicitIt);
2849     Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2853     CmdArgs.push_back(Args.MakeArgString(AsSecureLogFile));
2898                                        bool OFastEnabled, const ArgList &Args,
2923   bool TrappingMathPresent = false; // Is trapping-math in args, and not
2933       TC.getDefaultDenormalModeForType(Args, JA);
2935       TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEsingle());
3009   if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3014   for (const Arg *A : Args) {
3121             << Args.MakeArgString("-ffp-model=" + Val) << "-Ofast";
3127             << Args.MakeArgString("-ffp-model=" + FPModel)
3128             << Args.MakeArgString("-ffp-model=" + Val);
3179             << Args.MakeArgString("-ffp-exception-behavior=" +
3198             << Args.MakeArgString("-ffp-exception-behavior=" +
3219             << A->getAsString(Args) << A->getValue();
3227             << A->getAsString(Args) << A->getValue();
3239               << Args.MakeArgString("-ffp-contract=" + Val);
3258             << Args.MakeArgString("-ffp-exception-behavior=" +
3260             << Args.MakeArgString("-ffp-exception-behavior=" + Val);
3384                        : Args.MakeArgString(A->getSpelling() + A->getValue());
3410           << ArgThatEnabledMathErrnoAfterVecLib->getAsString(Args)
3411           << VecLibArg->getAsString(Args);
3437     CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3445     CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
3449     CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
3452     CmdArgs.push_back(Args.MakeArgString("-frounding-math"));
3454     CmdArgs.push_back(Args.MakeArgString("-fno-rounding-math"));
3457     CmdArgs.push_back(Args.MakeArgString("-ffp-exception-behavior=" +
3461     CmdArgs.push_back(Args.MakeArgString("-ffp-eval-method=" + FPEvalMethod));
3464     CmdArgs.push_back(Args.MakeArgString("-ffloat16-excess-precision=" +
3467     CmdArgs.push_back(Args.MakeArgString("-fbfloat16-excess-precision=" +
3470   ParseMRecip(D, Args, CmdArgs);
3489     for (const auto *Arg : Args.filtered(options::OPT_Xclang)) {
3502   if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3508   if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
3515     CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
3516     if (Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))
3517       CmdArgs.push_back(Args.MakeArgString("-fcomplex-arithmetic=" +
3520   if (Args.hasArg(options::OPT_fcx_limited_range))
3522   if (Args.hasArg(options::OPT_fcx_fortran_rules))
3524   if (Args.hasArg(options::OPT_fno_cx_limited_range))
3526   if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
3530 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs,
3534   if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3585   if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3596   Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3610                              const ArgList &Args, ArgStringList &CmdArgs,
3624   if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3647     CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3651   for (const Arg *A : Args.filtered(options::OPT__param)) {
3657         CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3664   if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) {
3670           << A->getAsString(Args) << TripleStr;
3680       if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3682             << A->getAsString(Args);
3692       if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
3696               << A->getAsString(Args) << "-mstack-protector-guard=tls";
3715         if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3717               << A->getAsString(Args);
3722     A->render(Args, CmdArgs);
3725   if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) {
3731           << A->getAsString(Args) << TripleStr;
3743     A->render(Args, CmdArgs);
3746   if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) {
3751           << A->getAsString(Args) << TripleStr;
3776     A->render(Args, CmdArgs);
3779   if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) {
3786     A->render(Args, CmdArgs);
3790 static void RenderSCPOptions(const ToolChain &TC, const ArgList &Args,
3803   Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,
3809                                             const ArgList &Args,
3814   for (const Arg *A : Args) {
3845         Args.MakeArgString("-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3849           Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {
3850     if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3852             Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3860         Args.MakeArgString("-ftrivial-auto-var-init-stop-after=" + Val));
3863   if (Arg *A = Args.getLastArg(options::OPT_ftrivial_auto_var_init_max_size)) {
3864     if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||
3866             Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==
3874         Args.MakeArgString("-ftrivial-auto-var-init-max-size=" + Val));
3878 static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs,
3896   if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3898     CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3899   } else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) {
3901     CmdArgs.push_back(Args.MakeArgString(CLExtStr));
3904   if (Args.hasArg(options::OPT_cl_finite_math_only)) {
3910     if (const auto *A = Args.getLastArg(Arg))
3911       CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3915        (Args.hasArg(options::OPT_cl_std_EQ) && types::isSrcFile(InputType))) &&
3916       !Args.hasArg(options::OPT_cl_no_stdinc)) {
3922 static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs,
3936     if (const auto *A = Args.getLastArg(Arg))
3937       A->renderAsInput(Args, CmdArgs);
3939   if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
3940       !Args.hasArg(options::OPT_nostdinc))
3944 static void RenderOpenACCOptions(const Driver &D, const ArgList &Args,
3946   if (!Args.hasArg(options::OPT_fopenacc))
3951   if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override)) {
3955       A->renderAsInput(Args, CmdArgs);
3961 static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args,
3964   if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3965     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3982         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3983         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3988     Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3989     Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3990     Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3993   if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3996           << A->getAsString(Args) << "-ccc-arcmt-migrate";
4001     if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
4009       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4010       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4011       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4014     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4015     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4016     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4017     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
4018     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
4019     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
4020     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
4021     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
4022     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
4023     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
4024     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
4025     Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
4026     Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
4027     Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
4028     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
4029     Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path);
4034                                  const ArgList &Args, ArgStringList &CmdArgs) {
4037       Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
4038                    !Args.hasArg(options::OPT_mkernel));
4043   if (Args.hasArg(options::OPT_ffreestanding))
4047   for (const Arg *A : Args.filtered(options::OPT_fno_builtin_)) {
4053       A->render(Args, CmdArgs);
4072 clang::driver::tools::getCXX20NamedModuleOutputPath(const ArgList &Args,
4074   if (Arg *ModuleOutputEQ = Args.getLastArg(options::OPT_fmodule_output_EQ))
4078   if (Arg *FinalOutput = Args.getLastArg(options::OPT_o);
4079       FinalOutput && Args.hasArg(options::OPT_c))
4090                                  const ArgList &Args, const InputInfo &Input,
4101   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
4102     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4114   if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4119   Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,
4124   if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4128   Args.addOptOutFlag(CmdArgs, options::OPT_fmodulemap_allow_subdirectory_search,
4133   if (!Args.hasFlag(options::OPT_fimplicit_modules,
4142     if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4162       CmdArgs.push_back(Args.MakeArgString(Path));
4167     if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
4170     if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
4178   Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
4182   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
4186   if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
4192           Args.MakeArgString("-fmodule-map-file=" + BuiltinModuleMap));
4200     Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4203     for (const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
4204       CmdArgs.push_back(Args.MakeArgString(
4209     Args.ClaimAllArgs(options::OPT_fmodule_file);
4217     C.addTempFile(Args.MakeArgString(VFSDir));
4221     CmdArgs.push_back(Args.MakeArgString(VFSDir));
4225     Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
4228   Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
4229   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4230   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
4233     Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4235     if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4236       if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4238             << A->getAsString(Args) << "-fbuild-session-timestamp";
4243       CmdArgs.push_back(Args.MakeArgString(
4250     if (Args.getLastArg(
4252       if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4256       Args.AddLastArg(CmdArgs,
4260     if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
4265     Args.AddLastArg(CmdArgs,
4268     Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);
4269     Args.ClaimAllArgs(options::OPT_fbuild_session_file);
4270     Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);
4271     Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);
4272     Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);
4273     Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);
4280   if (Args.hasArg(options::OPT_modules_reduced_bmi) &&
4285     if (Args.hasArg(options::OPT_fmodule_output_EQ))
4286       Args.AddLastArg(CmdArgs, options::OPT_fmodule_output_EQ);
4288       CmdArgs.push_back(Args.MakeArgString(
4290           getCXX20NamedModuleOutputPath(Args, Input.getBaseInput())));
4296   Args.ClaimAllArgs(options::OPT_modules_reduced_bmi);
4307     Args.ClaimAllArgs(options::OPT_fmodule_output);
4308     Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);
4311   if (Args.hasArg(options::OPT_fmodules_embed_all_files))
4317 static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T,
4320   if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
4333   Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
4335   if (const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4354                               const llvm::Triple &T, const ArgList &Args,
4363     if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4381   if (isObjCAutoRefCount(Args)) {
4390       if (TC.GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4398     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4406   if (Args.hasArg(options::OPT_fno_objc_arc)) {
4407     Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
4408     Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
4414     auto *Arg = Args.getLastArg(
4431         Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
4438       WeakArg->render(Args, CmdArgs);
4442   if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))
4446 static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args,
4451   if (const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
4471   if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4475   Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,
4477   Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,
4481           Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4486   Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,
4490           Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
4493     CmdArgs.push_back(Args.MakeArgString(Opt));
4497           Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
4500     CmdArgs.push_back(Args.MakeArgString(Opt));
4503   if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4511   if (const Arg *A = Args.getLastArg(
4521   handleColorDiagnosticsArgs(D, Args, CmdArgs);
4523   if (Args.hasArg(options::OPT_fansi_escape_codes))
4526   Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
4529   Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
4532   if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
4535   if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4539   Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,
4542   Args.addLastArg(CmdArgs, options::OPT_warning_suppression_mappings_EQ);
4546                                             const ArgList &Args, Arg *&Arg) {
4547   Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,
4567                               const ArgList &Args, ArgStringList &CmdArgs,
4570       Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);
4577           << DwarfFormatArg->getAsString(Args) << "DWARFv3 or greater";
4580           << DwarfFormatArg->getAsString(Args) << "64 bit architecture";
4583           << DwarfFormatArg->getAsString(Args) << "ELF platforms";
4586   DwarfFormatArg->render(Args, CmdArgs);
4591                    const ArgList &Args, bool IRInput, ArgStringList &CmdArgs,
4595   if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
4598           Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
4613       Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
4619   if (IRInput || Args.hasArg(options::OPT_g_Group)) {
4621     DwarfFission = getDebugFissionKind(D, Args, SplitDWARFArg);
4623         !checkDebugInfoOption(SplitDWARFArg, Args, D, TC)) {
4628   if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4632     if (checkDebugInfoOption(A, Args, D, TC) &&
4650           Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
4652     if (checkDebugInfoOption(A, Args, D, TC)) {
4666   if (const Arg *A = getDwarfNArg(Args))
4667     EmitDwarf = checkDebugInfoOption(A, Args, D, TC);
4670   if (const Arg *A = Args.getLastArg(options::OPT_gcodeview))
4671     EmitCodeView = checkDebugInfoOption(A, Args, D, TC);
4691     RequestedDWARFVersion = getDwarfVersion(TC, Args);
4696     Args.ClaimAllArgs(options::OPT_fdebug_default_version);
4706   if (const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
4707     (void)checkDebugInfoOption(A, Args, D, TC);
4708   if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
4713   Args.ClaimAllArgs(options::OPT_g_flags_Group);
4721   if (const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
4722     (void)checkDebugInfoOption(A, Args, D, TC);
4723   if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4724                     !(EmitCodeView && !getLastProfileSampleUseArg(Args)) &&
4730   if (Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules, false)) {
4733     if (checkDebugInfoOption(Args.getLastArg(options::OPT_gmodules), Args, D,
4752   bool NeedFullDebug = Args.hasFlag(
4756   if (const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
4757     (void)checkDebugInfoOption(A, Args, D, TC);
4761     if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
4768   if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
4774     const Arg *A = Args.getLastArg(options::OPT_gembed_source);
4777           << A->getAsString(Args) << "-gdwarf-5";
4782           << A->getAsString(Args) << TC.getTripleString() << 5
4784     else if (checkDebugInfoOption(A, Args, D, TC))
4791     Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,
4794     Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,
4798   Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,
4802   if (willEmitRemarks(Args) &&
4807   TC.adjustDebugInfoKind(DebugInfoKind, Args);
4811   RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, EffectiveDWARFVersion,
4817   if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
4819     if (checkDebugInfoOption(Args.getLastArg(options::OPT_fdebug_macro), Args,
4825       Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
4828       (PubnamesArg && checkDebugInfoOption(PubnamesArg, Args, D, TC))) {
4843       Args.getLastArg(options::OPT_gsimple_template_names,
4847       checkDebugInfoOption(SimpleTemplateNamesArg, Args, D, TC)) {
4858   if (const auto *DebugTemplateAlias = Args.getLastArg(
4862     if (checkDebugInfoOption(DebugTemplateAlias, Args, D, TC)) {
4870   if (const Arg *A = Args.getLastArg(options::OPT_gsrc_hash_EQ)) {
4872     CmdArgs.push_back(Args.MakeArgString("-gsrc-hash=" + v));
4875   Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,
4880   if (const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges);
4881       A && checkDebugInfoOption(A, Args, D, TC)) {
4886   Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,
4890   if (Args.hasFlag(options::OPT_fdebug_types_section,
4894           << Args.getLastArg(options::OPT_fdebug_types_section)
4895                  ->getAsString(Args)
4898                    Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
4907           Args.getLastArg(options::OPT_gomit_unreferenced_methods,
4909     (void)checkDebugInfoOption(A, Args, D, TC);
4910   if (Args.hasFlag(options::OPT_gomit_unreferenced_methods,
4921   if (!Args.hasFlag(options::OPT_fdwarf_directory_asm,
4936   renderDwarfFormat(D, T, Args, CmdArgs, EffectiveDWARFVersion);
4937   RenderDebugInfoCompressionArgs(Args, CmdArgs, D, TC);
4940   if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {
4958       addDebugCompDirArg(Args, CmdArgs, D.getVFS());
4960   addDebugPrefixMapArg(D, TC, Args, CmdArgs);
4964     addDebugObjectName(Args, CmdArgs, DebugCompilationDir,
4968 static void ProcessVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args,
4972   if (Args.hasArg(options::OPT__SLASH_LDd))
4977   if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4980   if (Arg *A = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
4992     if (Args.hasArg(options::OPT__SLASH_LDd))
5005     if (Args.hasArg(options::OPT__SLASH_LDd))
5021   if (Args.hasArg(options::OPT_fms_omit_default_lib)) {
5041                          const ArgList &Args, const char *LinkingOutput) const {
5048       Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
5074        Args.hasFlag(options::OPT_offload_new_driver,
5079       Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc, false);
5141   CmdArgs.push_back(Args.MakeArgString(TripleStr));
5143   if (const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
5144     DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
5145     Args.ClaimAllArgs(options::OPT_MJ);
5147                  Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
5149                                          TripleStr, Output, Input, Args);
5150     Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
5176           CmdArgs.push_back(Args.MakeArgString(
5189     CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5196       if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
5197         CmdArgs.push_back(Args.MakeArgString(
5199             Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
5202             Args.MakeArgString("-Werror=format-invalid-specifier"));
5208   if (const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
5217       CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5223       if (!Args.getLastArg(options::OPT_O_Group))
5235     Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
5237       SYCLStdArg->render(Args, CmdArgs);
5244   if (Args.hasArg(options::OPT_fclangir))
5254     CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5282     UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5288   // If CollectArgsForIntegratedAssembler() isn't called below, claim the args
5296     // The args claimed here should match the args used in
5299       Args.ClaimAllArgs(options::OPT_mrelax_all);
5300       Args.ClaimAllArgs(options::OPT_mno_relax_all);
5301       Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5302       Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5308         Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5314     Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5315     Args.ClaimAllArgs(options::OPT_Xassembler);
5316     Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5329       if (Args.hasArg(options::OPT_rewrite_objc) &&
5330           !Args.hasArg(options::OPT_g_Group))
5338     CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
5341     (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5358     if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5359       PrettySGFArg->render(Args, CmdArgs);
5361     Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5363     if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5364       ProductNameArg->render(Args, CmdArgs);
5366             Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5367       ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5369             Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5373       EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5376       SymbolGraphDirArg->render(Args, CmdArgs);
5388       if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5389           Args.hasArg(options::OPT_emit_llvm)) {
5397           Args.hasArg(options::OPT_interface_stub_version_EQ)
5398               ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5402           Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str()));
5430           !Args.hasFlag(options::OPT_offload_new_driver,
5435             << Args.getLastArg(options::OPT_foffload_lto,
5437                    ->getAsString(Args)
5442             << Args.getLastArg(options::OPT_foffload_lto,
5444                    ->getAsString(Args)
5448         CmdArgs.push_back(Args.MakeArgString(
5459   Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5461   if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5463       D.Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5464     Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5468     Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5471   if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5472     Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5474   if (Args.getLastArg(options::OPT_save_temps_EQ))
5475     Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5477   auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5482     MemProfArg->render(Args, CmdArgs);
5485           Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5488           << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5489     if (auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5492           << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5493     MemProfUseArg->render(Args, CmdArgs);
5501     Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5506     TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind());
5553     for (const auto &A : Args)
5558     Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5561     RenderFloatingPointOptions(TC, D, isOptimizationLevelFast(Args), Args,
5570       RenderARMABI(D, Triple, Args, CmdArgs);
5575       RenderAArch64ABI(Triple, Args, CmdArgs);
5580     if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5585         A->render(Args, CmdArgs);
5600       addDashXForInput(Args, II, CmdArgs);
5604         II.getInputArg().renderAsInput(Args, CmdArgs);
5630   if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5636   if (Args.hasFlag(options::OPT_fdiscard_value_names,
5638     if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5650   CmdArgs.push_back(getBaseInputName(Args, Input));
5654   if (Args.hasArg(options::OPT_static))
5657   if (Args.hasArg(options::OPT_municode))
5661     RenderAnalyzerOptions(Args, CmdArgs, Triple, Input);
5664       (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
5671   for (auto *Arg : Args.filtered(options::OPT_Xclang))
5677     for (auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5685   CheckCodeGenerationOptions(D, Args);
5687   unsigned FunctionAlignment = ParseFunctionAlignment(TC, Args);
5691     CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5696   if (const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5700           << A->getAsString(Args) << A->getValue();
5703           << A->getAsString(Args) << A->getValue();
5706       CmdArgs.push_back(Args.MakeArgString("-falign-loops=" +
5720       auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5742   std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(TC, Args);
5744       Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5768   if (Args.hasArg(options::OPT_mcmse) &&
5769       !Args.hasArg(options::OPT_fallow_unsupported)) {
5777       !Args.hasArg(options::OPT_fallow_unsupported))
5801   if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5818     Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5827         A->render(Args, CmdArgs);
5835     if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5838             << A->getValue() << A->getAsString(Args);
5844       CmdArgs.push_back(Args.MakeArgString(Model));
5848   if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5867     A->render(Args, CmdArgs);
5870   if (Args.hasFlag(options::OPT_fmerge_all_constants,
5874   Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5879   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5886   if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5894   if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5901       CmdArgs.push_back(Args.MakeArgString("-fwarn-stack-size=" + V));
5904   Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5906   Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5908   Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5911   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5916   if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5929   if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5942   if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) {
5949   if (Args.hasArg(options::OPT_fenable_matrix)) {
5957                   getFramePointerKind(Args, RawTriple);
5976   Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5979   bool OFastEnabled = isOptimizationLevelFast(Args);
5988   if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5991   if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
5994   if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5997   Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5999   Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
6001   Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
6003   Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
6005   Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
6007   Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
6009   Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
6012   Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
6015   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6018   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6021   Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
6025   Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
6029   if (Args.hasFlag(options::OPT_fprotect_parens,
6033   RenderFloatingPointOptions(TC, D, OFastEnabled, Args, CmdArgs, JA);
6035   if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
6049   if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
6051       A->render(Args, CmdArgs);
6054           << A->getAsString(Args) << TripleStr;
6057   if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
6059       A->render(Args, CmdArgs);
6062       A->render(Args, CmdArgs);
6065           << A->getAsString(Args) << TripleStr;
6071   if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
6077   if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
6081       A->render(Args, CmdArgs);
6085       A->render(Args, CmdArgs);
6096   if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
6100   if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
6116   if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
6122     Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
6126   if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
6133   if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
6137       A->render(Args, CmdArgs);
6145     Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);
6151       Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
6156   Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
6161   auto SanitizeArgs = TC.getSanitizerArgs(Args);
6164       TC.getDefaultUnwindTableLevel(Args) == ToolChain::UnwindTableLevel::Asynchronous;
6166       TC.getDefaultUnwindTableLevel(Args) == ToolChain::UnwindTableLevel::Synchronous;
6168   bool AsyncUnwindTables = Args.hasFlag(
6174       Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
6183   if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
6191       CmdArgs.push_back(Args.MakeArgString(HostCPU));
6197   TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind());
6199   addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
6201   if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
6211     Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6214   if (isTLSDESCEnabled(TC, Args))
6218   std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ false);
6221     CmdArgs.push_back(Args.MakeArgString(CPU));
6224   RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6229     AddClangCLArgs(Args, InputType, CmdArgs);
6234   renderDebugOptions(TC, D, RawTriple, Args, types::isLLVMIR(InputType),
6246     const char *SplitDWARFOut = SplitDebugName(JA, Args, Input, Output);
6256   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6263   if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6267       if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6268           (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6273     if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6277     if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6282   Args.AddAllArgs(CmdArgs, options::OPT_v);
6284   if (Args.getLastArg(options::OPT_H)) {
6288   Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6296     CmdArgs.push_back(Args.MakeArgString(
6300         Args.MakeArgString("-header-include-filtering=" +
6304   Args.AddLastArg(CmdArgs, options::OPT_P);
6305   Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6321   if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6322     StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6324     CmdArgs.push_back(Args.MakeArgString("-crash-diagnostics-dir=" + Dir));
6329   if (Args.hasFlag(options::OPT_ffunction_sections,
6334   if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6338         A->render(Args, CmdArgs);
6341           << A->getAsString(Args) << TripleStr;
6345   if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6349           << A->getAsString(Args) << /*hasReplacement=*/true
6355             << A->getAsString(Args) << A->getValue();
6357         A->render(Args, CmdArgs);
6363             << A->getAsString(Args) << A->getValue();
6365         A->render(Args, CmdArgs);
6373           << A->getAsString(Args) << TripleStr;
6378   if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6383   Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6385   Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6387   Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6389   Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6392   if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6397         A->render(Args, CmdArgs);
6400             << A->getAsString(Args) << TripleStr;
6404   Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6407   Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6414     addPGOAndCoverageFlags(TC, C, JA, Output, Args, SanitizeArgs, CmdArgs);
6416   Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6418   if (getLastProfileSampleUseArg(Args) &&
6419       Args.hasArg(options::OPT_fsample_profile_use_profi)) {
6426       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6427     PScpu::addProfileRTArgs(TC, Args, CmdArgs);
6428     PScpu::addSanitizerArgs(TC, Args, CmdArgs);
6432   if (Args.hasArg(options::OPT_nostdinc)) {
6436     if (Args.hasArg(options::OPT_nostdlibinc))
6438     Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6439     Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6446   Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6448   RenderARCMigrateToolOptions(D, Args, CmdArgs);
6455     AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
6461   Args.ClaimAllArgs(options::OPT_D);
6464   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
6469       A->render(Args, CmdArgs);
6475        Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6476     D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6481        Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6482     D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6486   claimNoWarnArgs(Args);
6488   Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6491        Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6497             << A->getAsString(Args) << A->getValue();
6502         CmdArgs.push_back(Args.MakeArgString(
6507     A->render(Args, CmdArgs);
6510   Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6512   if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
6514   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6515   Args.AddLastArg(CmdArgs, options::OPT_w);
6517   Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6520   if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6521     A->render(Args, CmdArgs);
6523   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6526   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6529   if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6530     A->render(Args, CmdArgs);
6539   const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6547       Std->render(Args, CmdArgs);
6550     if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6554         A->render(Args, CmdArgs);
6563       if (!Args.hasArg(options::OPT__SLASH_std)) {
6564         Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
6572     Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6589         Args.getLastArg(options::OPT_Wwrite_strings,
6600       Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6606   if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6613   if (!ShouldEnableAutolink(Args, TC, JA))
6616   Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6617   Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6618   Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6619   Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6621   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6623   if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6626   if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6631   if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6635       CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
6640   if (Args.hasArg(options::OPT_relocatable_pch))
6643   if (const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6651       A->render(Args, CmdArgs);
6654   if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6659   if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6664   Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6667   if (Args.hasArg(options::OPT_fstack_usage)) {
6670     if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6673       CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6676           Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".su"));
6680   if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6685   Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6686   Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6687   Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6688   Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6689   Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6693   if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6705         Args.MakeArgString("-fmessage-length=" + Twine(MessageLength)));
6707   if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6709         Args.MakeArgString("-frandomize-layout-seed=" + Twine(A->getValue(0))));
6711   if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6712     CmdArgs.push_back(Args.MakeArgString("-frandomize-layout-seed-file=" +
6716   if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6719       A->render(Args, CmdArgs);
6735             Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6740         Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6741         Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6742         Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6743         Args.AddLastArg(CmdArgs,
6749   if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6753   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6759           Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6761         << A->getAsString(Args) << /*hasReplacement=*/true
6766           Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6769       A->render(Args, CmdArgs);
6777   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6779   if (Args.hasFlag(options::OPT_fnew_infallible,
6783   if (Args.hasFlag(options::OPT_fno_operator_names,
6788   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6789   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6790   Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6791   Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6792   Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
6795   if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6799   Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6802   if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6808           << A->getAsString(Args) << TripleStr;
6813     Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6815   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6816   Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6820   if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6822       !Args.hasFlag(options::OPT_foffload_via_llvm,
6826     switch (D.getOpenMPRuntime(Args)) {
6835       if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6838       Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6840       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6841       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6842       if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6845       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6846       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6847       Args.AddAllArgs(CmdArgs,
6849       if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6856       if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6861       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6862       if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6868       if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6872       if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6876       if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6878       if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6880       if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6882       if (Args.hasArg(options::OPT_fopenmp_force_usm))
6895     Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6897     Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6898     Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6904   if (Args.hasFlag(options::OPT_foffload_via_llvm,
6907   } else if (Args.hasFlag(options::OPT_offload_new_driver,
6914   XRay.addArgs(TC, Args, CmdArgs, InputType);
6917        Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6919       CmdArgs.push_back(Args.MakeArgString("-fprofile-list=" + Filename));
6924   if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6932           << A->getAsString(Args) << TripleStr;
6941       CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6942       CmdArgs.push_back(Args.MakeArgString(
6947   Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6950     Args.AddLastArg(CmdArgs, options::OPT_pg);
6953     if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6955         A->render(Args, CmdArgs);
6958             << A->getAsString(Args) << TripleStr;
6960     if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6962         A->render(Args, CmdArgs);
6965             << A->getAsString(Args) << TripleStr;
6967     if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6969         A->render(Args, CmdArgs);
6972             << A->getAsString(Args) << TripleStr;
6976   if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6979           << A->getAsString(Args) << TripleStr;
6982   if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6985           << A->getAsString(Args) << TripleStr;
6988   if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6991       if (TC.getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6998     for (const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
7005   if (Args.getLastArg(options::OPT_fapple_kext) ||
7006       (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
7009   Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
7010   Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
7011   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
7012   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
7013   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
7014   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
7015   Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
7016   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
7017   Args.AddLastArg(CmdArgs, options::OPT_malign_double);
7018   Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
7021     CmdArgs.push_back(Args.MakeArgString("-ftime-trace=" + Twine(Name)));
7022     Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
7023     Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
7026   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
7031   Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
7035   renderCommonIntegerOverflowOptions(Args, CmdArgs);
7037   Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
7040   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
7041   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
7044   Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
7046   Args.AddLastArg(CmdArgs, options::OPT_pthread);
7048   Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
7051   RenderSSPOptions(D, TC, Args, CmdArgs, KernelOrKext);
7052   RenderSCPOptions(TC, Args, CmdArgs);
7053   RenderTrivialAutoVarInitOptions(D, TC, Args, CmdArgs);
7055   Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
7057   Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
7060   if (Args.hasArg(options::OPT_mstack_alignment)) {
7061     StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
7062     CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
7065   if (Args.hasArg(options::OPT_mstack_probe_size)) {
7066     StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
7069       CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
7074   Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
7077   if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
7089   RenderOpenCLOptions(Args, CmdArgs, InputType);
7092   RenderHLSLOptions(Args, CmdArgs, InputType);
7095   RenderOpenACCOptions(D, Args, CmdArgs, InputType);
7098     if (Args.hasFlag(options::OPT_fhip_new_launch_api,
7101     Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
7103     Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
7104     Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
7105     Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
7112     Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
7114     if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
7123   if (Args.hasArg(options::OPT_nogpulib))
7126   if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
7128         Args.MakeArgString(Twine("-fcf-protection=") + A->getValue()));
7130     if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
7131       CmdArgs.push_back(Args.MakeArgString(Twine("-mcf-branch-label-scheme=") +
7135   if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
7137         Args.MakeArgString(Twine("-mfunction-return=") + A->getValue()));
7139   Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
7145     if (Arg *A = getLastProfileSampleUseArg(Args)) {
7146       auto *PGOArg = Args.getLastArg(
7159         A->render(Args, CmdArgs);
7161     Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
7163     if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
7168       if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
7173   RenderBuiltinOptions(TC, RawTriple, Args, CmdArgs);
7175   Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7178   if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes, false))
7180   if (Args.hasFlag(options::OPT_fapinotes_modules,
7183   Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
7186   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
7188       (Args.hasArg(options::OPT_fgnu_runtime) &&
7189        Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
7190        !Args.hasArg(options::OPT_fno_blocks))) {
7193     if (!Args.hasArg(options::OPT_fgnu_runtime) && !TC.hasBlocksRuntime())
7201   if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7206   Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7209   Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7211   Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7221   if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7225   RenderCharacterOptions(Args, AuxTriple ? *AuxTriple : RawTriple, CmdArgs);
7228   if (!Args.hasFlag(
7236   if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7241   Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7245   if (Args.hasFlag(options::OPT_fminimize_whitespace,
7255   if (Args.hasFlag(options::OPT_fkeep_system_includes,
7265   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7270   bool IsMSVCCompat = Args.hasFlag(
7272       (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7277         Args.hasArg(options::OPT_fms_define_stdc))
7282       Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7283     ProcessVSRuntimeLibrary(getToolChain(), Args, CmdArgs);
7287   if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7297           << A->getAsString(Args) << A->getValue();
7305         Args.MakeArgString("-fgnuc-version=" + GNUCVer.getAsString()));
7308   VersionTuple MSVT = TC.computeMSVCVersion(&D, Args);
7311         Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
7316     if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7324             << StdArg->getAsString(Args);
7330     if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7342             << StdArg->getAsString(Args);
7355   Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7359   if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7362   else if (Args.hasArg(options::OPT_fno_declspec))
7367   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7373   if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7378   if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7384   Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7387   Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7390   const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7393   if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7395       A->render(Args, CmdArgs);
7397     InlineArg->render(Args, CmdArgs);
7400   Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7413       RenderModulesOptions(C, D, Args, Input, Output, HaveCxx20, CmdArgs);
7426   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7435   if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7438   if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7441   if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7444   if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7448   ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7449   RenderObjCOptions(TC, D, RawTriple, Args, Runtime, rewriteKind != RK_None,
7453       Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7458   if (Args.hasFlag(options::OPT_fapplication_extension,
7462   // Handle GCC-style exception args.
7465     EH = addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7468   Arg *A = Args.getLastArg(
7482     switch (TC.GetExceptionModel(Args)) {
7498   Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7502   Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7507   Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
7512   if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7523   if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7526         Args.MakeArgString(Twine("-fnew-alignment=") + A->getValue()));
7530   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7532       !Args.hasFlag(options::OPT_mconstant_cfstrings,
7536   Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7541   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7544     CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7545   } else if (Args.hasFlag(options::OPT_fpack_struct,
7551   bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7552   if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7556       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7561       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7565   if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true))
7569   Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7573   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7576         << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7579   if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope, true))
7581         << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7584   if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7587       D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7592   if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7595       D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7599   RenderDiagnosticsOptions(D, Args, CmdArgs);
7601   Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7604   Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7610   bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
7613   if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
7618   bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
7621   if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
7625   ParseMPreferVectorWidth(D, Args, CmdArgs);
7627   Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7628   Args.AddLastArg(CmdArgs,
7633   if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7641   Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7645   if (willEmitRemarks(Args) && checkRemarksOptions(D, Args, Triple))
7646     renderRemarksOptions(Args, CmdArgs, Triple, Input, Output, JA);
7648   bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7653   Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7660   if (Args.hasFlag(options::OPT_frewrite_includes,
7665   if (Args.hasFlag(options::OPT_fzos_extensions,
7668   else if (Args.hasArg(options::OPT_fno_zos_extensions))
7672   if (Arg *A = Args.getLastArg(options::OPT_traditional,
7677       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7680   Args.AddLastArg(CmdArgs, options::OPT_dM);
7681   Args.AddLastArg(CmdArgs, options::OPT_dD);
7682   Args.AddLastArg(CmdArgs, options::OPT_dI);
7684   Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7687   if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7689     CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7692   if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7695   Args.AddLastArg(CmdArgs, options::OPT_fextend_variable_liveness_EQ);
7698   Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7700   Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7703   for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7717   for (const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7726         D.Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7729             << PluginName << A->getAsString(Args);
7734     CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-arg-") + PluginName));
7735     CmdArgs.push_back(Args.MakeArgString(Arg));
7739   for (const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7741         Args.MakeArgString(Twine("-fpass-plugin=") + A->getValue()));
7746   for (const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7752   Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7755   Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7759   SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D);
7761     CmdArgs.push_back(Args.MakeArgString(Twine("-stats-file=") + StatsFile));
7768   for (auto Arg : Args.filtered(options::OPT_Xclang)) {
7779   for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
7788       A->render(Args, CmdArgs);
7794   SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
7810   Args.AddAllArgs(CmdArgs, options::OPT_undef);
7821   if (shouldRecordCommandLine(TC, Args, FRecordSwitches, GRecordSwitches)) {
7822     auto FlagsArgString = renderEscapedCommandLine(TC, Args);
7846         CmdArgs.push_back(Args.MakeArgString("-fembed-offload-object=" +
7852     if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7866       CmdArgs.push_back(Args.MakeArgString(Twine("-cuid=") + Twine(CUID)));
7870     bool UseApproxTranscendentals = Args.hasFlag(
7872     if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7877     Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7883     Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7886   Args.AddAllArgs(CmdArgs,
7889   Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7892   Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7897         Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7901       CmdArgs.append({"-mllvm", Args.MakeArgStringRef(ArgStr)});
7906     Args.addOptOutFlag(CmdArgs,
7918     if (Args.hasArg(options::OPT_foffload_via_llvm))
7923       CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->getFilename()));
7928     handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs);
7930     Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7932     Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7936   addOpenMPHostOffloadingArgs(C, JA, Args, CmdArgs);
7939       Args.hasFlag(options::OPT_fvirtual_function_elimination,
7953   bool WholeProgramVTables = Args.hasFlag(
7993       Args.hasFlag(options::OPT_fsplit_lto_unit,
8001   if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
8007             << A->getAsString(Args) << TC.getTripleString();
8009       CmdArgs.push_back(Args.MakeArgString(
8013       A->render(Args, CmdArgs);
8017   if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
8029       Arg *A = Args.getLastArg(options::OPT_O_Group);
8049           Args.getLastArg(options::OPT_forder_file_instrumentation)) {
8051         << A->getAsString(Args) << /*hasReplacement=*/true
8063   if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
8069   Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
8071   Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
8073   Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
8075   if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
8076     A->render(Args, CmdArgs);
8078   addMachineOutlinerArgs(D, Args, CmdArgs, Triple, /*IsLTO=*/false);
8080   addOutlineAtomicsArgs(D, getToolChain(), Args, CmdArgs, Triple);
8083       (Args.hasArg(options::OPT_mno_fmv) ||
8085        getToolChain().GetRuntimeLibType(Args) != ToolChain::RLT_CompilerRT)) {
8091   if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
8105   if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
8106     std::string Str = A->getAsString(Args);
8110     CmdArgs.push_back(Args.MakeArgString(Str));
8123       CmdArgs.push_back(Args.MakeArgString(OutputFilename));
8132   addDashXForInput(Args, Input, CmdArgs);
8144       Input.getInputArg().renderAsInput(Args, CmdArgs);
8160       Args.hasFlag(options::OPT__SLASH_showFilenames,
8165   if (Arg *A = Args.getLastArg(options::OPT_pg))
8167         !Args.hasArg(options::OPT_mfentry))
8169                                                       << A->getAsString(Args);
8175   Args.ClaimAllArgs(options::OPT_fpch_preprocess);
8179   Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8180   Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8183   Args.ClaimAllArgs(options::OPT_emit_llvm);
8197 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
8203       args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
8225     runtimeArg->render(args, cmdArgs);
8236   if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
8252     if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
8263               args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
8326         args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
8351 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args,
8356       Args.getAllArgValues(options::OPT__SLASH_EH);
8390       Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
8396   if (Args.hasArg(options::OPT__SLASH_kernel)) {
8405 void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
8409   ProcessVSRuntimeLibrary(getToolChain(), Args, CmdArgs);
8412           Args.getLastArg(options::OPT__SLASH_showIncludes,
8420   if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8426   if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
8429     CmdArgs.push_back(Args.MakeArgString(Twine(LangOptions::SSPStrong)));
8435   EHFlags EH = parseClangCLEHFlags(D, Args, IsWindowsMSVC);
8447   if (Args.hasArg(options::OPT__SLASH_EP)) {
8452  if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
8458  if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
8463  if (Args.hasArg(options::OPT__SLASH_kernel)) {
8466        Args.getAllArgValues(options::OPT__SLASH_arch);
8479    if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_, false))
8484   Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
8485   Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
8488         << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
8491     Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
8492     Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
8493     Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
8499           << FirstConflict->getAsString(Args)
8500           << SecondConflict->getAsString(Args);
8510   if (Args.hasArg(options::OPT_regcall4))
8515           Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
8549   if (Args.hasArg(options::OPT__SLASH_Gregcall4))
8552   Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
8554   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
8559   if (Args.hasArg(options::OPT__SLASH_kernel))
8562   for (const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
8585 const char *Clang::getBaseInputName(const ArgList &Args,
8587   return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
8590 const char *Clang::getBaseInputStem(const ArgList &Args,
8592   const char *Str = getBaseInputName(Args, Inputs[0]);
8595     return Args.MakeArgString(std::string(Str, End));
8600 const char *Clang::getDependencyFileName(const ArgList &Args,
8604   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
8607     return Args.MakeArgString(OutputFilename);
8610   return Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".d");
8615 void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
8620   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
8626 void ClangAs::AddX86TargetArgs(const ArgList &Args,
8628   addX86AlignBranchArgs(getToolChain().getDriver(), Args, CmdArgs,
8631   if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
8635       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
8643 void ClangAs::AddLoongArchTargetArgs(const ArgList &Args,
8646   CmdArgs.push_back(loongarch::getLoongArchABI(getToolChain().getDriver(), Args,
8651 void ClangAs::AddRISCVTargetArgs(const ArgList &Args,
8654   StringRef ABIName = riscv::getRISCVABI(Args, Triple);
8659   if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8668                            const ArgList &Args,
8680   Args.ClaimAllArgs(options::OPT_w);
8682   Args.ClaimAllArgs(options::OPT_emit_llvm);
8684   claimNoWarnArgs(Args);
8693   CmdArgs.push_back(Args.MakeArgString(TripleStr));
8695   getToolChain().addClangCC1ASTargetOptions(Args, CmdArgs);
8705   CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
8708   std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ true);
8711     CmdArgs.push_back(Args.MakeArgString(CPU));
8715   getTargetFeatures(D, Triple, Args, CmdArgs, true);
8718   (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
8721   Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
8724   Args.AddAllArgs(CmdArgs, options::OPT_embed_dir_EQ);
8739   Args.ClaimAllArgs(options::OPT_g_Group);
8740   if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8746   if (const Arg *A = getDwarfNArg(Args))
8747     EmitDwarf = checkDebugInfoOption(A, Args, D, getToolChain());
8750   if (const Arg *A = Args.getLastArg(options::OPT_gcodeview))
8751     EmitCodeView = checkDebugInfoOption(A, Args, D, getToolChain());
8775       addDebugCompDirArg(Args, CmdArgs, C.getDriver().getVFS());
8786     addDebugPrefixMapArg(getToolChain().getDriver(), getToolChain(), Args,
8792     CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
8795     Args.AddAllArgs(CmdArgs, options::OPT_I);
8797   const unsigned DwarfVersion = getDwarfVersion(getToolChain(), Args);
8798   RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
8800   renderDwarfFormat(D, Triple, Args, CmdArgs, DwarfVersion);
8801   RenderDebugInfoCompressionArgs(Args, CmdArgs, D, getToolChain());
8809       ParsePICArgs(getToolChain(), Args);
8821     for (const auto &Arg : Args)
8822       Arg->render(Args, OriginalArgs);
8834     CmdArgs.push_back(Args.MakeArgString(Flags));
8848     AddMIPSTargetArgs(Args, CmdArgs);
8853     AddX86TargetArgs(Args, CmdArgs);
8862     if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8872     if (Args.hasArg(options::OPT_mmark_bti_property)) {
8880     AddLoongArchTargetArgs(Args, CmdArgs);
8885     AddRISCVTargetArgs(Args, CmdArgs);
8889     if (Args.hasFlag(options::OPT_mdefault_build_attributes,
8902   Args.ClaimAllArgs(options::OPT_W_Group);
8904   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
8907   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
8910     addDebugObjectName(Args, CmdArgs, DebugCompilationDir,
8923        addDebugObjectName(Args, NewArgs, DebugCompilationDir,
8938   if (getDebugFissionKind(D, Args, A) == DwarfFissionKind::Split &&
8941     CmdArgs.push_back(SplitDebugName(JA, Args, Input, Output));
8945     handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs, /*IsCC1As=*/true);
9158                                    const llvm::opt::ArgList &Args,
9201     CmdArgs.push_back(Args.MakeArgString("--image=" + llvm::join(Parts, ",")));
9206       Args.MakeArgString(getToolChain().GetProgramPath(getShortName())),
9213                                  const ArgList &Args,
9225         CudaInstallationDetector CudaInstallation(D, TheTriple, Args);
9227           CmdArgs.push_back(Args.MakeArgString(
9235   if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
9249       CmdArgs.push_back(Args.MakeArgString(Twine("--opt-level=O") + OOpt));
9253       Args.MakeArgString("--host-triple=" + TheTriple.getTriple()));
9254   if (Args.hasArg(options::OPT_v))
9257   if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
9264   if (const Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
9265     CmdArgs.push_back(Args.MakeArgString("-mllvm"));
9266     CmdArgs.push_back(Args.MakeArgString(
9270   for (const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
9271     CmdArgs.push_back(Args.MakeArgString("--ptxas-arg=" + A));
9274   if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
9275     CmdArgs.push_back(Args.MakeArgString(Twine("--offload-opt=-pass-remarks=") +
9277   if (const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
9278     CmdArgs.push_back(Args.MakeArgString(
9280   if (const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
9281     CmdArgs.push_back(Args.MakeArgString(
9284   if (Args.getLastArg(options::OPT_ftime_report))
9287   if (Args.getLastArg(options::OPT_save_temps_EQ))
9291   Linker->ConstructJob(C, JA, Output, Inputs, Args, LinkingOutput);
9295   for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) {
9299           Args.MakeArgString(Twine("--device-linker=") + A->getValue(1)));
9301       CmdArgs.push_back(Args.MakeArgString(
9306   Args.ClaimAllArgs(options::OPT_Xoffload_linker);
9309   if (Args.hasFlag(options::OPT_fopenmp_target_jit,
9314   for (Arg *A : Args.filtered(options::OPT_mllvm)) {
9321   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r, options::OPT_nogpulib,
9331         CmdArgs.push_back(Args.MakeArgString(
9333         CmdArgs.push_back(Args.MakeArgString(
9337           TC.getCompilerRT(Args, "builtins", ToolChain::FT_Static));
9340             Args.MakeArgString("--device-linker=" + TC.getTripleString() + "=" +
9347   if (!Args.hasFlag(options::OPT_gpulibc, options::OPT_nogpulibc, true))
9351   CmdArgs.push_back(Args.MakeArgString(Twine("--linker-path=") +
9356   addOffloadCompressArgs(Args, CmdArgs);
9359       Args.MakeArgString(getToolChain().GetProgramPath("clang-linker-wrapper"));