4815 const ArgList &Args,
const char *LinkingOutput)
const {
4817 const llvm::Triple &RawTriple = TC.
getTriple();
4819 const std::string &TripleStr = Triple.getTriple();
4822 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4824 ArgStringList CmdArgs;
4826 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4844 bool IsHostOffloadingAction =
4848 Args.hasFlag(options::OPT_offload_new_driver,
4849 options::OPT_no_offload_new_driver,
4853 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4864 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4868 const InputInfo *CudaDeviceInput =
nullptr;
4869 const InputInfo *OpenMPDeviceInput =
nullptr;
4871 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4873 }
else if (IsExtractAPI) {
4874 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4875 if (I.getType() != ExpectedInputType) {
4876 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4880 ExtractAPIInputs.push_back(I);
4881 }
else if (IsHostOffloadingAction) {
4882 HostOffloadingInputs.push_back(I);
4883 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4884 CudaDeviceInput = &I;
4885 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4886 OpenMPDeviceInput = &I;
4888 llvm_unreachable(
"unexpectedly given multiple inputs");
4892 const llvm::Triple *AuxTriple =
4894 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4895 bool IsUEFI = RawTriple.isUEFI();
4896 bool IsIAMCU = RawTriple.isOSIAMCU();
4901 if (IsCuda || IsHIP || IsSYCL)
4902 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4906 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4911 CmdArgs.push_back(
"-cc1");
4914 CmdArgs.push_back(
"-triple");
4915 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4917 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4918 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4919 Args.ClaimAllArgs(options::OPT_MJ);
4920 }
else if (
const Arg *GenCDBFragment =
4921 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4922 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4923 TripleStr, Output, Input, Args);
4924 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4927 if (IsCuda || IsHIP) {
4930 std::string NormalizedTriple;
4948 assert(CTC &&
"Expected valid CUDA Toolchain.");
4950 CmdArgs.push_back(Args.MakeArgString(
4951 Twine(
"-target-sdk-version=") +
4959 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4962 CmdArgs.push_back(
"-aux-triple");
4963 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4968 getToolChain().getTriple().getVendor() == llvm::Triple::AMD))) {
4970 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4971 CmdArgs.push_back(Args.MakeArgString(
4973 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4976 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4982 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4983 if (A->getOption().matches(options::OPT_O4)) {
4984 CmdArgs.push_back(
"-O3");
4985 D.
Diag(diag::warn_O4_is_O3);
4987 A->render(Args, CmdArgs);
4992 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
4998 llvm::Triple AuxT =
C.getDefaultToolChain().getTriple();
4999 std::string NormalizedTriple = AuxT.normalize();
5000 CmdArgs.push_back(
"-aux-triple");
5001 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5004 CmdArgs.push_back(
"-fsycl-is-device");
5007 if (!Args.getLastArg(options::OPT_O_Group))
5008 CmdArgs.push_back(
"-O2");
5015 CmdArgs.push_back(
"-fsycl-is-host");
5019 Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
5021 SYCLStdArg->render(Args, CmdArgs);
5024 CmdArgs.push_back(
"-sycl-std=2020");
5028 if (Args.hasArg(options::OPT_fclangir))
5029 CmdArgs.push_back(
"-fclangir");
5031 if (IsOpenMPDevice) {
5033 std::string NormalizedTriple =
5037 CmdArgs.push_back(
"-aux-triple");
5038 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5041 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
5042 Triple.getArch() == llvm::Triple::thumb)) {
5043 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5044 unsigned Version = 0;
5046 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
5047 if (Failure || Version < 7)
5048 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
5058 if (Triple.isSPIR() || Triple.isSPIRV())
5059 CmdArgs.push_back(
"-Wspir-compat");
5062 RewriteKind rewriteKind = RK_None;
5064 bool UnifiedLTO =
false;
5066 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5067 options::OPT_fno_unified_lto, Triple.isPS());
5069 CmdArgs.push_back(
"-funified-lto");
5083 Args.ClaimAllArgs(options::OPT_mrelax_all);
5084 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5085 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5086 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5087 switch (
C.getDefaultToolChain().getArch()) {
5088 case llvm::Triple::arm:
5089 case llvm::Triple::armeb:
5090 case llvm::Triple::thumb:
5091 case llvm::Triple::thumbeb:
5092 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5098 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5099 Args.ClaimAllArgs(options::OPT_Xassembler);
5100 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5104 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5105 CmdArgs.push_back(
"-analyze");
5107 if (Output.
getType() == types::TY_Dependencies)
5108 CmdArgs.push_back(
"-Eonly");
5110 CmdArgs.push_back(
"-E");
5111 if (Args.hasArg(options::OPT_rewrite_objc) &&
5112 !Args.hasArg(options::OPT_g_Group))
5113 CmdArgs.push_back(
"-P");
5114 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5115 CmdArgs.push_back(
"-fdirectives-only");
5118 CmdArgs.push_back(
"-emit-obj");
5123 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5125 if (JA.
getType() == types::TY_Nothing)
5126 CmdArgs.push_back(
"-fsyntax-only");
5127 else if (JA.
getType() == types::TY_ModuleFile)
5128 CmdArgs.push_back(
"-emit-module-interface");
5129 else if (JA.
getType() == types::TY_HeaderUnit)
5130 CmdArgs.push_back(
"-emit-header-unit");
5131 else if (!Args.hasArg(options::OPT_ignore_pch))
5132 CmdArgs.push_back(
"-emit-pch");
5134 CmdArgs.push_back(
"-verify-pch");
5136 assert(JA.
getType() == types::TY_API_INFO &&
5137 "Extract API actions must generate a API information.");
5138 CmdArgs.push_back(
"-extract-api");
5140 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5141 PrettySGFArg->render(Args, CmdArgs);
5143 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5145 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5146 ProductNameArg->render(Args, CmdArgs);
5147 if (Arg *ExtractAPIIgnoresFileArg =
5148 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5149 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5150 if (Arg *EmitExtensionSymbolGraphs =
5151 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5152 if (!SymbolGraphDirArg)
5153 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5155 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5157 if (SymbolGraphDirArg)
5158 SymbolGraphDirArg->render(Args, CmdArgs);
5161 "Invalid action for clang tool.");
5162 if (JA.
getType() == types::TY_Nothing) {
5163 CmdArgs.push_back(
"-fsyntax-only");
5164 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5165 JA.
getType() == types::TY_LTO_IR) {
5166 CmdArgs.push_back(
"-emit-llvm");
5167 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5168 JA.
getType() == types::TY_LTO_BC) {
5170 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5171 Args.hasArg(options::OPT_emit_llvm)) {
5172 CmdArgs.push_back(
"-emit-llvm");
5174 CmdArgs.push_back(
"-emit-llvm-bc");
5176 }
else if (JA.
getType() == types::TY_IFS ||
5177 JA.
getType() == types::TY_IFS_CPP) {
5179 Args.hasArg(options::OPT_interface_stub_version_EQ)
5180 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5182 CmdArgs.push_back(
"-emit-interface-stubs");
5184 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5185 }
else if (JA.
getType() == types::TY_PP_Asm) {
5186 CmdArgs.push_back(
"-S");
5187 }
else if (JA.
getType() == types::TY_AST) {
5188 if (!Args.hasArg(options::OPT_ignore_pch))
5189 CmdArgs.push_back(
"-emit-pch");
5190 }
else if (JA.
getType() == types::TY_ModuleFile) {
5191 CmdArgs.push_back(
"-module-file-info");
5192 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5193 CmdArgs.push_back(
"-rewrite-objc");
5194 rewriteKind = RK_NonFragile;
5195 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5196 CmdArgs.push_back(
"-rewrite-objc");
5197 rewriteKind = RK_Fragile;
5198 }
else if (JA.
getType() == types::TY_CIR) {
5199 CmdArgs.push_back(
"-emit-cir");
5201 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5208 if (JA.
getType() == types::TY_LLVM_BC)
5209 CmdArgs.push_back(
"-emit-llvm-uselists");
5213 !Args.hasFlag(options::OPT_offload_new_driver,
5214 options::OPT_no_offload_new_driver,
5216 !Triple.isAMDGPU()) {
5217 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5218 << Args.getLastArg(options::OPT_foffload_lto,
5219 options::OPT_foffload_lto_EQ)
5221 << Triple.getTriple();
5222 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5224 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5225 << Args.getLastArg(options::OPT_foffload_lto,
5226 options::OPT_foffload_lto_EQ)
5231 CmdArgs.push_back(Args.MakeArgString(
5232 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5235 if (!RawTriple.isPS4() ||
5237 CmdArgs.push_back(
"-flto-unit");
5242 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5244 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5246 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5247 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5251 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5252 options::OPT_mno_regnames);
5254 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5255 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5257 if (Args.getLastArg(options::OPT_save_temps_EQ))
5258 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5260 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5261 options::OPT_fmemory_profile_EQ,
5262 options::OPT_fno_memory_profile);
5264 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5265 MemProfArg->render(Args, CmdArgs);
5267 if (
auto *MemProfUseArg =
5268 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5270 D.
Diag(diag::err_drv_argument_not_allowed_with)
5271 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5272 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5273 options::OPT_fprofile_generate_EQ))
5274 D.
Diag(diag::err_drv_argument_not_allowed_with)
5275 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5276 MemProfUseArg->render(Args, CmdArgs);
5281 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5284 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5286 CmdArgs.push_back(
"-disable-llvm-passes");
5293 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5294 options::OPT_mkernel,
5295 options::OPT_fapple_kext,
5296 options::OPT_ffunction_sections,
5297 options::OPT_fno_function_sections,
5298 options::OPT_fdata_sections,
5299 options::OPT_fno_data_sections,
5300 options::OPT_fbasic_block_sections_EQ,
5301 options::OPT_funique_internal_linkage_names,
5302 options::OPT_fno_unique_internal_linkage_names,
5303 options::OPT_funique_section_names,
5304 options::OPT_fno_unique_section_names,
5305 options::OPT_funique_basic_block_section_names,
5306 options::OPT_fno_unique_basic_block_section_names,
5307 options::OPT_mrestrict_it,
5308 options::OPT_mno_restrict_it,
5309 options::OPT_mstackrealign,
5310 options::OPT_mno_stackrealign,
5311 options::OPT_mstack_alignment,
5312 options::OPT_mcmodel_EQ,
5313 options::OPT_mlong_calls,
5314 options::OPT_mno_long_calls,
5315 options::OPT_ggnu_pubnames,
5316 options::OPT_gdwarf_aranges,
5317 options::OPT_fdebug_types_section,
5318 options::OPT_fno_debug_types_section,
5319 options::OPT_fdwarf_directory_asm,
5320 options::OPT_fno_dwarf_directory_asm,
5321 options::OPT_mrelax_all,
5322 options::OPT_mno_relax_all,
5323 options::OPT_ftrap_function_EQ,
5324 options::OPT_ffixed_r9,
5325 options::OPT_mfix_cortex_a53_835769,
5326 options::OPT_mno_fix_cortex_a53_835769,
5327 options::OPT_ffixed_x18,
5328 options::OPT_mglobal_merge,
5329 options::OPT_mno_global_merge,
5330 options::OPT_mred_zone,
5331 options::OPT_mno_red_zone,
5332 options::OPT_Wa_COMMA,
5333 options::OPT_Xassembler,
5337 for (
const auto &A : Args)
5338 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5339 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5342 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5343 options::OPT_fno_optimize_sibling_calls);
5351 case llvm::Triple::arm:
5352 case llvm::Triple::armeb:
5353 case llvm::Triple::thumbeb:
5354 RenderARMABI(D, Triple, Args, CmdArgs);
5356 case llvm::Triple::aarch64:
5357 case llvm::Triple::aarch64_32:
5358 case llvm::Triple::aarch64_be:
5359 RenderAArch64ABI(Triple, Args, CmdArgs);
5364 if (Output.
getType() == types::TY_Dependencies) {
5367 CmdArgs.push_back(
"-o");
5370 assert(Output.
isNothing() &&
"Input output.");
5373 for (
const auto &II : Inputs) {
5375 if (II.isFilename())
5376 CmdArgs.push_back(II.getFilename());
5378 II.getInputArg().renderAsInput(Args, CmdArgs);
5381 C.addCommand(std::make_unique<Command>(
5387 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5388 CmdArgs.push_back(
"-fembed-bitcode=marker");
5393 if (!
C.isForDiagnostics())
5394 CmdArgs.push_back(
"-disable-free");
5395 CmdArgs.push_back(
"-clear-ast-before-backend");
5398 const bool IsAssertBuild =
false;
5400 const bool IsAssertBuild =
true;
5405 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5406 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5407 CmdArgs.push_back(
"-disable-llvm-verifier");
5411 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5412 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5413 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5415 return types::isLLVMIR(II.getType());
5417 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5419 CmdArgs.push_back(
"-discard-value-names");
5424 CmdArgs.push_back(
"-main-file-name");
5429 if (Args.hasArg(options::OPT_static))
5430 CmdArgs.push_back(
"-static-define");
5432 Args.AddLastArg(CmdArgs, options::OPT_static_libclosure);
5434 if (Args.hasArg(options::OPT_municode))
5435 CmdArgs.push_back(
"-DUNICODE");
5442 CmdArgs.push_back(
"-setup-static-analyzer");
5447 bool FoundAnalyzerConfig =
false;
5448 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5449 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5450 FoundAnalyzerConfig =
true;
5453 if (!FoundAnalyzerConfig)
5454 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5455 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5456 FoundAnalyzerConfig =
true;
5459 if (FoundAnalyzerConfig)
5460 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5465 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5466 if (FunctionAlignment) {
5467 CmdArgs.push_back(
"-function-alignment");
5468 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5473 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5475 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5477 << A->getAsString(Args) << A->getValue();
5479 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5480 << A->getAsString(Args) << A->getValue();
5483 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5484 Twine(std::min(
Value, 65536u))));
5487 if (Triple.isOSzOS()) {
5496 auto findMacroDefinition = [&](
const std::string &
Macro) {
5497 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5498 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5499 return M ==
Macro || M.find(
Macro +
'=') != std::string::npos;
5504 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5505 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5507 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5508 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5511 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5512 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5516 llvm::Reloc::Model RelocationModel;
5519 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5520 Arg *LastPICDataRelArg =
5521 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5522 options::OPT_mpic_data_is_text_relative);
5523 bool NoPICDataIsTextRelative =
false;
5524 if (LastPICDataRelArg) {
5525 if (LastPICDataRelArg->getOption().matches(
5526 options::OPT_mno_pic_data_is_text_relative)) {
5527 NoPICDataIsTextRelative =
true;
5529 D.
Diag(diag::err_drv_argument_only_allowed_with)
5530 <<
"-mno-pic-data-is-text-relative"
5533 if (!Triple.isSystemZ())
5534 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5535 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5536 :
"-mpic-data-is-text-relative")
5540 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5541 RelocationModel == llvm::Reloc::ROPI_RWPI;
5542 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5543 RelocationModel == llvm::Reloc::ROPI_RWPI;
5545 if (Args.hasArg(options::OPT_mcmse) &&
5546 !Args.hasArg(options::OPT_fallow_unsupported)) {
5548 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5550 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5554 !Args.hasArg(options::OPT_fallow_unsupported))
5555 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5559 CmdArgs.push_back(
"-mrelocation-model");
5560 CmdArgs.push_back(RMName);
5563 CmdArgs.push_back(
"-pic-level");
5564 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5566 CmdArgs.push_back(
"-pic-is-pie");
5567 if (NoPICDataIsTextRelative)
5568 CmdArgs.push_back(
"-mcmodel=medium");
5571 if (RelocationModel == llvm::Reloc::ROPI ||
5572 RelocationModel == llvm::Reloc::ROPI_RWPI)
5573 CmdArgs.push_back(
"-fropi");
5574 if (RelocationModel == llvm::Reloc::RWPI ||
5575 RelocationModel == llvm::Reloc::ROPI_RWPI)
5576 CmdArgs.push_back(
"-frwpi");
5578 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5579 CmdArgs.push_back(
"-meabi");
5580 CmdArgs.push_back(A->getValue());
5594 if (Triple.isOSBinFormatELF()) {
5595 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5596 options::OPT_fno_semantic_interposition);
5597 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5599 bool SupportsLocalAlias =
5600 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5602 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5603 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5604 A->render(Args, CmdArgs);
5605 else if (!SupportsLocalAlias)
5606 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5612 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5614 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5615 << A->getValue() << A->getAsString(Args);
5616 Model = A->getValue();
5619 if (Model !=
"posix") {
5620 CmdArgs.push_back(
"-mthread-model");
5621 CmdArgs.push_back(Args.MakeArgString(Model));
5625 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5626 StringRef Name = A->getValue();
5627 if (Name ==
"SVML") {
5628 if (Triple.getArch() != llvm::Triple::x86 &&
5629 Triple.getArch() != llvm::Triple::x86_64)
5630 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5631 << Name << Triple.getArchName();
5632 }
else if (Name ==
"AMDLIBM") {
5633 if (Triple.getArch() != llvm::Triple::x86 &&
5634 Triple.getArch() != llvm::Triple::x86_64)
5635 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5636 << Name << Triple.getArchName();
5637 }
else if (Name ==
"libmvec") {
5638 if (Triple.getArch() != llvm::Triple::x86 &&
5639 Triple.getArch() != llvm::Triple::x86_64 &&
5640 Triple.getArch() != llvm::Triple::aarch64 &&
5641 Triple.getArch() != llvm::Triple::aarch64_be)
5642 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5643 << Name << Triple.getArchName();
5644 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5645 if (Triple.getArch() != llvm::Triple::aarch64 &&
5646 Triple.getArch() != llvm::Triple::aarch64_be &&
5647 Triple.getArch() != llvm::Triple::riscv64)
5648 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5649 << Name << Triple.getArchName();
5651 A->render(Args, CmdArgs);
5654 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5655 options::OPT_fno_merge_all_constants,
false))
5656 CmdArgs.push_back(
"-fmerge-all-constants");
5658 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5659 options::OPT_fno_delete_null_pointer_checks);
5663 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5664 if (!Triple.isOSAIX() || Triple.isPPC32())
5665 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5666 << A->getSpelling() << RawTriple.str();
5667 CmdArgs.push_back(
"-mabi=quadword-atomics");
5670 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5673 if (Triple.isOSAIX())
5674 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5675 << A->getSpelling() << RawTriple.str();
5678 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5679 StringRef
V = A->getValue(), V1 =
V;
5681 if (V1.consumeInteger(10, Size) || !V1.empty())
5682 D.
Diag(diag::err_drv_invalid_argument_to_option)
5683 <<
V << A->getOption().getName();
5685 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5688 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5689 options::OPT_fno_jump_tables);
5690 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5691 options::OPT_fno_profile_sample_accurate);
5692 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5693 options::OPT_fno_preserve_as_comments);
5695 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5696 CmdArgs.push_back(
"-mregparm");
5697 CmdArgs.push_back(A->getValue());
5700 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5701 options::OPT_msvr4_struct_return)) {
5703 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5704 << A->getSpelling() << RawTriple.str();
5705 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5706 CmdArgs.push_back(
"-maix-struct-return");
5708 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5709 CmdArgs.push_back(
"-msvr4-struct-return");
5713 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5714 options::OPT_freg_struct_return)) {
5715 if (TC.
getArch() != llvm::Triple::x86) {
5716 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5717 << A->getSpelling() << RawTriple.str();
5718 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5719 CmdArgs.push_back(
"-fpcc-struct-return");
5721 assert(A->getOption().matches(options::OPT_freg_struct_return));
5722 CmdArgs.push_back(
"-freg-struct-return");
5726 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5727 if (Triple.getArch() == llvm::Triple::m68k)
5728 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5730 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5733 if (Args.hasArg(options::OPT_fenable_matrix)) {
5735 CmdArgs.push_back(
"-fenable-matrix");
5736 CmdArgs.push_back(
"-mllvm");
5737 CmdArgs.push_back(
"-enable-matrix");
5742 const char *FPKeepKindStr =
nullptr;
5743 switch (FPKeepKind) {
5745 FPKeepKindStr =
"-mframe-pointer=none";
5748 FPKeepKindStr =
"-mframe-pointer=reserved";
5751 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5754 FPKeepKindStr =
"-mframe-pointer=all";
5757 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5758 CmdArgs.push_back(FPKeepKindStr);
5760 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5761 options::OPT_fno_zero_initialized_in_bss);
5765 D.
Diag(diag::warn_drv_deprecated_arg_ofast);
5768 OptSpecifier StrictAliasingAliasOption =
5769 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5772 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5773 options::OPT_fno_strict_aliasing,
5774 !IsWindowsMSVC && !IsUEFI))
5775 CmdArgs.push_back(
"-relaxed-aliasing");
5776 if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
5778 CmdArgs.push_back(
"-no-pointer-tbaa");
5779 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5780 options::OPT_fno_struct_path_tbaa,
true))
5781 CmdArgs.push_back(
"-no-struct-path-tbaa");
5782 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5783 options::OPT_fno_strict_enums);
5784 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5785 options::OPT_fno_strict_return);
5786 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5787 options::OPT_fno_allow_editor_placeholders);
5788 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5789 options::OPT_fno_strict_vtable_pointers);
5790 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5791 options::OPT_fno_force_emit_vtables);
5792 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5793 options::OPT_fno_optimize_sibling_calls);
5794 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5795 options::OPT_fno_escaping_block_tail_calls);
5797 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5798 options::OPT_fno_fine_grained_bitfield_accesses);
5800 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5801 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5803 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5804 options::OPT_fno_experimental_omit_vtable_rtti);
5806 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
5807 options::OPT_fno_disable_block_signature_string);
5810 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5811 options::OPT_fno_split_stack);
5814 if (Args.hasFlag(options::OPT_fprotect_parens,
5815 options::OPT_fno_protect_parens,
false))
5816 CmdArgs.push_back(
"-fprotect-parens");
5820 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_remote_memory,
5821 options::OPT_fno_atomic_remote_memory);
5822 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_fine_grained_memory,
5823 options::OPT_fno_atomic_fine_grained_memory);
5824 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_ignore_denormal_mode,
5825 options::OPT_fno_atomic_ignore_denormal_mode);
5827 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5829 if (
Arch == llvm::Triple::x86 ||
Arch == llvm::Triple::x86_64) {
5830 StringRef
V = A->getValue();
5832 CmdArgs.push_back(
"-fextend-arguments=64");
5834 D.
Diag(diag::err_drv_invalid_argument_to_option)
5835 << A->getValue() << A->getOption().getName();
5837 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5838 << A->getOption().getName() << TripleStr;
5841 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5842 if (TC.
getArch() == llvm::Triple::avr)
5843 A->render(Args, CmdArgs);
5845 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5846 << A->getAsString(Args) << TripleStr;
5849 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5851 A->render(Args, CmdArgs);
5853 (A->getOption().getID() != options::OPT_mlong_double_80))
5854 A->render(Args, CmdArgs);
5856 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5857 << A->getAsString(Args) << TripleStr;
5863 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5864 IsIntegratedAssemblerDefault))
5865 CmdArgs.push_back(
"-fno-verbose-asm");
5869 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5870 StringRef
V = A->getValue();
5873 A->render(Args, CmdArgs);
5874 else if (!
V.consumeInteger(10,
Num) &&
Num > 0 &&
5875 (
V.empty() || (
V.consume_front(
".") &&
5876 !
V.consumeInteger(10,
Num) &&
V.empty())))
5877 A->render(Args, CmdArgs);
5879 D.
Diag(diag::err_drv_invalid_argument_to_option)
5880 << A->getValue() << A->getOption().getName();
5886 CmdArgs.push_back(
"-no-integrated-as");
5888 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5889 CmdArgs.push_back(
"-mdebug-pass");
5890 CmdArgs.push_back(
"Structure");
5892 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5893 CmdArgs.push_back(
"-mdebug-pass");
5894 CmdArgs.push_back(
"Arguments");
5900 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5901 CmdArgs.push_back(
"-mconstructor-aliases");
5905 if (KernelOrKext && RawTriple.isOSDarwin())
5906 CmdArgs.push_back(
"-fforbid-guard-variables");
5908 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5909 Triple.isWindowsGNUEnvironment())) {
5910 CmdArgs.push_back(
"-mms-bitfields");
5913 if (Triple.isOSCygMing()) {
5914 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5915 options::OPT_fno_auto_import);
5918 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5919 Triple.isX86() && IsWindowsMSVC))
5920 CmdArgs.push_back(
"-fms-volatile");
5925 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5926 options::OPT_fno_direct_access_external_data)) {
5927 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5929 A->render(Args, CmdArgs);
5930 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
5933 CmdArgs.push_back(
"-fno-direct-access-external-data");
5936 if (Triple.isOSBinFormatELF() && (Triple.isAArch64() || Triple.isX86()))
5937 Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);
5943 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5946 CmdArgs.push_back(
"-ffreestanding");
5948 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5951 Args.AddLastArg(CmdArgs,
5952 options::OPT_fallow_runtime_check_skip_hot_cutoff_EQ);
5957 bool IsAsyncUnwindTablesDefault =
5959 bool IsSyncUnwindTablesDefault =
5962 bool AsyncUnwindTables = Args.hasFlag(
5963 options::OPT_fasynchronous_unwind_tables,
5964 options::OPT_fno_asynchronous_unwind_tables,
5965 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5968 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5969 IsSyncUnwindTablesDefault && !Freestanding);
5970 if (AsyncUnwindTables)
5971 CmdArgs.push_back(
"-funwind-tables=2");
5972 else if (UnwindTables)
5973 CmdArgs.push_back(
"-funwind-tables=1");
5977 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5978 (IsCudaDevice || IsHIPDevice || IsSYCLDevice)) {
5979 const ArgList &HostArgs =
5981 std::string HostCPU =
5983 if (!HostCPU.empty()) {
5984 CmdArgs.push_back(
"-aux-target-cpu");
5985 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5993 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
5995 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5996 StringRef
Value = A->getValue();
5997 unsigned TLSSize = 0;
5998 Value.getAsInteger(10, TLSSize);
5999 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
6000 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6001 << A->getOption().getName() << TripleStr;
6002 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
6003 D.
Diag(diag::err_drv_invalid_int_value)
6004 << A->getOption().getName() <<
Value;
6005 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6009 CmdArgs.push_back(
"-enable-tlsdesc");
6012 std::string CPU =
getCPUName(D, Args, Triple,
false);
6014 CmdArgs.push_back(
"-target-cpu");
6015 CmdArgs.push_back(Args.MakeArgString(CPU));
6018 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6023 AddClangCLArgs(Args, InputType, CmdArgs);
6025 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6026 llvm::codegenoptions::NoDebugInfo;
6029 DebugInfoKind, DwarfFission);
6040 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6041 CmdArgs.push_back(
"-split-dwarf-file");
6042 CmdArgs.push_back(SplitDWARFOut);
6044 CmdArgs.push_back(
"-split-dwarf-output");
6045 CmdArgs.push_back(SplitDWARFOut);
6050 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6051 CmdArgs.push_back(
"-target-linker-version");
6052 CmdArgs.push_back(A->getValue());
6057 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6059 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6060 TC.
getArch() == llvm::Triple::x86) {
6061 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6062 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6063 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6064 << Unsupported->getOption().getName();
6067 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6068 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6069 << Unsupported->getOption().getName()
6070 <<
"please use -maltivec and include altivec.h explicitly";
6071 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6072 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6073 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6076 Args.AddAllArgs(CmdArgs, options::OPT_v);
6078 if (Args.getLastArg(options::OPT_H)) {
6079 CmdArgs.push_back(
"-H");
6080 CmdArgs.push_back(
"-sys-header-deps");
6082 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6085 CmdArgs.push_back(
"-header-include-file");
6089 CmdArgs.push_back(
"-sys-header-deps");
6090 CmdArgs.push_back(Args.MakeArgString(
6091 "-header-include-format=" +
6094 Args.MakeArgString(
"-header-include-filtering=" +
6098 Args.AddLastArg(CmdArgs, options::OPT_P);
6099 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6102 CmdArgs.push_back(
"-diagnostic-log-file");
6111 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6115 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6116 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6117 CmdArgs.push_back(
"-mllvm");
6118 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6123 if (Args.hasFlag(options::OPT_ffunction_sections,
6124 options::OPT_fno_function_sections, UseSeparateSections)) {
6125 CmdArgs.push_back(
"-ffunction-sections");
6128 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6129 options::OPT_fno_basic_block_address_map)) {
6130 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6131 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6132 A->render(Args, CmdArgs);
6134 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6135 << A->getAsString(Args) << TripleStr;
6139 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6140 StringRef Val = A->getValue();
6141 if (Val ==
"labels") {
6142 D.
Diag(diag::warn_drv_deprecated_arg)
6143 << A->getAsString(Args) <<
true
6144 <<
"-fbasic-block-address-map";
6145 CmdArgs.push_back(
"-fbasic-block-address-map");
6146 }
else if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6147 if (Val !=
"all" && Val !=
"none" && !Val.starts_with(
"list="))
6148 D.
Diag(diag::err_drv_invalid_value)
6149 << A->getAsString(Args) << A->getValue();
6151 A->render(Args, CmdArgs);
6152 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6155 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6156 D.
Diag(diag::err_drv_invalid_value)
6157 << A->getAsString(Args) << A->getValue();
6159 A->render(Args, CmdArgs);
6160 }
else if (Triple.isNVPTX()) {
6163 }
else if (Val !=
"none") {
6166 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6167 << A->getAsString(Args) << TripleStr;
6171 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6172 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6173 UseSeparateSections || HasDefaultDataSections)) {
6174 CmdArgs.push_back(
"-fdata-sections");
6177 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6178 options::OPT_fno_unique_section_names);
6179 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6180 options::OPT_fno_separate_named_sections);
6181 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6182 options::OPT_fno_unique_internal_linkage_names);
6183 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6184 options::OPT_fno_unique_basic_block_section_names);
6186 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6187 options::OPT_fno_split_machine_functions)) {
6188 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6190 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6191 A->render(Args, CmdArgs);
6193 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6194 << A->getAsString(Args) << TripleStr;
6198 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6199 options::OPT_finstrument_functions_after_inlining,
6200 options::OPT_finstrument_function_entry_bare);
6201 Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6202 options::OPT_fno_convergent_functions);
6205 if (!Triple.isNVPTX())
6208 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6211 Args.hasFlag(options::OPT_fsample_profile_use_profi,
6212 options::OPT_fno_sample_profile_use_profi,
true)) {
6213 CmdArgs.push_back(
"-mllvm");
6214 CmdArgs.push_back(
"-sample-profile-use-profi");
6218 if (RawTriple.isPS() &&
6219 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6225 if (Args.hasArg(options::OPT_nostdinc)) {
6226 CmdArgs.push_back(
"-nostdsysteminc");
6227 CmdArgs.push_back(
"-nobuiltininc");
6229 if (Args.hasArg(options::OPT_nostdlibinc))
6230 CmdArgs.push_back(
"-nostdsysteminc");
6231 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6232 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6236 CmdArgs.push_back(
"-resource-dir");
6239 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6246 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6252 Args.ClaimAllArgs(options::OPT_D);
6256 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6257 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6262 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6263 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6269 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6272 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6274 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6275 unsigned WarningNumber;
6276 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6277 D.
Diag(diag::err_drv_invalid_int_value)
6278 << A->getAsString(Args) << A->getValue();
6283 CmdArgs.push_back(Args.MakeArgString(
6288 A->render(Args, CmdArgs);
6291 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6293 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6294 CmdArgs.push_back(
"-pedantic");
6295 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6296 Args.AddLastArg(CmdArgs, options::OPT_w);
6298 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6299 options::OPT_fno_fixed_point);
6301 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6302 A->render(Args, CmdArgs);
6304 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6305 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6307 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6308 options::OPT_fno_experimental_omit_vtable_rtti);
6310 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6311 A->render(Args, CmdArgs);
6318 bool ImplyVCPPCVer =
false;
6319 bool ImplyVCPPCXXVer =
false;
6320 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6322 if (Std->getOption().matches(options::OPT_ansi))
6324 CmdArgs.push_back(
"-std=c++98");
6326 CmdArgs.push_back(
"-std=c89");
6328 Std->render(Args, CmdArgs);
6331 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6332 options::OPT_ftrigraphs,
6333 options::OPT_fno_trigraphs))
6335 A->render(Args, CmdArgs);
6344 if (!Args.hasArg(options::OPT__SLASH_std)) {
6345 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6348 ImplyVCPPCVer =
true;
6350 else if (IsWindowsMSVC)
6351 ImplyVCPPCXXVer =
true;
6353 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6354 options::OPT_fno_trigraphs);
6370 Args.getLastArg(options::OPT_Wwrite_strings,
6371 options::OPT_Wno_write_strings, options::OPT_w);
6373 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6374 CmdArgs.push_back(
"-fconst-strings");
6381 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6383 CmdArgs.push_back(
"-fdeprecated-macro");
6387 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6388 if (
Asm->getOption().matches(options::OPT_fasm))
6389 CmdArgs.push_back(
"-fgnu-keywords");
6391 CmdArgs.push_back(
"-fno-gnu-keywords");
6395 CmdArgs.push_back(
"-fno-autolink");
6397 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6398 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6399 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6400 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6402 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6404 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6405 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6407 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6408 CmdArgs.push_back(
"-fbracket-depth");
6409 CmdArgs.push_back(A->getValue());
6412 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6413 options::OPT_Wlarge_by_value_copy_def)) {
6414 if (A->getNumValues()) {
6415 StringRef
bytes = A->getValue();
6416 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6418 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6421 if (Args.hasArg(options::OPT_relocatable_pch))
6422 CmdArgs.push_back(
"-relocatable-pch");
6424 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6425 static const char *kCFABIs[] = {
6426 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6429 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6430 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6432 A->render(Args, CmdArgs);
6435 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6436 CmdArgs.push_back(
"-fconstant-string-class");
6437 CmdArgs.push_back(A->getValue());
6440 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6441 CmdArgs.push_back(
"-ftabstop");
6442 CmdArgs.push_back(A->getValue());
6445 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6446 options::OPT_fno_stack_size_section);
6448 if (Args.hasArg(options::OPT_fstack_usage)) {
6449 CmdArgs.push_back(
"-stack-usage-file");
6451 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6453 llvm::sys::path::replace_extension(OutputFilename,
"su");
6454 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6460 CmdArgs.push_back(
"-ferror-limit");
6461 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6462 CmdArgs.push_back(A->getValue());
6464 CmdArgs.push_back(
"19");
6466 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6467 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6468 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6469 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6470 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6473 unsigned MessageLength = 0;
6474 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6475 StringRef
V(A->getValue());
6476 if (
V.getAsInteger(0, MessageLength))
6477 D.
Diag(diag::err_drv_invalid_argument_to_option)
6478 <<
V << A->getOption().getName();
6482 MessageLength = llvm::sys::Process::StandardErrColumns();
6484 if (MessageLength != 0)
6486 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6488 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6490 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6492 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6493 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6494 Twine(A->getValue(0))));
6497 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6498 options::OPT_fvisibility_ms_compat)) {
6499 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6500 A->render(Args, CmdArgs);
6502 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6503 CmdArgs.push_back(
"-fvisibility=hidden");
6504 CmdArgs.push_back(
"-ftype-visibility=default");
6506 }
else if (IsOpenMPDevice) {
6510 CmdArgs.push_back(
"-fvisibility=protected");
6514 if (!RawTriple.isPS()) {
6516 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6517 options::OPT_fno_visibility_from_dllstorageclass)) {
6518 if (A->getOption().matches(
6519 options::OPT_fvisibility_from_dllstorageclass)) {
6520 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6521 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6522 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6523 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6524 Args.AddLastArg(CmdArgs,
6525 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6530 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6531 options::OPT_fno_visibility_inlines_hidden,
false))
6532 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6534 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6535 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6540 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6541 D.
Diag(diag::warn_drv_deprecated_arg)
6542 << A->getAsString(Args) <<
true
6543 <<
"-fvisibility-global-new-delete=force-hidden";
6547 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6548 options::OPT_fvisibility_global_new_delete_hidden)) {
6549 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6550 A->render(Args, CmdArgs);
6552 assert(A->getOption().matches(
6553 options::OPT_fvisibility_global_new_delete_hidden));
6554 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6558 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6560 if (Args.hasFlag(options::OPT_fnew_infallible,
6561 options::OPT_fno_new_infallible,
false))
6562 CmdArgs.push_back(
"-fnew-infallible");
6564 if (Args.hasFlag(options::OPT_fno_operator_names,
6565 options::OPT_foperator_names,
false))
6566 CmdArgs.push_back(
"-fno-operator-names");
6569 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6570 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6571 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6572 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6573 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
6574 options::OPT_fno_raw_string_literals);
6576 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6577 Triple.hasDefaultEmulatedTLS()))
6578 CmdArgs.push_back(
"-femulated-tls");
6580 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6581 options::OPT_fno_check_new);
6583 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6587 if (!Triple.isX86() && !Triple.isAArch64())
6588 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6589 << A->getAsString(Args) << TripleStr;
6594 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6596 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6597 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6601 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6602 options::OPT_fno_openmp,
false) &&
6603 !Args.hasFlag(options::OPT_foffload_via_llvm,
6604 options::OPT_fno_offload_via_llvm,
false) &&
6611 CmdArgs.push_back(
"-fopenmp");
6616 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6617 options::OPT_fnoopenmp_use_tls,
true))
6618 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6619 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6620 options::OPT_fno_openmp_simd);
6621 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6622 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6623 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6624 options::OPT_fno_openmp_extensions,
true))
6625 CmdArgs.push_back(
"-fno-openmp-extensions");
6626 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6627 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6628 Args.AddAllArgs(CmdArgs,
6629 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6630 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6631 options::OPT_fno_openmp_optimistic_collapse,
6633 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6637 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6638 options::OPT_fno_openmp_cuda_mode,
false))
6639 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6642 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6643 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6644 options::OPT_fno_openmp_target_debug,
false))
6645 CmdArgs.push_back(
"-fopenmp-target-debug");
6649 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6650 options::OPT_fno_openmp_assume_teams_oversubscription,
6652 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6653 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6654 options::OPT_fno_openmp_assume_threads_oversubscription,
6656 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6657 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6658 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6659 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6660 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6661 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6662 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6663 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6664 CmdArgs.push_back(
"-fopenmp-force-usm");
6676 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6677 options::OPT_fno_openmp_simd);
6678 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6679 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6680 options::OPT_fno_openmp_extensions);
6685 if (Args.hasFlag(options::OPT_foffload_via_llvm,
6686 options::OPT_fno_offload_via_llvm,
false)) {
6687 CmdArgs.append({
"--offload-new-driver",
"-foffload-via-llvm"});
6688 }
else if (Args.hasFlag(options::OPT_offload_new_driver,
6689 options::OPT_no_offload_new_driver,
6691 CmdArgs.push_back(
"--offload-new-driver");
6695 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6697 for (
const auto &Filename :
6698 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6699 if (D.
getVFS().exists(Filename))
6700 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" + Filename));
6702 D.
Diag(clang::diag::err_drv_no_such_file) << Filename;
6705 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6706 StringRef S0 = A->getValue(), S = S0;
6707 unsigned Size, Offset = 0;
6708 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6710 !(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||
6711 Triple.getArch() == llvm::Triple::ppc64 ||
6712 Triple.getArch() == llvm::Triple::ppc64le)))
6713 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6714 << A->getAsString(Args) << TripleStr;
6715 else if (S.consumeInteger(10, Size) ||
6717 (!S.consume_front(
",") || S.consumeInteger(10, Offset))) ||
6718 (!S.empty() && (!S.consume_front(
",") || S.empty())))
6719 D.
Diag(diag::err_drv_invalid_argument_to_option)
6720 << S0 << A->getOption().getName();
6721 else if (Size < Offset)
6722 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6724 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6725 CmdArgs.push_back(Args.MakeArgString(
6726 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6729 Args.MakeArgString(
"-fpatchable-function-entry-section=" + S));
6733 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6735 if (Args.hasArg(options::OPT_fms_secure_hotpatch_functions_file))
6736 Args.AddLastArg(CmdArgs, options::OPT_fms_secure_hotpatch_functions_file);
6738 for (
const auto &A :
6739 Args.getAllArgValues(options::OPT_fms_secure_hotpatch_functions_list))
6741 Args.MakeArgString(
"-fms-secure-hotpatch-functions-list=" + Twine(A)));
6744 Args.AddLastArg(CmdArgs, options::OPT_pg);
6747 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6748 if (
Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6749 A->render(Args, CmdArgs);
6751 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6752 << A->getAsString(Args) << TripleStr;
6754 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6755 if (
Arch == llvm::Triple::systemz)
6756 A->render(Args, CmdArgs);
6758 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6759 << A->getAsString(Args) << TripleStr;
6761 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6762 if (
Arch == llvm::Triple::systemz)
6763 A->render(Args, CmdArgs);
6765 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6766 << A->getAsString(Args) << TripleStr;
6770 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6772 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6773 << A->getAsString(Args) << TripleStr;
6776 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6778 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6779 << A->getAsString(Args) << TripleStr;
6782 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6783 if (A->getOption().matches(options::OPT_p)) {
6785 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6786 CmdArgs.push_back(
"-pg");
6792 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6793 options::OPT_mxcoff_build_id_EQ)) {
6794 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6795 << A->getSpelling() << TripleStr;
6799 if (Args.getLastArg(options::OPT_fapple_kext) ||
6800 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6801 CmdArgs.push_back(
"-fapple-kext");
6803 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6804 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6805 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6806 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6807 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6808 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6809 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6810 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_json);
6811 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6812 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6813 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6815 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
6816 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
6817 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6818 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
6821 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6822 CmdArgs.push_back(
"-ftrapv-handler");
6823 CmdArgs.push_back(A->getValue());
6826 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6832 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6833 options::OPT_fno_finite_loops);
6835 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6836 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6837 options::OPT_fno_unroll_loops);
6838 Args.AddLastArg(CmdArgs, options::OPT_floop_interchange,
6839 options::OPT_fno_loop_interchange);
6840 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_loop_fusion,
6841 options::OPT_fno_experimental_loop_fusion);
6843 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6845 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6847 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6848 options::OPT_mno_speculative_load_hardening);
6854 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6856 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6857 options::OPT_mno_stackrealign);
6859 if (
const Arg *A = Args.getLastArg(options::OPT_mstack_alignment)) {
6860 StringRef
Value = A->getValue();
6861 int64_t Alignment = 0;
6862 if (
Value.getAsInteger(10, Alignment) || Alignment < 0)
6863 D.
Diag(diag::err_drv_invalid_argument_to_option)
6864 <<
Value << A->getOption().getName();
6865 else if (Alignment & (Alignment - 1))
6866 D.
Diag(diag::err_drv_alignment_not_power_of_two)
6867 << A->getAsString(Args) <<
Value;
6869 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" +
Value));
6872 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6873 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6876 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6878 CmdArgs.push_back(
"-mstack-probe-size=0");
6881 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6882 options::OPT_mno_stack_arg_probe);
6884 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6885 options::OPT_mno_restrict_it)) {
6886 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6887 CmdArgs.push_back(
"-mllvm");
6888 CmdArgs.push_back(
"-arm-restrict-it");
6890 CmdArgs.push_back(
"-mllvm");
6891 CmdArgs.push_back(
"-arm-default-it");
6905 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6906 options::OPT_fno_hip_new_launch_api,
true))
6907 CmdArgs.push_back(
"-fhip-new-launch-api");
6908 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6909 options::OPT_fno_gpu_allow_device_init);
6910 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6911 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6912 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6913 options::OPT_fno_hip_kernel_arg_name);
6916 if (IsCuda || IsHIP) {
6918 CmdArgs.push_back(
"-fgpu-rdc");
6919 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6920 options::OPT_fno_gpu_defer_diag);
6921 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6922 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6924 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6925 CmdArgs.push_back(
"-fgpu-defer-diag");
6930 if (!Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
true))
6931 CmdArgs.push_back(
"--no-offloadlib");
6933 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6935 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
6937 if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
6938 CmdArgs.push_back(Args.MakeArgString(Twine(
"-mcf-branch-label-scheme=") +
6940 }
else if (Triple.isOSOpenBSD() && Triple.getArch() == llvm::Triple::x86_64) {
6942 CmdArgs.push_back(
"-fcf-protection=branch");
6944 CmdArgs.push_back(
"-fno-jump-tables");
6947 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6949 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
6951 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6956 if (!(IsCudaDevice || IsHIPDevice)) {
6958 auto *PGOArg = Args.getLastArg(
6959 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
6960 options::OPT_fcs_profile_generate,
6961 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
6962 options::OPT_fprofile_use_EQ);
6964 D.
Diag(diag::err_drv_argument_not_allowed_with)
6965 <<
"SampleUse with PGO options";
6967 StringRef fname = A->getValue();
6968 if (!llvm::sys::fs::exists(fname))
6969 D.
Diag(diag::err_drv_no_such_file) << fname;
6971 A->render(Args, CmdArgs);
6973 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6975 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6976 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
6977 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
6980 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6981 options::OPT_fno_unique_internal_linkage_names,
true))
6982 CmdArgs.push_back(
"-funique-internal-linkage-names");
6987 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6988 options::OPT_fno_assume_sane_operator_new);
6990 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
6991 CmdArgs.push_back(
"-fapinotes");
6992 if (Args.hasFlag(options::OPT_fapinotes_modules,
6993 options::OPT_fno_apinotes_modules,
false))
6994 CmdArgs.push_back(
"-fapinotes-modules");
6995 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
6997 if (Args.hasFlag(options::OPT_fswift_version_independent_apinotes,
6998 options::OPT_fno_swift_version_independent_apinotes,
false))
6999 CmdArgs.push_back(
"-fswift-version-independent-apinotes");
7002 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
7004 (Args.hasArg(options::OPT_fgnu_runtime) &&
7005 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
7006 !Args.hasArg(options::OPT_fno_blocks))) {
7007 CmdArgs.push_back(
"-fblocks");
7010 CmdArgs.push_back(
"-fblocks-runtime-optional");
7015 CmdArgs.push_back(
"-fencode-extended-block-signature");
7017 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7018 options::OPT_fno_coro_aligned_allocation,
false) &&
7020 CmdArgs.push_back(
"-fcoro-aligned-allocation");
7022 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7023 options::OPT_fno_double_square_bracket_attributes);
7025 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7026 options::OPT_fno_access_control);
7027 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7028 options::OPT_fno_elide_constructors);
7034 CmdArgs.push_back(
"-fno-rtti");
7037 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7038 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
7039 CmdArgs.push_back(
"-fshort-enums");
7045 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
7046 !RawTriple.isOSAIX() &&
7047 (!RawTriple.isOSWindows() ||
7048 RawTriple.isWindowsCygwinEnvironment()) &&
7049 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
7050 RawTriple.hasEnvironment())) ||
7052 CmdArgs.push_back(
"-fno-use-cxa-atexit");
7054 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7055 options::OPT_fno_register_global_dtors_with_atexit,
7056 RawTriple.isOSDarwin() && !KernelOrKext))
7057 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7059 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7060 options::OPT_fno_use_line_directives);
7063 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7064 options::OPT_fno_minimize_whitespace,
false)) {
7065 types::ID InputType = Inputs[0].getType();
7066 if (!isDerivedFromC(InputType))
7067 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7069 CmdArgs.push_back(
"-fminimize-whitespace");
7073 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7074 options::OPT_fno_keep_system_includes,
false)) {
7075 types::ID InputType = Inputs[0].getType();
7076 if (!isDerivedFromC(InputType))
7077 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7079 CmdArgs.push_back(
"-fkeep-system-includes");
7083 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7084 IsWindowsMSVC || IsUEFI))
7085 CmdArgs.push_back(
"-fms-extensions");
7088 bool IsMSVCCompat = Args.hasFlag(
7089 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7090 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7091 options::OPT_fno_ms_extensions,
true)));
7093 CmdArgs.push_back(
"-fms-compatibility");
7095 Args.hasArg(options::OPT_fms_define_stdc))
7096 CmdArgs.push_back(
"-fms-define-stdc");
7099 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7100 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7104 VersionTuple GNUCVer;
7105 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7108 StringRef Val = A->getValue();
7109 Val = Val.empty() ?
"0" : Val;
7110 bool Invalid = GNUCVer.tryParse(Val);
7111 unsigned Minor = GNUCVer.getMinor().value_or(0);
7112 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7113 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7114 D.
Diag(diag::err_drv_invalid_value)
7115 << A->getAsString(Args) << A->getValue();
7117 }
else if (!IsMSVCCompat) {
7119 GNUCVer = VersionTuple(4, 2, 1);
7121 if (!GNUCVer.empty()) {
7123 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7129 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7131 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7132 if (ImplyVCPPCVer) {
7134 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7137 .Case(
"c11",
"-std=c11")
7138 .Case(
"c17",
"-std=c17")
7140 .Case(
"clatest",
"-std=c23")
7143 D.
Diag(clang::diag::warn_drv_unused_argument)
7144 << StdArg->getAsString(Args);
7148 if (ImplyVCPPCXXVer) {
7150 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7153 .Case(
"c++14",
"-std=c++14")
7154 .Case(
"c++17",
"-std=c++17")
7155 .Case(
"c++20",
"-std=c++20")
7157 .Case(
"c++23preview",
"-std=c++23")
7158 .Case(
"c++latest",
"-std=c++26")
7161 D.
Diag(clang::diag::warn_drv_unused_argument)
7162 << StdArg->getAsString(Args);
7166 if (IsMSVC2015Compatible)
7175 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7176 options::OPT_fno_borland_extensions);
7179 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7181 CmdArgs.push_back(
"-fdeclspec");
7182 else if (Args.hasArg(options::OPT_fno_declspec))
7183 CmdArgs.push_back(
"-fno-declspec");
7187 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7188 options::OPT_fno_threadsafe_statics,
7190 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7191 CmdArgs.push_back(
"-fno-threadsafe-statics");
7193 if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7195 CmdArgs.push_back(
"-fno-ms-tls-guards");
7198 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7200 CmdArgs.push_back(
"-fno-assumptions");
7204 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7205 options::OPT_fno_gnu_keywords);
7207 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7208 options::OPT_fno_gnu89_inline);
7210 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7211 options::OPT_finline_hint_functions,
7212 options::OPT_fno_inline_functions);
7213 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7214 if (A->getOption().matches(options::OPT_fno_inline))
7215 A->render(Args, CmdArgs);
7216 }
else if (InlineArg) {
7217 InlineArg->render(Args, CmdArgs);
7220 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7225 (Std->containsValue(
"c++2a") || Std->containsValue(
"gnu++2a") ||
7226 Std->containsValue(
"c++20") || Std->containsValue(
"gnu++20") ||
7227 Std->containsValue(
"c++2b") || Std->containsValue(
"gnu++2b") ||
7228 Std->containsValue(
"c++23") || Std->containsValue(
"gnu++23") ||
7229 Std->containsValue(
"c++2c") || Std->containsValue(
"gnu++2c") ||
7230 Std->containsValue(
"c++26") || Std->containsValue(
"gnu++26") ||
7231 Std->containsValue(
"c++latest") || Std->containsValue(
"gnu++latest"));
7246 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7247 options::OPT_fno_delayed_template_parsing,
7248 IsWindowsMSVC && !HaveCxx20)) {
7250 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7252 CmdArgs.push_back(
"-fdelayed-template-parsing");
7255 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7256 options::OPT_fno_pch_validate_input_files_content,
false))
7257 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7258 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7259 options::OPT_fno_pch_instantiate_templates,
false))
7260 CmdArgs.push_back(
"-fpch-instantiate-templates");
7261 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7263 CmdArgs.push_back(
"-fmodules-codegen");
7264 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7266 CmdArgs.push_back(
"-fmodules-debuginfo");
7268 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7273 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7274 options::OPT_fno_objc_encode_cxx_class_template_spec,
7276 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7278 if (Args.hasFlag(options::OPT_fapplication_extension,
7279 options::OPT_fno_application_extension,
false))
7280 CmdArgs.push_back(
"-fapplication-extension");
7284 if (!
C.getDriver().IsCLMode())
7285 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7288 Arg *A = Args.getLastArg(
7289 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7290 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7292 const Option &Opt = A->getOption();
7293 if (Opt.matches(options::OPT_fsjlj_exceptions))
7294 CmdArgs.push_back(
"-exception-model=sjlj");
7295 if (Opt.matches(options::OPT_fseh_exceptions))
7296 CmdArgs.push_back(
"-exception-model=seh");
7297 if (Opt.matches(options::OPT_fdwarf_exceptions))
7298 CmdArgs.push_back(
"-exception-model=dwarf");
7299 if (Opt.matches(options::OPT_fwasm_exceptions))
7300 CmdArgs.push_back(
"-exception-model=wasm");
7305 case llvm::ExceptionHandling::DwarfCFI:
7306 CmdArgs.push_back(
"-exception-model=dwarf");
7308 case llvm::ExceptionHandling::SjLj:
7309 CmdArgs.push_back(
"-exception-model=sjlj");
7311 case llvm::ExceptionHandling::WinEH:
7312 CmdArgs.push_back(
"-exception-model=seh");
7318 Args.AddLastArg(CmdArgs, options::OPT_winx64_eh_unwindv2);
7321 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7322 options::OPT_fno_assume_sane_operator_new);
7325 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7326 options::OPT_fno_assume_unique_vtables);
7330 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
7331 options::OPT_fno_sized_deallocation);
7335 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7336 options::OPT_fno_aligned_allocation,
7337 options::OPT_faligned_new_EQ)) {
7338 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7339 CmdArgs.push_back(
"-fno-aligned-allocation");
7341 CmdArgs.push_back(
"-faligned-allocation");
7346 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7347 options::OPT_faligned_new_EQ))
7349 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7353 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7354 options::OPT_fno_constant_cfstrings,
true) ||
7355 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7356 options::OPT_mno_constant_cfstrings,
true))
7357 CmdArgs.push_back(
"-fno-constant-cfstrings");
7359 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7360 options::OPT_fno_pascal_strings);
7364 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7365 std::string PackStructStr =
"-fpack-struct=";
7366 PackStructStr += A->getValue();
7367 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7368 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7369 options::OPT_fno_pack_struct,
false)) {
7370 CmdArgs.push_back(
"-fpack-struct=1");
7374 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7375 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7376 if (!SkipMaxTypeAlign) {
7377 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7378 MaxTypeAlignStr += A->getValue();
7379 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7381 }
else if (RawTriple.isOSDarwin()) {
7382 if (!SkipMaxTypeAlign) {
7383 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7384 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7388 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7389 CmdArgs.push_back(
"-Qn");
7392 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7396 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7397 options::OPT_funsigned_bitfields,
true))
7398 D.
Diag(diag::warn_drv_clang_unsupported)
7399 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7402 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7403 D.
Diag(diag::err_drv_clang_unsupported)
7404 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7407 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7408 StringRef value = inputCharset->getValue();
7409 if (!value.equals_insensitive(
"utf-8"))
7410 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7415 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7416 StringRef value = execCharset->getValue();
7417 if (!value.equals_insensitive(
"utf-8"))
7418 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7424 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7425 options::OPT_fno_asm_blocks);
7427 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7428 options::OPT_fno_gnu_inline_asm);
7434 if (!VecWidth.empty())
7435 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + VecWidth));
7437 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7438 Args.AddLastArg(CmdArgs,
7439 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7443 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7444 options::OPT_fno_dollars_in_identifiers)) {
7445 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7446 CmdArgs.push_back(
"-fdollars-in-identifiers");
7448 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7451 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7452 options::OPT_fno_apple_pragma_pack);
7458 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7459 options::OPT_fno_rewrite_imports,
false);
7461 CmdArgs.push_back(
"-frewrite-imports");
7463 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7464 options::OPT_fno_directives_only);
7470 if (Args.hasFlag(options::OPT_frewrite_includes,
7471 options::OPT_fno_rewrite_includes,
false) ||
7472 (
C.isForDiagnostics() && !HaveModules))
7473 CmdArgs.push_back(
"-frewrite-includes");
7475 if (Args.hasFlag(options::OPT_fzos_extensions,
7476 options::OPT_fno_zos_extensions,
false))
7477 CmdArgs.push_back(
"-fzos-extensions");
7478 else if (Args.hasArg(options::OPT_fno_zos_extensions))
7479 CmdArgs.push_back(
"-fno-zos-extensions");
7482 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7483 options::OPT_traditional_cpp)) {
7485 CmdArgs.push_back(
"-traditional-cpp");
7487 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7490 Args.AddLastArg(CmdArgs, options::OPT_dM);
7491 Args.AddLastArg(CmdArgs, options::OPT_dD);
7492 Args.AddLastArg(CmdArgs, options::OPT_dI);
7494 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7497 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7498 CmdArgs.push_back(
"-serialize-diagnostic-file");
7499 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7502 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7503 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7505 if (Arg *A = Args.getLastArg(options::OPT_fextend_variable_liveness_EQ)) {
7506 A->render(Args, CmdArgs);
7507 }
else if (Arg *A = Args.getLastArg(options::OPT_O_Group);
7508 A && A->containsValue(
"g")) {
7510 CmdArgs.push_back(
"-fextend-variable-liveness=all");
7514 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7516 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7519 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7520 CmdArgs.push_back(
"-load");
7521 CmdArgs.push_back(A->getValue());
7533 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7534 auto ArgValue = StringRef(A->getValue());
7535 auto FirstDashIndex = ArgValue.find(
'-');
7536 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7537 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7540 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7541 if (PluginName.empty()) {
7542 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7544 D.
Diag(diag::warn_drv_missing_plugin_arg)
7545 << PluginName << A->getAsString(Args);
7550 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7551 CmdArgs.push_back(Args.MakeArgString(Arg));
7555 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7557 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7562 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7563 CmdArgs.push_back(
"--vfsoverlay");
7564 CmdArgs.push_back(A->getValue());
7568 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7569 options::OPT_fno_safe_buffer_usage_suggestions);
7571 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7572 options::OPT_fno_experimental_late_parse_attributes);
7574 if (Args.hasFlag(options::OPT_funique_source_file_names,
7575 options::OPT_fno_unique_source_file_names,
false)) {
7576 if (Arg *A = Args.getLastArg(options::OPT_unique_source_file_identifier_EQ))
7577 A->render(Args, CmdArgs);
7579 CmdArgs.push_back(Args.MakeArgString(
7580 Twine(
"-funique-source-file-identifier=") + Input.
getBaseInput()));
7585 if (!StatsFile.empty()) {
7586 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7588 CmdArgs.push_back(
"-stats-file-append");
7593 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7597 if (
C.getDriver().isSaveTempsEnabled() &&
7599 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7602 CmdArgs.push_back(Arg->getValue());
7604 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7610 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7611 CmdArgs.push_back(
"-disable-llvm-optzns");
7613 A->render(Args, CmdArgs);
7619 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
7621 Args.AddLastArg(CmdArgs, options::OPT_falloc_token_max_EQ);
7625 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
7627 A->render(Args, CmdArgs);
7639 if ((
C.getDriver().isSaveTempsEnabled() ||
7641 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7643 CmdArgs.push_back(
"-disable-llvm-passes");
7645 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7654 auto GRecordSwitches =
false;
7655 auto FRecordSwitches =
false;
7659 CmdArgs.push_back(
"-dwarf-debug-flags");
7660 CmdArgs.push_back(FlagsArgString);
7662 if (FRecordSwitches) {
7663 CmdArgs.push_back(
"-record-command-line");
7664 CmdArgs.push_back(FlagsArgString);
7671 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7672 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7673 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7674 }
else if (!HostOffloadingInputs.empty()) {
7675 if (IsCuda && !IsRDCMode) {
7676 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7677 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7678 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7680 for (
const InputInfo Input : HostOffloadingInputs)
7681 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7687 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7688 options::OPT_fno_cuda_short_ptr,
false))
7689 CmdArgs.push_back(
"-fcuda-short-ptr");
7692 if (IsCuda || IsHIP) {
7694 const Action *SourceAction = &JA;
7696 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7697 SourceAction = SourceAction->
getInputs()[0];
7701 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7705 bool UseApproxTranscendentals = Args.hasFlag(
7706 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7707 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7708 options::OPT_fno_gpu_approx_transcendentals,
7709 UseApproxTranscendentals))
7710 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7712 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7713 options::OPT_fno_gpu_approx_transcendentals);
7717 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7718 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7721 Args.AddAllArgs(CmdArgs,
7722 options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);
7724 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7725 options::OPT_fno_offload_uniform_block);
7727 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7728 options::OPT_fno_offload_implicit_host_device_templates);
7730 if (IsCudaDevice || IsHIPDevice) {
7731 StringRef InlineThresh =
7732 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7733 if (!InlineThresh.empty()) {
7734 std::string ArgStr =
7735 std::string(
"-inline-threshold=") + InlineThresh.str();
7736 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7741 Args.addOptOutFlag(CmdArgs,
7742 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7743 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7750 if (IsOpenMPDevice) {
7751 CmdArgs.push_back(
"-fopenmp-is-target-device");
7753 if (Args.hasArg(options::OPT_foffload_via_llvm))
7754 CmdArgs.push_back(
"-fcuda-is-device");
7756 if (OpenMPDeviceInput) {
7757 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7758 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7762 if (Triple.isAMDGPU()) {
7765 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7766 options::OPT_mno_unsafe_fp_atomics);
7767 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7768 options::OPT_mno_amdgpu_ieee);
7773 bool VirtualFunctionElimination =
7774 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7775 options::OPT_fno_virtual_function_elimination,
false);
7776 if (VirtualFunctionElimination) {
7780 D.
Diag(diag::err_drv_argument_only_allowed_with)
7781 <<
"-fvirtual-function-elimination"
7784 CmdArgs.push_back(
"-fvirtual-function-elimination");
7788 bool WholeProgramVTables = Args.hasFlag(
7789 options::OPT_fwhole_program_vtables,
7790 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7791 if (VirtualFunctionElimination && !WholeProgramVTables) {
7792 D.
Diag(diag::err_drv_argument_not_allowed_with)
7793 <<
"-fno-whole-program-vtables"
7794 <<
"-fvirtual-function-elimination";
7797 if (WholeProgramVTables) {
7810 auto OtherIsUsingLTO = OtherLTOMode !=
LTOK_None;
7812 if ((!IsUsingLTO && !OtherIsUsingLTO) ||
7814 D.
Diag(diag::err_drv_argument_only_allowed_with)
7815 <<
"-fwhole-program-vtables"
7816 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7820 CmdArgs.push_back(
"-fwhole-program-vtables");
7823 bool DefaultsSplitLTOUnit =
7824 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7826 (!Triple.isPS4() && UnifiedLTO);
7828 Args.hasFlag(options::OPT_fsplit_lto_unit,
7829 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
7830 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
7831 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
7832 <<
"-fsanitize=cfi";
7834 CmdArgs.push_back(
"-fsplit-lto-unit");
7836 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7837 options::OPT_fno_fat_lto_objects)) {
7838 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
7840 if (!Triple.isOSBinFormatELF()) {
7841 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7844 CmdArgs.push_back(Args.MakeArgString(
7845 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
7846 CmdArgs.push_back(
"-flto-unit");
7847 CmdArgs.push_back(
"-ffat-lto-objects");
7848 A->render(Args, CmdArgs);
7852 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7853 options::OPT_fno_global_isel)) {
7854 CmdArgs.push_back(
"-mllvm");
7855 if (A->getOption().matches(options::OPT_fglobal_isel)) {
7856 CmdArgs.push_back(
"-global-isel=1");
7861 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
7862 bool IsOptLevelSupported =
false;
7864 Arg *A = Args.getLastArg(options::OPT_O_Group);
7865 if (Triple.getArch() == llvm::Triple::aarch64) {
7866 if (!A || A->getOption().matches(options::OPT_O0))
7867 IsOptLevelSupported =
true;
7869 if (!IsArchSupported || !IsOptLevelSupported) {
7870 CmdArgs.push_back(
"-mllvm");
7871 CmdArgs.push_back(
"-global-isel-abort=2");
7873 if (!IsArchSupported)
7874 D.
Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
7876 D.
Diag(diag::warn_drv_global_isel_incomplete_opt);
7879 CmdArgs.push_back(
"-global-isel=0");
7883 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7884 options::OPT_fno_force_enable_int128)) {
7885 if (A->getOption().matches(options::OPT_fforce_enable_int128))
7886 CmdArgs.push_back(
"-fforce-enable-int128");
7889 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7890 options::OPT_fno_keep_static_consts);
7891 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7892 options::OPT_fno_keep_persistent_storage_variables);
7893 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7894 options::OPT_fno_complete_member_pointers);
7895 if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
7896 A->render(Args, CmdArgs);
7902 if (Triple.isAArch64() &&
7903 (Args.hasArg(options::OPT_mno_fmv) ||
7904 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
7907 CmdArgs.push_back(
"-target-feature");
7908 CmdArgs.push_back(
"-fmv");
7911 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7918 CmdArgs.push_back(
"-faddrsig");
7920 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
7921 (EH || UnwindTables || AsyncUnwindTables ||
7922 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
7923 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
7925 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7926 std::string Str = A->getAsString(Args);
7928 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7930 CmdArgs.push_back(Args.MakeArgString(Str));
7935 if (Output.
getType() == types::TY_Dependencies) {
7938 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
7939 Output.
getType() == clang::driver::types::TY_IFS) {
7941 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
7942 CmdArgs.push_back(
"-o");
7943 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7945 CmdArgs.push_back(
"-o");
7949 assert(Output.
isNothing() &&
"Invalid output.");
7956 FrontendInputs = ExtractAPIInputs;
7958 FrontendInputs = {};
7960 for (
const InputInfo &Input : FrontendInputs) {
7969 C.addCommand(std::make_unique<CC1Command>(
7973 C.addCommand(std::make_unique<Command>(
7979 if (Output.
getType() == types::TY_Object &&
7980 Args.hasFlag(options::OPT__SLASH_showFilenames,
7981 options::OPT__SLASH_showFilenames_,
false)) {
7982 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
7985 if (Arg *A = Args.getLastArg(options::OPT_pg))
7987 !Args.hasArg(options::OPT_mfentry))
7988 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
7989 << A->getAsString(Args);
7995 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
7999 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8000 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8003 Args.ClaimAllArgs(options::OPT_emit_llvm);