5282 const ArgList &Args,
const char *LinkingOutput)
const {
5284 const llvm::Triple &RawTriple = TC.
getTriple();
5286 const std::string &TripleStr = Triple.getTriple();
5289 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
5291 ArgStringList CmdArgs;
5293 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
5309 bool UsesLLVMOffloading = Args.hasFlag(
5310 options::OPT_foffload_via_llvm, options::OPT_fno_offload_via_llvm,
false);
5313 bool IsHostOffloadingAction =
5319 bool IsRDCMode = Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
5331 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
5335 const InputInfo *OpenMPDeviceInput =
nullptr;
5337 if (&I == &Input || I.
getType() == types::TY_Nothing) {
5339 }
else if (IsExtractAPI) {
5340 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
5341 if (I.getType() != ExpectedInputType) {
5342 D.
Diag(diag::err_drv_extract_api_wrong_kind)
5346 ExtractAPIInputs.push_back(I);
5347 }
else if (IsHostOffloadingAction) {
5348 HostOffloadingInputs.push_back(I);
5349 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
5350 OpenMPDeviceInput = &I;
5352 llvm_unreachable(
"unexpectedly given multiple inputs");
5356 bool IsUEFI = RawTriple.isUEFI();
5357 bool IsIAMCU = RawTriple.isOSIAMCU();
5361 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
5366 CmdArgs.push_back(
"-cc1");
5369 CmdArgs.push_back(
"-triple");
5370 CmdArgs.push_back(Args.MakeArgStringRef(TripleStr));
5372 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
5376 CmdArgs.push_back(
"-aux-triple");
5377 CmdArgs.push_back(Args.MakeArgStringRef(AuxTriple->str()));
5382 IsWindowsMSVC |= AuxTriple->isWindowsMSVCEnvironment();
5389 if (OffloadToolChains.first == OffloadToolChains.second)
5392 const llvm::Triple &DeviceAuxTriple =
5393 OffloadToolChains.first->second->getTriple();
5394 CmdArgs.push_back(
"-aux-triple");
5395 CmdArgs.push_back(Args.MakeArgStringRef(DeviceAuxTriple.str()));
5400 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
5401 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
5402 Args.ClaimAllArgs(options::OPT_MJ);
5403 }
else if (
const Arg *GenCDBFragment =
5404 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
5405 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
5406 TripleStr, Output, Input, Args);
5407 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
5414 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
5415 CmdArgs.push_back(Args.MakeArgString(
5417 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
5420 Args.MakeArgStringRef(
"-Werror=format-invalid-specifier"));
5424 if (IsCuda && !IsCudaDevice && !UsesLLVMOffloading) {
5429 assert(CTC &&
"Expected valid CUDA Toolchain.");
5431 CmdArgs.push_back(Args.MakeArgString(
5432 Twine(
"-target-sdk-version=") +
5437 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5438 if (A->getOption().matches(options::OPT_O4)) {
5439 CmdArgs.push_back(
"-O3");
5440 D.
Diag(diag::warn_O4_is_O3);
5442 A->render(Args, CmdArgs);
5447 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
5453 CmdArgs.push_back(
"-fsycl-is-device");
5456 if (!Args.getLastArg(options::OPT_O_Group))
5457 CmdArgs.push_back(
"-O2");
5464 CmdArgs.push_back(
"-fsycl-is-host");
5468 Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
5470 SYCLStdArg->render(Args, CmdArgs);
5473 CmdArgs.push_back(
"-sycl-std=2020");
5477 if (Args.hasFlag(options::OPT_fclangir, options::OPT_fno_clangir,
false))
5478 CmdArgs.push_back(
"-fclangir");
5480 if (IsOpenMPDevice) {
5482 const llvm::Triple &HostTriple =
5484 CmdArgs.push_back(
"-aux-triple");
5485 CmdArgs.push_back(HostTriple.str().c_str());
5488 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
5489 Triple.getArch() == llvm::Triple::thumb)) {
5490 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5491 unsigned Version = 0;
5493 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
5495 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
5505 if (Triple.isSPIR() || Triple.isSPIRV())
5506 CmdArgs.push_back(
"-Wspir-compat");
5509 RewriteKind rewriteKind = RK_None;
5511 bool UnifiedLTO =
false;
5513 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5514 options::OPT_fno_unified_lto, Triple.isPS());
5516 CmdArgs.push_back(
"-funified-lto");
5519 if (Args.hasArg(options::OPT_fdefined_pointer_subtraction))
5520 CmdArgs.push_back(
"-fdefined-pointer-subtraction");
5533 Args.ClaimAllArgs(options::OPT_mrelax_all);
5534 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5535 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5536 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5537 switch (
C.getDefaultToolChain().getArch()) {
5538 case llvm::Triple::arm:
5539 case llvm::Triple::armeb:
5540 case llvm::Triple::thumb:
5541 case llvm::Triple::thumbeb:
5542 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5548 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5549 Args.ClaimAllArgs(options::OPT_Xassembler);
5550 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5553 bool IsAMDSPIRVForHIPDevice =
5558 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5559 CmdArgs.push_back(
"-analyze");
5561 if (Output.
getType() == types::TY_Dependencies)
5562 CmdArgs.push_back(
"-Eonly");
5564 CmdArgs.push_back(
"-E");
5565 if (Args.hasArg(options::OPT_rewrite_objc) &&
5566 !Args.hasArg(options::OPT_g_Group))
5567 CmdArgs.push_back(
"-P");
5568 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5569 CmdArgs.push_back(
"-fdirectives-only");
5572 CmdArgs.push_back(
"-emit-obj");
5577 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5579 if (JA.
getType() == types::TY_Nothing)
5580 CmdArgs.push_back(
"-fsyntax-only");
5581 else if (JA.
getType() == types::TY_ModuleFile) {
5582 if (Args.hasArg(options::OPT__precompile_reduced_bmi) ||
5583 ((Input.
getType() == types::TY_CXXStdModule ||
5584 Input.
getType() == types::TY_PP_CXXStdModule) &&
5585 !Args.hasArg(options::OPT_fno_modules_reduced_bmi)))
5586 CmdArgs.push_back(
"-emit-reduced-module-interface");
5588 CmdArgs.push_back(
"-emit-module-interface");
5589 }
else if (JA.
getType() == types::TY_HeaderUnit)
5590 CmdArgs.push_back(
"-emit-header-unit");
5591 else if (!Args.hasArg(options::OPT_ignore_pch))
5592 CmdArgs.push_back(
"-emit-pch");
5594 CmdArgs.push_back(
"-verify-pch");
5596 assert(JA.
getType() == types::TY_API_INFO &&
5597 "Extract API actions must generate a API information.");
5598 CmdArgs.push_back(
"-extract-api");
5600 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5601 PrettySGFArg->render(Args, CmdArgs);
5603 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5605 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5606 ProductNameArg->render(Args, CmdArgs);
5607 if (Arg *ExtractAPIIgnoresFileArg =
5608 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5609 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5610 if (Arg *EmitExtensionSymbolGraphs =
5611 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5612 if (!SymbolGraphDirArg)
5613 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5615 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5617 if (SymbolGraphDirArg)
5618 SymbolGraphDirArg->render(Args, CmdArgs);
5621 "Invalid action for clang tool.");
5622 if (JA.
getType() == types::TY_Nothing) {
5623 CmdArgs.push_back(
"-fsyntax-only");
5624 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5625 JA.
getType() == types::TY_LTO_IR) {
5626 CmdArgs.push_back(
"-emit-llvm");
5627 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5628 JA.
getType() == types::TY_LTO_BC) {
5630 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5631 Args.hasArg(options::OPT_emit_llvm)) {
5632 CmdArgs.push_back(
"-emit-llvm");
5634 CmdArgs.push_back(
"-emit-llvm-bc");
5636 }
else if (JA.
getType() == types::TY_IFS ||
5637 JA.
getType() == types::TY_IFS_CPP) {
5639 Args.hasArg(options::OPT_interface_stub_version_EQ)
5640 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5642 CmdArgs.push_back(
"-emit-interface-stubs");
5644 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr));
5645 }
else if (JA.
getType() == types::TY_PP_Asm) {
5646 CmdArgs.push_back(
"-S");
5647 }
else if (JA.
getType() == types::TY_AST) {
5648 if (!Args.hasArg(options::OPT_ignore_pch))
5649 CmdArgs.push_back(
"-emit-pch");
5650 }
else if (JA.
getType() == types::TY_ModuleFile) {
5651 CmdArgs.push_back(
"-module-file-info");
5652 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5653 CmdArgs.push_back(
"-rewrite-objc");
5654 rewriteKind = RK_NonFragile;
5655 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5656 CmdArgs.push_back(
"-rewrite-objc");
5657 rewriteKind = RK_Fragile;
5658 }
else if (JA.
getType() == types::TY_CIR) {
5659 CmdArgs.push_back(
"-emit-cir");
5660 }
else if (JA.
getType() == types::TY_CIRBC) {
5661 CmdArgs.push_back(
"-emit-cir-bc");
5662 }
else if (JA.
getType() == types::TY_Image && IsAMDSPIRVForHIPDevice) {
5663 CmdArgs.push_back(
"-emit-obj");
5665 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5672 if (JA.
getType() == types::TY_LLVM_BC)
5673 CmdArgs.push_back(
"-emit-llvm-uselists");
5676 const Arg *LTOArg = Args.getLastArg(options::OPT_foffload_lto,
5677 options::OPT_foffload_lto_EQ);
5678 if (Triple.isNVPTX() && !IsRDCMode &&
5680 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5681 << (LTOArg ? LTOArg->getAsString(Args) :
"-foffload-lto")
5685 CmdArgs.push_back(Args.MakeArgString(
5686 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5689 if (!RawTriple.isPS4() || (LTOMode ==
LTOK_Full) || !UnifiedLTO)
5690 CmdArgs.push_back(
"-flto-unit");
5695 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5697 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5699 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5700 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5704 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5705 options::OPT_mno_regnames);
5707 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5708 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5710 if (Args.getLastArg(options::OPT_save_temps_EQ))
5711 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5713 if (Args.getLastArg(options::OPT_save_dynamic_debugging_temps))
5714 Args.AddLastArg(CmdArgs, options::OPT_save_dynamic_debugging_temps);
5716 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5717 options::OPT_fmemory_profile_EQ,
5718 options::OPT_fno_memory_profile);
5720 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5721 MemProfArg->render(Args, CmdArgs);
5723 if (
auto *MemProfUseArg =
5724 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5726 D.
Diag(diag::err_drv_argument_not_allowed_with)
5727 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5728 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5729 options::OPT_fprofile_generate_EQ))
5730 D.
Diag(diag::err_drv_argument_not_allowed_with)
5731 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5732 MemProfUseArg->render(Args, CmdArgs);
5736 Args.getLastArg(options::OPT_fcopyprof, options::OPT_fno_copyprof);
5738 !CopyProfArg->getOption().matches(options::OPT_fno_copyprof)) {
5739 CopyProfArg->render(Args, CmdArgs);
5740 Args.AddLastArg(CmdArgs, options::OPT_fcopyprof_static_size_threshold_EQ);
5745 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5748 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5750 CmdArgs.push_back(
"-disable-llvm-passes");
5758 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5759 options::OPT_mkernel,
5760 options::OPT_fapple_kext,
5761 options::OPT_ffunction_sections,
5762 options::OPT_fno_function_sections,
5763 options::OPT_fdata_sections,
5764 options::OPT_fno_data_sections,
5765 options::OPT_fbasic_block_sections_EQ,
5766 options::OPT_funique_internal_linkage_names,
5767 options::OPT_fno_unique_internal_linkage_names,
5768 options::OPT_funique_section_names,
5769 options::OPT_fno_unique_section_names,
5770 options::OPT_funique_basic_block_section_names,
5771 options::OPT_fno_unique_basic_block_section_names,
5772 options::OPT_mrestrict_it,
5773 options::OPT_mno_restrict_it,
5774 options::OPT_mstackrealign,
5775 options::OPT_mno_stackrealign,
5776 options::OPT_mstack_alignment,
5777 options::OPT_mcmodel_EQ,
5778 options::OPT_mlong_calls,
5779 options::OPT_mno_long_calls,
5780 options::OPT_ggnu_pubnames,
5781 options::OPT_gdwarf_aranges,
5782 options::OPT_fdebug_types_section,
5783 options::OPT_fno_debug_types_section,
5784 options::OPT_fdwarf_directory_asm,
5785 options::OPT_fno_dwarf_directory_asm,
5786 options::OPT_mrelax_all,
5787 options::OPT_mno_relax_all,
5788 options::OPT_ftrap_function_EQ,
5789 options::OPT_ffixed_r9,
5790 options::OPT_mfix_cortex_a53_835769,
5791 options::OPT_mno_fix_cortex_a53_835769,
5792 options::OPT_ffixed_x18,
5793 options::OPT_mglobal_merge,
5794 options::OPT_mno_global_merge,
5795 options::OPT_mred_zone,
5796 options::OPT_mno_red_zone,
5797 options::OPT_Wa_COMMA,
5798 options::OPT_Xassembler,
5802 for (
const auto &A : Args)
5803 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5804 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5807 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5808 options::OPT_fno_optimize_sibling_calls);
5816 case llvm::Triple::arm:
5817 case llvm::Triple::armeb:
5818 case llvm::Triple::thumbeb:
5819 RenderARMABI(D, Triple, Args, CmdArgs);
5821 case llvm::Triple::aarch64:
5822 case llvm::Triple::aarch64_32:
5823 case llvm::Triple::aarch64_be:
5824 RenderAArch64ABI(Triple, Args, CmdArgs);
5829 if (Output.
getType() == types::TY_Dependencies) {
5832 CmdArgs.push_back(
"-o");
5835 assert(Output.
isNothing() &&
"Input output.");
5838 for (
const auto &II : Inputs) {
5840 if (II.isFilename())
5841 CmdArgs.push_back(II.getFilename());
5843 II.getInputArg().renderAsInput(Args, CmdArgs);
5846 C.addCommand(std::make_unique<Command>(
5852 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5853 CmdArgs.push_back(
"-fembed-bitcode=marker");
5858 if (!
C.isForDiagnostics())
5859 CmdArgs.push_back(
"-disable-free");
5860 CmdArgs.push_back(
"-clear-ast-before-backend");
5863 const bool IsAssertBuild =
false;
5865 const bool IsAssertBuild =
true;
5870 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5871 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5872 CmdArgs.push_back(
"-disable-llvm-verifier");
5876 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5877 options::OPT_fno_discard_value_names, !IsAssertBuild))
5878 CmdArgs.push_back(
"-discard-value-names");
5882 CmdArgs.push_back(
"-main-file-name");
5887 if (Args.hasArg(options::OPT_static))
5888 CmdArgs.push_back(
"-static-define");
5890 Args.AddLastArg(CmdArgs, options::OPT_static_libclosure);
5892 if (Args.hasArg(options::OPT_municode))
5893 CmdArgs.push_back(
"-DUNICODE");
5900 CmdArgs.push_back(
"-setup-static-analyzer");
5905 bool FoundAnalyzerConfig =
false;
5906 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5907 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5908 FoundAnalyzerConfig =
true;
5911 if (!FoundAnalyzerConfig)
5912 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5913 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5914 FoundAnalyzerConfig =
true;
5917 if (FoundAnalyzerConfig)
5918 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5923 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5924 if (FunctionAlignment) {
5925 CmdArgs.push_back(
"-function-alignment");
5926 CmdArgs.push_back(Args.MakeArgString(Twine(FunctionAlignment)));
5930 Args.getLastArg(options::OPT_fpreferred_function_alignment_EQ)) {
5932 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5934 << A->getAsString(Args) << A->getValue();
5935 else if (!llvm::isPowerOf2_32(
Value))
5936 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5937 << A->getAsString(Args) << A->getValue();
5939 CmdArgs.push_back(Args.MakeArgString(
"-fpreferred-function-alignment=" +
5940 Twine(std::min(
Value, 65536u))));
5945 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5947 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5949 << A->getAsString(Args) << A->getValue();
5951 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5952 << A->getAsString(Args) << A->getValue();
5955 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5956 Twine(std::min(
Value, 65536u))));
5959 if (Triple.isOSzOS()) {
5968 auto findMacroDefinition = [&](
const std::string &
Macro) {
5969 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5970 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5971 return M ==
Macro || M.find(
Macro +
'=') != std::string::npos;
5976 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5977 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5979 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5980 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5983 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5984 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5988 llvm::Reloc::Model RelocationModel;
5991 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5992 Arg *LastPICDataRelArg =
5993 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5994 options::OPT_mpic_data_is_text_relative);
5995 bool NoPICDataIsTextRelative =
false;
5996 if (LastPICDataRelArg) {
5997 if (LastPICDataRelArg->getOption().matches(
5998 options::OPT_mno_pic_data_is_text_relative)) {
5999 NoPICDataIsTextRelative =
true;
6001 D.
Diag(diag::err_drv_argument_only_allowed_with)
6002 <<
"-mno-pic-data-is-text-relative"
6005 if (!Triple.isSystemZ())
6006 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6007 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
6008 :
"-mpic-data-is-text-relative")
6012 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
6013 RelocationModel == llvm::Reloc::ROPI_RWPI;
6014 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
6015 RelocationModel == llvm::Reloc::ROPI_RWPI;
6017 if (Args.hasArg(options::OPT_mcmse) &&
6018 !Args.hasArg(options::OPT_fallow_unsupported)) {
6020 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
6022 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
6026 !Args.hasArg(options::OPT_fallow_unsupported))
6027 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
6031 CmdArgs.push_back(
"-mrelocation-model");
6032 CmdArgs.push_back(RMName);
6035 CmdArgs.push_back(
"-pic-level");
6036 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
6038 CmdArgs.push_back(
"-pic-is-pie");
6039 if (NoPICDataIsTextRelative)
6040 CmdArgs.push_back(
"-mcmodel=medium");
6043 if (RelocationModel == llvm::Reloc::ROPI ||
6044 RelocationModel == llvm::Reloc::ROPI_RWPI)
6045 CmdArgs.push_back(
"-fropi");
6046 if (RelocationModel == llvm::Reloc::RWPI ||
6047 RelocationModel == llvm::Reloc::ROPI_RWPI)
6048 CmdArgs.push_back(
"-frwpi");
6052 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
6053 StringRef
Value = A->getValue();
6055 CmdArgs.push_back(
"-meabi");
6056 CmdArgs.push_back(A->getValue());
6071 if (Triple.isOSBinFormatELF()) {
6072 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
6073 options::OPT_fno_semantic_interposition);
6074 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
6076 bool SupportsLocalAlias =
6077 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
6079 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
6080 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
6081 A->render(Args, CmdArgs);
6082 else if (!SupportsLocalAlias)
6083 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
6089 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
6091 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
6092 << A->getValue() << A->getAsString(Args);
6093 Model = A->getValue();
6096 if (Model !=
"posix") {
6097 CmdArgs.push_back(
"-mthread-model");
6098 CmdArgs.push_back(Args.MakeArgString(Model));
6102 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6103 StringRef Name = A->getValue();
6104 if (Name ==
"SVML") {
6105 if (Triple.getArch() != llvm::Triple::x86 &&
6106 Triple.getArch() != llvm::Triple::x86_64)
6107 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6108 << Name << Triple.getArchName();
6109 }
else if (Name ==
"AMDLIBM") {
6110 if (Triple.getArch() != llvm::Triple::x86 &&
6111 Triple.getArch() != llvm::Triple::x86_64)
6112 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6113 << Name << Triple.getArchName();
6114 }
else if (Name ==
"libmvec") {
6115 if (Triple.getArch() != llvm::Triple::x86 &&
6116 Triple.getArch() != llvm::Triple::x86_64 &&
6117 Triple.getArch() != llvm::Triple::aarch64 &&
6118 Triple.getArch() != llvm::Triple::aarch64_be)
6119 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6120 << Name << Triple.getArchName();
6121 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
6122 if (Triple.getArch() != llvm::Triple::aarch64 &&
6123 Triple.getArch() != llvm::Triple::aarch64_be && !Triple.isRISCV64())
6124 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6125 << Name << Triple.getArchName();
6127 A->render(Args, CmdArgs);
6130 if (Args.hasFlag(options::OPT_fmerge_all_constants,
6131 options::OPT_fno_merge_all_constants,
false))
6132 CmdArgs.push_back(
"-fmerge-all-constants");
6134 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
6135 options::OPT_fno_delete_null_pointer_checks);
6137 Args.addOptOutFlag(CmdArgs, options::OPT_flifetime_dse,
6138 options::OPT_fno_lifetime_dse);
6142 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
6143 if (!Triple.isOSAIX() || Triple.isPPC32())
6144 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6145 << A->getSpelling() << RawTriple.str();
6146 CmdArgs.push_back(
"-mabi=quadword-atomics");
6149 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
6152 if (Triple.isOSAIX())
6153 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6154 << A->getSpelling() << RawTriple.str();
6157 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
6158 StringRef
V = A->getValue(), V1 =
V;
6160 if (V1.consumeInteger(10, Size) || !V1.empty())
6161 D.
Diag(diag::err_drv_invalid_argument_to_option)
6162 <<
V << A->getOption().getName();
6164 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
6167 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
6168 options::OPT_fno_jump_tables);
6169 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
6170 options::OPT_fno_profile_sample_accurate);
6171 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
6172 options::OPT_fno_preserve_as_comments);
6174 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
6175 CmdArgs.push_back(
"-mregparm");
6176 CmdArgs.push_back(A->getValue());
6179 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
6180 options::OPT_msvr4_struct_return)) {
6182 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6183 << A->getSpelling() << RawTriple.str();
6184 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
6185 CmdArgs.push_back(
"-maix-struct-return");
6187 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
6188 CmdArgs.push_back(
"-msvr4-struct-return");
6192 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
6193 options::OPT_freg_struct_return)) {
6194 if (TC.
getArch() != llvm::Triple::x86) {
6195 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6196 << A->getSpelling() << RawTriple.str();
6197 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
6198 CmdArgs.push_back(
"-fpcc-struct-return");
6200 assert(A->getOption().matches(options::OPT_freg_struct_return));
6201 CmdArgs.push_back(
"-freg-struct-return");
6205 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
6206 if (Triple.getArch() == llvm::Triple::m68k)
6207 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
6209 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
6212 if (Args.hasArg(options::OPT_fenable_matrix)) {
6214 CmdArgs.push_back(
"-fenable-matrix");
6215 CmdArgs.push_back(
"-mllvm");
6216 CmdArgs.push_back(
"-enable-matrix");
6218 if (
const Arg *A = Args.getLastArg(options::OPT_fmatrix_memory_layout_EQ)) {
6219 StringRef Val = A->getValue();
6220 if (Val ==
"row-major" || Val ==
"column-major") {
6221 CmdArgs.push_back(Args.MakeArgString(
"-fmatrix-memory-layout=" + Val));
6222 CmdArgs.push_back(
"-mllvm");
6223 CmdArgs.push_back(Args.MakeArgString(
"-matrix-default-layout=" + Val));
6226 D.
Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
6233 const char *FPKeepKindStr =
nullptr;
6234 switch (FPKeepKind) {
6236 FPKeepKindStr =
"-mframe-pointer=none";
6239 FPKeepKindStr =
"-mframe-pointer=reserved";
6242 FPKeepKindStr =
"-mframe-pointer=non-leaf-no-reserve";
6245 FPKeepKindStr =
"-mframe-pointer=non-leaf";
6248 FPKeepKindStr =
"-mframe-pointer=all";
6251 assert(FPKeepKindStr &&
"unknown FramePointerKind");
6252 CmdArgs.push_back(FPKeepKindStr);
6254 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
6255 options::OPT_fno_zero_initialized_in_bss);
6258 if (Args.hasArg(options::OPT_Ofast))
6259 D.
Diag(diag::warn_drv_deprecated_arg_ofast);
6262 OptSpecifier StrictAliasingAliasOption =
6263 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
6266 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
6267 options::OPT_fno_strict_aliasing,
6268 !IsWindowsMSVC && !IsUEFI))
6269 CmdArgs.push_back(
"-relaxed-aliasing");
6270 if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
6272 CmdArgs.push_back(
"-no-pointer-tbaa");
6273 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
6274 options::OPT_fno_struct_path_tbaa,
true))
6275 CmdArgs.push_back(
"-no-struct-path-tbaa");
6277 if (Arg *A = Args.getLastArg(options::OPT_fstrict_bool,
6278 options::OPT_fno_strict_bool,
6279 options::OPT_fno_strict_bool_EQ)) {
6281 if (A->getOption().matches(options::OPT_fstrict_bool))
6283 else if (A->getOption().matches(options::OPT_fno_strict_bool))
6285 else if (A->getValue() == StringRef(
"truncate"))
6287 else if (A->getValue() == StringRef(
"nonzero"))
6290 D.
Diag(diag::err_drv_invalid_value)
6291 << A->getAsString(Args) << A->getValue();
6292 CmdArgs.push_back(Args.MakeArgString(
"-load-bool-from-mem=" + BFM));
6293 }
else if (KernelOrKext) {
6295 CmdArgs.push_back(
"-load-bool-from-mem=truncate");
6298 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
6299 options::OPT_fno_strict_enums);
6300 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
6301 options::OPT_fno_strict_return);
6302 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
6303 options::OPT_fno_allow_editor_placeholders);
6304 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
6305 options::OPT_fno_strict_vtable_pointers);
6306 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
6307 options::OPT_fno_force_emit_vtables);
6308 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
6309 options::OPT_fno_optimize_sibling_calls);
6310 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
6311 options::OPT_fno_escaping_block_tail_calls);
6313 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
6314 options::OPT_fno_fine_grained_bitfield_accesses);
6316 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6317 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6319 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6320 options::OPT_fno_experimental_omit_vtable_rtti);
6322 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
6323 options::OPT_fno_disable_block_signature_string);
6326 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
6327 options::OPT_fno_split_stack);
6330 if (Args.hasFlag(options::OPT_fprotect_parens,
6331 options::OPT_fno_protect_parens,
false))
6332 CmdArgs.push_back(
"-fprotect-parens");
6336 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_remote_memory,
6337 options::OPT_fno_atomic_remote_memory);
6338 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_fine_grained_memory,
6339 options::OPT_fno_atomic_fine_grained_memory);
6340 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_ignore_denormal_mode,
6341 options::OPT_fno_atomic_ignore_denormal_mode);
6343 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
6345 if (
Arch == llvm::Triple::x86 ||
Arch == llvm::Triple::x86_64) {
6346 StringRef
V = A->getValue();
6348 CmdArgs.push_back(
"-fextend-arguments=64");
6350 D.
Diag(diag::err_drv_invalid_argument_to_option)
6351 << A->getValue() << A->getOption().getName();
6353 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6354 << A->getOption().getName() << TripleStr;
6357 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
6358 if (TC.
getArch() == llvm::Triple::avr)
6359 A->render(Args, CmdArgs);
6361 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6362 << A->getAsString(Args) << TripleStr;
6365 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
6367 A->render(Args, CmdArgs);
6369 (A->getOption().getID() != options::OPT_mlong_double_80))
6370 A->render(Args, CmdArgs);
6372 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6373 << A->getAsString(Args) << TripleStr;
6379 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
6380 IsIntegratedAssemblerDefault))
6381 CmdArgs.push_back(
"-fno-verbose-asm");
6385 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
6386 StringRef
V = A->getValue();
6389 A->render(Args, CmdArgs);
6390 else if (!
V.consumeInteger(10,
Num) &&
Num > 0 &&
6391 (
V.empty() || (
V.consume_front(
".") &&
6392 !
V.consumeInteger(10,
Num) &&
V.empty())))
6393 A->render(Args, CmdArgs);
6395 D.
Diag(diag::err_drv_invalid_argument_to_option)
6396 << A->getValue() << A->getOption().getName();
6402 CmdArgs.push_back(
"-no-integrated-as");
6404 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
6405 CmdArgs.push_back(
"-mdebug-pass");
6406 CmdArgs.push_back(
"Structure");
6408 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
6409 CmdArgs.push_back(
"-mdebug-pass");
6410 CmdArgs.push_back(
"Arguments");
6416 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
6417 CmdArgs.push_back(
"-mconstructor-aliases");
6421 if (KernelOrKext && RawTriple.isOSDarwin())
6422 CmdArgs.push_back(
"-fforbid-guard-variables");
6424 if (Arg *A = Args.getLastArg(options::OPT_mms_bitfields,
6425 options::OPT_mno_ms_bitfields)) {
6426 if (A->getOption().matches(options::OPT_mms_bitfields))
6427 CmdArgs.push_back(
"-fms-layout-compatibility=microsoft");
6429 CmdArgs.push_back(
"-fms-layout-compatibility=itanium");
6432 if (Triple.isOSCygMing()) {
6433 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
6434 options::OPT_fno_auto_import);
6437 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
6438 Triple.isX86() && IsWindowsMSVC))
6439 CmdArgs.push_back(
"-fms-volatile");
6444 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
6445 options::OPT_fno_direct_access_external_data)) {
6446 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
6448 A->render(Args, CmdArgs);
6449 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
6452 CmdArgs.push_back(
"-fno-direct-access-external-data");
6455 if (Triple.isOSBinFormatELF() && (Triple.isAArch64() || Triple.isX86()))
6456 Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);
6462 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
6465 CmdArgs.push_back(
"-ffreestanding");
6467 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
6472 Args.AddLastArg(CmdArgs,
6473 options::OPT_fallow_runtime_check_skip_hot_cutoff_EQ);
6478 bool IsAsyncUnwindTablesDefault =
6480 bool IsSyncUnwindTablesDefault =
6483 bool AsyncUnwindTables = Args.hasFlag(
6484 options::OPT_fasynchronous_unwind_tables,
6485 options::OPT_fno_asynchronous_unwind_tables,
6486 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
6489 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
6490 IsSyncUnwindTablesDefault && !Freestanding);
6491 if (AsyncUnwindTables)
6492 CmdArgs.push_back(
"-funwind-tables=2");
6493 else if (UnwindTables)
6494 CmdArgs.push_back(
"-funwind-tables=1");
6498 if (Arg *A = Args.getLastArg(options::OPT_gsframe)) {
6499 if (Triple.isOSBinFormatELF() && Triple.isX86())
6500 CmdArgs.push_back(
"--gsframe");
6502 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6503 << A->getOption().getName() << TripleStr;
6508 if (AuxTriple && !Args.getLastArg(options::OPT_gpu_use_aux_triple_only)) {
6509 const ArgList &HostArgs =
6511 std::string HostCPU =
getCPUName(D, HostArgs, *AuxTriple,
false);
6512 if (!HostCPU.empty()) {
6513 CmdArgs.push_back(
"-aux-target-cpu");
6514 CmdArgs.push_back(Args.MakeArgString(HostCPU));
6523 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
6525 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
6526 StringRef
Value = A->getValue();
6527 unsigned TLSSize = 0;
6528 Value.getAsInteger(10, TLSSize);
6529 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
6530 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6531 << A->getOption().getName() << TripleStr;
6532 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
6533 D.
Diag(diag::err_drv_invalid_int_value)
6534 << A->getOption().getName() <<
Value;
6535 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6539 CmdArgs.push_back(
"-enable-tlsdesc");
6542 std::string CPU =
getCPUName(D, Args, Triple,
false);
6544 CmdArgs.push_back(
"-target-cpu");
6545 CmdArgs.push_back(Args.MakeArgString(CPU));
6548 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6553 AddClangCLArgs(Args, InputType, CmdArgs);
6555 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6556 llvm::codegenoptions::NoDebugInfo;
6559 DebugInfoKind, DwarfFission, IsUsingLTO);
6570 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6571 CmdArgs.push_back(
"-split-dwarf-file");
6572 CmdArgs.push_back(SplitDWARFOut);
6574 CmdArgs.push_back(
"-split-dwarf-output");
6575 CmdArgs.push_back(SplitDWARFOut);
6580 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6581 CmdArgs.push_back(
"-target-linker-version");
6582 CmdArgs.push_back(A->getValue());
6587 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6589 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6590 TC.
getArch() == llvm::Triple::x86) {
6591 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6592 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6593 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6594 << Unsupported->getOption().getName();
6597 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6598 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6599 << Unsupported->getOption().getName()
6600 <<
"please use -maltivec and include altivec.h explicitly";
6601 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6602 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6603 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6606 Args.AddAllArgs(CmdArgs, options::OPT_v);
6608 if (Args.getLastArg(options::OPT_H)) {
6609 CmdArgs.push_back(
"-H");
6610 CmdArgs.push_back(
"-sys-header-deps");
6612 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6615 CmdArgs.push_back(
"-header-include-file");
6619 CmdArgs.push_back(
"-sys-header-deps");
6620 CmdArgs.push_back(Args.MakeArgString(
6621 "-header-include-format=" +
6623 CmdArgs.push_back(Args.MakeArgString(
6624 "-header-include-filtering=" +
6627 Args.AddLastArg(CmdArgs, options::OPT_P);
6628 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6631 CmdArgs.push_back(
"-diagnostic-log-file");
6640 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6644 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6645 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6646 CmdArgs.push_back(
"-mllvm");
6647 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6652 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6653 options::OPT_fno_basic_block_address_map)) {
6654 if (((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) ||
6655 (Triple.isX86() && Triple.isOSBinFormatCOFF())) {
6656 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6657 A->render(Args, CmdArgs);
6659 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6660 << A->getAsString(Args) << TripleStr;
6664 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6665 StringRef Val = A->getValue();
6666 if (Val ==
"labels") {
6667 D.
Diag(diag::warn_drv_deprecated_arg)
6668 << A->getAsString(Args) <<
true
6669 <<
"-fbasic-block-address-map";
6670 CmdArgs.push_back(
"-fbasic-block-address-map");
6671 }
else if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6672 if (Val !=
"all" && Val !=
"none" && !Val.starts_with(
"list="))
6673 D.
Diag(diag::err_drv_invalid_value)
6674 << A->getAsString(Args) << A->getValue();
6676 A->render(Args, CmdArgs);
6677 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6680 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6681 D.
Diag(diag::err_drv_invalid_value)
6682 << A->getAsString(Args) << A->getValue();
6684 A->render(Args, CmdArgs);
6685 }
else if (Triple.isNVPTX()) {
6688 }
else if (Val !=
"none") {
6691 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6692 << A->getAsString(Args) << TripleStr;
6696 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6697 options::OPT_fno_unique_section_names);
6698 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6699 options::OPT_fno_separate_named_sections);
6700 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6701 options::OPT_fno_unique_internal_linkage_names);
6702 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6703 options::OPT_fno_unique_basic_block_section_names);
6708 Args.getLastArg(options::OPT_fpartition_static_data_sections,
6709 options::OPT_fno_partition_static_data_sections)) {
6710 if (!A->getOption().matches(
6711 options::OPT_fno_partition_static_data_sections)) {
6713 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6714 A->render(Args, CmdArgs);
6715 CmdArgs.push_back(
"-mllvm");
6716 CmdArgs.push_back(
"-memprof-annotate-static-data-prefix");
6718 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6719 << A->getAsString(Args) << TripleStr;
6723 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6724 options::OPT_finstrument_functions_after_inlining,
6725 options::OPT_finstrument_function_entry_bare);
6726 Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6727 options::OPT_fno_convergent_functions);
6730 if (!Triple.isNVPTX())
6733 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6736 Args.hasFlag(options::OPT_fsample_profile_use_profi,
6737 options::OPT_fno_sample_profile_use_profi,
true)) {
6738 CmdArgs.push_back(
"-mllvm");
6739 CmdArgs.push_back(
"-sample-profile-use-profi");
6743 if (RawTriple.isPS() &&
6744 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6750 if (Args.hasArg(options::OPT_nostdinc)) {
6751 CmdArgs.push_back(
"-nostdsysteminc");
6752 CmdArgs.push_back(
"-nobuiltininc");
6754 if (Args.hasArg(options::OPT_nostdlibinc))
6755 CmdArgs.push_back(
"-nostdsysteminc");
6756 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6757 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6761 CmdArgs.push_back(
"-resource-dir");
6764 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6771 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6777 Args.ClaimAllArgs(options::OPT_D);
6781 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6782 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6787 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6788 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6794 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6797 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6799 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6800 unsigned WarningNumber;
6801 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6802 D.
Diag(diag::err_drv_invalid_int_value)
6803 << A->getAsString(Args) << A->getValue();
6808 CmdArgs.push_back(Args.MakeArgString(
6813 A->render(Args, CmdArgs);
6816 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6818 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6819 CmdArgs.push_back(
"-pedantic");
6820 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6821 Args.AddLastArg(CmdArgs, options::OPT_w);
6823 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6824 options::OPT_fno_fixed_point);
6826 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_overflow_behavior_types,
6827 options::OPT_fno_experimental_overflow_behavior_types);
6829 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6830 A->render(Args, CmdArgs);
6832 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6833 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6835 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6836 options::OPT_fno_experimental_omit_vtable_rtti);
6838 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6839 A->render(Args, CmdArgs);
6846 bool ImplyVCPPCVer =
false;
6847 bool ImplyVCPPCXXVer =
false;
6848 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6850 if (Std->getOption().matches(options::OPT_ansi))
6852 CmdArgs.push_back(
"-std=c++98");
6854 CmdArgs.push_back(
"-std=c89");
6862 D.
Diag(diag::err_drv_argument_not_allowed_with)
6863 << Std->getAsString(Args) <<
"-fsycl";
6866 D.
Diag(diag::err_drv_sycl_requires_cxx17) << Std->getAsString(Args);
6869 Std->render(Args, CmdArgs);
6873 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6874 options::OPT_ftrigraphs,
6875 options::OPT_fno_trigraphs))
6877 A->render(Args, CmdArgs);
6886 if (!Args.hasArg(options::OPT__SLASH_std)) {
6887 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6890 ImplyVCPPCVer =
true;
6892 else if (IsWindowsMSVC)
6893 ImplyVCPPCXXVer =
true;
6896 !Args.hasArg(options::OPT__SLASH_std) && !IsWindowsMSVC)
6900 CmdArgs.push_back(
"-std=c++17");
6902 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6903 options::OPT_fno_trigraphs);
6919 Args.getLastArg(options::OPT_Wwrite_strings,
6920 options::OPT_Wno_write_strings, options::OPT_w);
6922 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6923 CmdArgs.push_back(
"-fconst-strings");
6930 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6932 CmdArgs.push_back(
"-fdeprecated-macro");
6936 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6937 if (
Asm->getOption().matches(options::OPT_fasm))
6938 CmdArgs.push_back(
"-fgnu-keywords");
6940 CmdArgs.push_back(
"-fno-gnu-keywords");
6944 CmdArgs.push_back(
"-fno-autolink");
6946 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6947 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6948 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6949 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6951 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6953 if (CLANG_USE_EXPERIMENTAL_CONST_INTERP) {
6954 Args.ClaimAllArgs(options::OPT_fexperimental_new_constant_interpreter);
6955 Args.AddLastArg(CmdArgs,
6956 options::OPT_fno_experimental_new_constant_interpreter);
6958 Args.ClaimAllArgs(options::OPT_fno_experimental_new_constant_interpreter);
6959 Args.AddLastArg(CmdArgs,
6960 options::OPT_fexperimental_new_constant_interpreter);
6963 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6964 CmdArgs.push_back(
"-fbracket-depth");
6965 CmdArgs.push_back(A->getValue());
6968 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6969 options::OPT_Wlarge_by_value_copy_def)) {
6970 if (A->getNumValues()) {
6971 StringRef
bytes = A->getValue();
6972 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6974 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6977 if (Args.hasArg(options::OPT_relocatable_pch))
6978 CmdArgs.push_back(
"-relocatable-pch");
6979 Args.AddLastArg(CmdArgs, options::OPT_fpch_base_dir_is_cwd);
6981 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6982 static const char *kCFABIs[] = {
6983 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6986 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6987 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6989 A->render(Args, CmdArgs);
6992 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6993 CmdArgs.push_back(
"-fconstant-string-class");
6994 CmdArgs.push_back(A->getValue());
6997 if (Arg *A = Args.getLastArg(options::OPT_fconstant_array_class_EQ)) {
6998 CmdArgs.push_back(
"-fconstant-array-class");
6999 CmdArgs.push_back(A->getValue());
7001 if (Arg *A = Args.getLastArg(options::OPT_fconstant_dictionary_class_EQ)) {
7002 CmdArgs.push_back(
"-fconstant-dictionary-class");
7003 CmdArgs.push_back(A->getValue());
7006 Args.getLastArg(options::OPT_fconstant_integer_number_class_EQ)) {
7007 CmdArgs.push_back(
"-fconstant-integer-number-class");
7008 CmdArgs.push_back(A->getValue());
7010 if (Arg *A = Args.getLastArg(options::OPT_fconstant_float_number_class_EQ)) {
7011 CmdArgs.push_back(
"-fconstant-float-number-class");
7012 CmdArgs.push_back(A->getValue());
7014 if (Arg *A = Args.getLastArg(options::OPT_fconstant_double_number_class_EQ)) {
7015 CmdArgs.push_back(
"-fconstant-double-number-class");
7016 CmdArgs.push_back(A->getValue());
7019 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
7020 CmdArgs.push_back(
"-ftabstop");
7021 CmdArgs.push_back(A->getValue());
7024 if (Args.hasFlag(options::OPT_fexperimental_call_graph_section,
7025 options::OPT_fno_experimental_call_graph_section,
false))
7026 CmdArgs.push_back(
"-fexperimental-call-graph-section");
7028 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
7029 options::OPT_fno_stack_size_section);
7031 if (Args.hasArg(options::OPT_fstack_usage)) {
7032 CmdArgs.push_back(
"-stack-usage-file");
7034 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
7036 llvm::sys::path::replace_extension(OutputFilename,
"su");
7037 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7043 CmdArgs.push_back(
"-ferror-limit");
7044 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
7045 CmdArgs.push_back(A->getValue());
7047 CmdArgs.push_back(
"19");
7049 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
7050 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
7051 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
7052 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
7053 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
7056 unsigned MessageLength = 0;
7057 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
7058 StringRef
V(A->getValue());
7059 if (
V.getAsInteger(0, MessageLength))
7060 D.
Diag(diag::err_drv_invalid_argument_to_option)
7061 <<
V << A->getOption().getName();
7065 MessageLength = llvm::sys::Process::StandardErrColumns();
7067 if (MessageLength != 0)
7069 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
7071 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
7073 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
7075 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
7076 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
7077 Twine(A->getValue(0))));
7080 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
7081 options::OPT_fvisibility_ms_compat)) {
7082 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
7083 A->render(Args, CmdArgs);
7085 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
7086 CmdArgs.push_back(
"-fvisibility=hidden");
7087 CmdArgs.push_back(
"-ftype-visibility=default");
7089 }
else if (IsOpenMPDevice) {
7093 CmdArgs.push_back(
"-fvisibility=protected");
7097 if (!RawTriple.isPS()) {
7099 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
7100 options::OPT_fno_visibility_from_dllstorageclass)) {
7101 if (A->getOption().matches(
7102 options::OPT_fvisibility_from_dllstorageclass)) {
7103 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
7104 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
7105 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
7106 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
7107 Args.AddLastArg(CmdArgs,
7108 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
7113 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
7114 options::OPT_fno_visibility_inlines_hidden,
false))
7115 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
7117 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
7118 options::OPT_fno_visibility_inlines_hidden_static_local_var);
7123 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
7124 D.
Diag(diag::warn_drv_deprecated_arg)
7125 << A->getAsString(Args) <<
true
7126 <<
"-fvisibility-global-new-delete=force-hidden";
7130 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
7131 options::OPT_fvisibility_global_new_delete_hidden)) {
7132 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
7133 A->render(Args, CmdArgs);
7135 assert(A->getOption().matches(
7136 options::OPT_fvisibility_global_new_delete_hidden));
7137 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
7141 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
7143 if (Args.hasFlag(options::OPT_fnew_infallible,
7144 options::OPT_fno_new_infallible,
false))
7145 CmdArgs.push_back(
"-fnew-infallible");
7147 if (Args.hasFlag(options::OPT_fno_operator_names,
7148 options::OPT_foperator_names,
false))
7149 CmdArgs.push_back(
"-fno-operator-names");
7152 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
7153 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
7154 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
7155 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
7156 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
7157 options::OPT_fno_raw_string_literals);
7159 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
7160 Triple.hasDefaultEmulatedTLS()))
7161 CmdArgs.push_back(
"-femulated-tls");
7163 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
7164 options::OPT_fno_check_new);
7166 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
7170 if (!Triple.isX86() && !Triple.isAArch64() && !Triple.isRISCV())
7171 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7172 << A->getAsString(Args) << TripleStr;
7177 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
7179 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
7180 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
7184 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
7185 options::OPT_fno_openmp,
false) &&
7186 !Args.hasFlag(options::OPT_foffload_via_llvm,
7187 options::OPT_fno_offload_via_llvm,
false) &&
7192 bool TargetFastUsed =
7193 Args.hasFlag(options::OPT_fopenmp_target_fast,
7194 options::OPT_fno_openmp_target_fast, OFastEnabled);
7199 CmdArgs.push_back(
"-fopenmp");
7204 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
7205 options::OPT_fnoopenmp_use_tls,
true))
7206 CmdArgs.push_back(
"-fnoopenmp-use-tls");
7207 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
7208 options::OPT_fno_openmp_simd);
7209 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
7210 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
7211 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
7212 options::OPT_fno_openmp_extensions,
true))
7213 CmdArgs.push_back(
"-fno-openmp-extensions");
7214 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
7215 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
7221 if (Arg *A = Args.getLastArg(
7222 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ))
7223 D.
Diag(diag::warn_drv_deprecated_custom)
7224 << A->getAsString(Args)
7225 <<
"the value is ignored; the teams reduction buffer is sized "
7226 "automatically at kernel launch";
7227 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
7228 options::OPT_fno_openmp_optimistic_collapse,
7230 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
7234 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
7235 options::OPT_fno_openmp_cuda_mode,
false))
7236 CmdArgs.push_back(
"-fopenmp-cuda-mode");
7239 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
7240 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
7241 options::OPT_fno_openmp_target_debug,
false))
7242 CmdArgs.push_back(
"-fopenmp-target-debug");
7246 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
7247 options::OPT_fno_openmp_assume_teams_oversubscription,
7249 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
7250 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
7251 options::OPT_fno_openmp_assume_threads_oversubscription,
7253 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
7256 if (Args.hasFlag(options::OPT_fopenmp_assume_no_thread_state,
7257 options::OPT_fno_openmp_assume_no_thread_state,
7259 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
7262 if (Args.hasFlag(options::OPT_fopenmp_assume_no_nested_parallelism,
7263 options::OPT_fno_openmp_assume_no_nested_parallelism,
7265 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
7268 if (Args.hasFlag(options::OPT_fopenmp_target_atomic_reduction,
7269 options::OPT_fno_openmp_target_atomic_reduction,
7271 CmdArgs.push_back(
"-fopenmp-target-atomic-reduction");
7273 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
7274 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
7275 if (Args.hasArg(options::OPT_fopenmp_force_usm))
7276 CmdArgs.push_back(
"-fopenmp-force-usm");
7288 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
7289 options::OPT_fno_openmp_simd);
7290 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
7291 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
7292 options::OPT_fno_openmp_extensions);
7296 if (Args.hasFlag(options::OPT_foffload_via_llvm,
7297 options::OPT_fno_offload_via_llvm,
false))
7298 CmdArgs.push_back(
"-foffload-via-llvm");
7301 XRay.
addArgs(TC, Args, CmdArgs, InputType);
7303 for (
const auto &Filename :
7304 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
7305 if (D.
getVFS().exists(Filename))
7306 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" + Filename));
7308 D.
Diag(clang::diag::err_drv_no_such_file) << Filename;
7311 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
7312 StringRef S0 = A->getValue(), S = S0;
7313 unsigned Size, Offset = 0;
7314 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
7315 !Triple.isX86() && !Triple.isSystemZ() &&
7316 !(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||
7317 Triple.getArch() == llvm::Triple::ppc64 ||
7318 Triple.getArch() == llvm::Triple::ppc64le)))
7319 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7320 << A->getAsString(Args) << TripleStr;
7321 else if (S.consumeInteger(10, Size) ||
7323 (!S.consume_front(
",") || S.consumeInteger(10, Offset))) ||
7324 (!S.empty() && (!S.consume_front(
",") || S.empty())))
7325 D.
Diag(diag::err_drv_invalid_argument_to_option)
7326 << S0 << A->getOption().getName();
7327 else if (Size < Offset)
7328 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
7330 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
7331 CmdArgs.push_back(Args.MakeArgString(
7332 "-fpatchable-function-entry-offset=" + Twine(Offset)));
7335 Args.MakeArgString(
"-fpatchable-function-entry-section=" + S));
7339 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
7341 if (Args.hasArg(options::OPT_fms_secure_hotpatch_functions_file))
7342 Args.AddLastArg(CmdArgs, options::OPT_fms_secure_hotpatch_functions_file);
7344 for (
const auto &A :
7345 Args.getAllArgValues(options::OPT_fms_secure_hotpatch_functions_list))
7347 Args.MakeArgString(
"-fms-secure-hotpatch-functions-list=" + Twine(A)));
7350 Args.AddLastArg(CmdArgs, options::OPT_pg);
7353 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
7354 if (
Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
7355 A->render(Args, CmdArgs);
7357 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7358 << A->getAsString(Args) << TripleStr;
7360 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
7361 if (
Arch == llvm::Triple::systemz ||
7363 A->render(Args, CmdArgs);
7365 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7366 << A->getAsString(Args) << TripleStr;
7368 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
7369 if (
Arch == llvm::Triple::systemz ||
7371 A->render(Args, CmdArgs);
7373 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7374 << A->getAsString(Args) << TripleStr;
7378 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
7380 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7381 << A->getAsString(Args) << TripleStr;
7384 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
7386 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7387 << A->getAsString(Args) << TripleStr;
7390 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
7391 if (A->getOption().matches(options::OPT_p)) {
7393 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
7394 CmdArgs.push_back(
"-pg");
7400 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
7401 options::OPT_mxcoff_build_id_EQ)) {
7402 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7403 << A->getSpelling() << TripleStr;
7407 if (Args.getLastArg(options::OPT_fapple_kext) ||
7408 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
7409 CmdArgs.push_back(
"-fapple-kext");
7411 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
7412 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
7413 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
7414 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
7415 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
7416 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
7417 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
7418 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_json);
7419 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
7420 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
7421 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
7423 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
7424 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
7425 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
7426 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
7427 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_compress_EQ);
7430 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
7431 CmdArgs.push_back(
"-ftrapv-handler");
7432 CmdArgs.push_back(A->getValue());
7435 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
7437 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
7438 options::OPT_fno_finite_loops);
7440 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
7441 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
7442 options::OPT_fno_unroll_loops);
7443 Args.AddLastArg(CmdArgs, options::OPT_floop_interchange,
7444 options::OPT_fno_loop_interchange);
7445 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_loop_fusion,
7446 options::OPT_fno_experimental_loop_fusion);
7448 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
7450 Args.AddLastArg(CmdArgs, options::OPT_pthread);
7452 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
7453 options::OPT_mno_speculative_load_hardening);
7459 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
7461 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
7462 options::OPT_mno_stackrealign);
7464 if (
const Arg *A = Args.getLastArg(options::OPT_mstack_alignment)) {
7465 StringRef
Value = A->getValue();
7466 int64_t Alignment = 0;
7467 if (
Value.getAsInteger(10, Alignment) || Alignment < 0)
7468 D.
Diag(diag::err_drv_invalid_argument_to_option)
7469 <<
Value << A->getOption().getName();
7470 else if (Alignment & (Alignment - 1))
7471 D.
Diag(diag::err_drv_alignment_not_power_of_two)
7472 << A->getAsString(Args) <<
Value;
7474 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" +
Value));
7477 if (Args.hasArg(options::OPT_mstack_probe_size)) {
7478 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
7481 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
7483 CmdArgs.push_back(
"-mstack-probe-size=0");
7486 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
7487 options::OPT_mno_stack_arg_probe);
7489 if (Arg *A = Args.getLastArg(options::OPT_msmall_int_abi_compat_EQ))
7490 A->render(Args, CmdArgs);
7492 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
7493 options::OPT_mno_restrict_it)) {
7494 if (A->getOption().matches(options::OPT_mrestrict_it)) {
7495 CmdArgs.push_back(
"-mllvm");
7496 CmdArgs.push_back(
"-arm-restrict-it");
7498 CmdArgs.push_back(
"-mllvm");
7499 CmdArgs.push_back(
"-arm-default-it");
7513 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
7514 options::OPT_fno_hip_new_launch_api,
true))
7515 CmdArgs.push_back(
"-fhip-new-launch-api");
7516 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
7517 options::OPT_fno_gpu_allow_device_init);
7518 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
7519 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
7520 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
7521 options::OPT_fno_hip_kernel_arg_name);
7523 TC.
getTriple().getVendor() == llvm::Triple::VendorType::AMD)
7524 Args.addLastArg(CmdArgs, options::OPT_fenable_spirv_size_optimization);
7527 if ((IsCuda || IsHIP || IsSYCL) && IsRDCMode)
7528 CmdArgs.push_back(
"-fgpu-rdc");
7530 if (IsCuda || IsHIP) {
7531 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
7532 options::OPT_fno_gpu_defer_diag);
7533 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
7534 options::OPT_fno_gpu_exclude_wrong_side_overloads,
7536 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
7537 CmdArgs.push_back(
"-fgpu-defer-diag");
7542 if (!Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
true))
7543 CmdArgs.push_back(
"--no-offloadlib");
7545 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
7547 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
7549 if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
7550 CmdArgs.push_back(Args.MakeArgString(Twine(
"-mcf-branch-label-scheme=") +
7552 }
else if (Triple.isOSOpenBSD() && Triple.getArch() == llvm::Triple::x86_64) {
7554 CmdArgs.push_back(
"-fcf-protection=branch");
7556 CmdArgs.push_back(
"-fno-jump-tables");
7559 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
7561 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
7563 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
7568 if (!(IsCudaDevice || IsHIPDevice)) {
7570 auto *PGOArg = Args.getLastArg(
7571 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
7572 options::OPT_fcs_profile_generate,
7573 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
7574 options::OPT_fprofile_use_EQ);
7576 D.
Diag(diag::err_drv_argument_not_allowed_with)
7577 <<
"SampleUse with PGO options";
7579 StringRef fname = A->getValue();
7580 if (!llvm::sys::fs::exists(fname))
7581 D.
Diag(diag::err_drv_no_such_file) << fname;
7583 A->render(Args, CmdArgs);
7585 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
7587 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
7588 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
7589 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
7592 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
7593 options::OPT_fno_unique_internal_linkage_names,
true))
7594 CmdArgs.push_back(
"-funique-internal-linkage-names");
7599 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7600 options::OPT_fno_assume_sane_operator_new);
7602 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
7603 CmdArgs.push_back(
"-fapinotes");
7604 if (Args.hasFlag(options::OPT_fapinotes_modules,
7605 options::OPT_fno_apinotes_modules,
false))
7606 CmdArgs.push_back(
"-fapinotes-modules");
7607 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
7609 if (Args.hasFlag(options::OPT_fswift_version_independent_apinotes,
7610 options::OPT_fno_swift_version_independent_apinotes,
false))
7611 CmdArgs.push_back(
"-fswift-version-independent-apinotes");
7614 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
7616 (Args.hasArg(options::OPT_fgnu_runtime) &&
7617 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
7618 !Args.hasArg(options::OPT_fno_blocks))) {
7619 CmdArgs.push_back(
"-fblocks");
7622 CmdArgs.push_back(
"-fblocks-runtime-optional");
7627 CmdArgs.push_back(
"-fencode-extended-block-signature");
7629 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7630 options::OPT_fno_coro_aligned_allocation,
false) &&
7632 CmdArgs.push_back(
"-fcoro-aligned-allocation");
7634 if (Args.hasFlag(options::OPT_fdefer_ts, options::OPT_fno_defer_ts,
7636 CmdArgs.push_back(
"-fdefer-ts");
7638 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7639 options::OPT_fno_double_square_bracket_attributes);
7641 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7642 options::OPT_fno_access_control);
7643 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7644 options::OPT_fno_elide_constructors);
7650 CmdArgs.push_back(
"-fno-rtti");
7653 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7654 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
7655 CmdArgs.push_back(
"-fshort-enums");
7661 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
7662 !RawTriple.isOSAIX() &&
7663 (!RawTriple.isOSWindows() ||
7664 RawTriple.isWindowsCygwinEnvironment()) &&
7665 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
7666 RawTriple.hasEnvironment())) ||
7668 CmdArgs.push_back(
"-fno-use-cxa-atexit");
7670 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7671 options::OPT_fno_register_global_dtors_with_atexit,
7672 RawTriple.isOSDarwin() && !KernelOrKext))
7673 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7675 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7676 options::OPT_fno_use_line_directives);
7679 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7680 options::OPT_fno_minimize_whitespace,
false)) {
7681 types::ID InputType = Inputs[0].getType();
7682 if (!isDerivedFromC(InputType))
7683 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7685 CmdArgs.push_back(
"-fminimize-whitespace");
7689 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7690 options::OPT_fno_keep_system_includes,
false)) {
7691 types::ID InputType = Inputs[0].getType();
7692 if (!isDerivedFromC(InputType))
7693 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7695 CmdArgs.push_back(
"-fkeep-system-includes");
7699 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7700 IsWindowsMSVC || IsUEFI))
7701 CmdArgs.push_back(
"-fms-extensions");
7704 bool IsMSVCCompat = Args.hasFlag(
7705 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7706 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7707 options::OPT_fno_ms_extensions,
true)));
7709 CmdArgs.push_back(
"-fms-compatibility");
7711 Args.hasArg(options::OPT_fms_define_stdc))
7712 CmdArgs.push_back(
"-fms-define-stdc");
7733 auto MSAnonymousStructsOptionToUseOrNull =
7734 [](
const ArgList &Args) ->
const char * {
7735 const char *Option =
nullptr;
7736 constexpr const char *Enable =
"-fms-anonymous-structs";
7737 constexpr const char *Disable =
"-fno-ms-anonymous-structs";
7740 for (
const Arg *A : Args) {
7741 switch (A->getOption().getID()) {
7742 case options::OPT_fms_anonymous_structs:
7746 case options::OPT_fno_ms_anonymous_structs:
7752 case options::OPT_fms_extensions:
7753 case options::OPT_fms_compatibility:
7758 case options::OPT_fno_ms_extensions:
7759 case options::OPT_fno_ms_compatibility:
7770 if (
auto MSAnonOpt = MSAnonymousStructsOptionToUseOrNull(Args))
7771 CmdArgs.push_back(MSAnonOpt);
7773 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7774 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7778 VersionTuple GNUCVer;
7779 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7782 StringRef Val = A->getValue();
7783 Val = Val.empty() ?
"0" : Val;
7784 bool Invalid = GNUCVer.tryParse(Val);
7785 unsigned Minor = GNUCVer.getMinor().value_or(0);
7786 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7787 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7788 D.
Diag(diag::err_drv_invalid_value)
7789 << A->getAsString(Args) << A->getValue();
7791 }
else if (!IsMSVCCompat) {
7793 GNUCVer = VersionTuple(4, 2, 1);
7795 if (!GNUCVer.empty()) {
7797 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7803 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7805 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7806 if (ImplyVCPPCVer) {
7807 StringRef LanguageStandard;
7808 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7810 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7811 .Case(
"c11",
"-std=c11")
7812 .Case(
"c17",
"-std=c17")
7819 .Case(
"clatest",
"-std=c23")
7821 if (LanguageStandard.empty())
7822 D.
Diag(clang::diag::warn_drv_unused_argument)
7823 << StdArg->getAsString(Args);
7825 CmdArgs.push_back(LanguageStandard.data());
7827 if (ImplyVCPPCXXVer) {
7828 StringRef LanguageStandard;
7829 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7831 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7832 .Case(
"c++14",
"-std=c++14")
7833 .Case(
"c++17",
"-std=c++17")
7834 .Case(
"c++20",
"-std=c++20")
7835 .Case(
"c++23",
"-std=c++23")
7843 .Case(
"c++23preview",
"-std=c++23")
7844 .Case(
"c++26preview",
"-std=c++26")
7845 .Case(
"c++latest",
"-std=c++2d")
7853 D.
Diag(diag::err_drv_argument_not_allowed_with)
7854 << StdArg->getAsString(Args) <<
"-fsycl";
7857 D.
Diag(diag::err_drv_sycl_requires_cxx17)
7858 << StdArg->getAsString(Args);
7861 if (LanguageStandard.empty())
7862 D.
Diag(clang::diag::warn_drv_unused_argument)
7863 << StdArg->getAsString(Args);
7866 if (LanguageStandard.empty()) {
7869 LanguageStandard =
"-std=c++17";
7870 else if (IsMSVC2015Compatible)
7871 LanguageStandard =
"-std=c++14";
7873 LanguageStandard =
"-std=c++11";
7876 CmdArgs.push_back(LanguageStandard.data());
7879 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7880 options::OPT_fno_borland_extensions);
7883 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7885 CmdArgs.push_back(
"-fdeclspec");
7886 else if (Args.hasArg(options::OPT_fno_declspec))
7887 CmdArgs.push_back(
"-fno-declspec");
7891 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7892 options::OPT_fno_threadsafe_statics,
7894 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7895 CmdArgs.push_back(
"-fno-threadsafe-statics");
7897 if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7899 CmdArgs.push_back(
"-fno-ms-tls-guards");
7902 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7904 CmdArgs.push_back(
"-fno-assumptions");
7908 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7909 options::OPT_fno_gnu_keywords);
7911 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7912 options::OPT_fno_gnu89_inline);
7914 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7915 options::OPT_finline_hint_functions,
7916 options::OPT_fno_inline_functions);
7917 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7918 if (A->getOption().matches(options::OPT_fno_inline))
7919 A->render(Args, CmdArgs);
7920 }
else if (InlineArg) {
7921 InlineArg->render(Args, CmdArgs);
7924 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7929 (Std->containsValue(
"c++2a") || Std->containsValue(
"gnu++2a") ||
7930 Std->containsValue(
"c++20") || Std->containsValue(
"gnu++20") ||
7931 Std->containsValue(
"c++2b") || Std->containsValue(
"gnu++2b") ||
7932 Std->containsValue(
"c++23") || Std->containsValue(
"gnu++23") ||
7933 Std->containsValue(
"c++23preview") || Std->containsValue(
"c++2c") ||
7934 Std->containsValue(
"gnu++2c") || Std->containsValue(
"c++26") ||
7935 Std->containsValue(
"gnu++26") || Std->containsValue(
"c++26preview") ||
7936 Std->containsValue(
"c++2d") || Std->containsValue(
"gnu++2d") ||
7937 Std->containsValue(
"c++latest") || Std->containsValue(
"gnu++latest"));
7952 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7953 options::OPT_fno_delayed_template_parsing,
7954 IsWindowsMSVC && !HaveCxx20)) {
7956 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7958 CmdArgs.push_back(
"-fdelayed-template-parsing");
7961 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7962 options::OPT_fno_pch_validate_input_files_content,
false))
7963 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7964 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7965 options::OPT_fno_pch_instantiate_templates,
false))
7966 CmdArgs.push_back(
"-fpch-instantiate-templates");
7967 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7969 CmdArgs.push_back(
"-fmodules-codegen");
7970 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7972 CmdArgs.push_back(
"-fmodules-debuginfo");
7974 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7979 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7980 options::OPT_fno_objc_encode_cxx_class_template_spec,
7982 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7984 if (Args.hasFlag(options::OPT_fapplication_extension,
7985 options::OPT_fno_application_extension,
false))
7986 CmdArgs.push_back(
"-fapplication-extension");
7990 if (!
C.getDriver().IsCLMode())
7992 IsDeviceOffloadAction, Runtime, CmdArgs);
7995 Arg *A = Args.getLastArg(
7996 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7997 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions,
7998 options::OPT_femscripten_exceptions);
8000 const Option &Opt = A->getOption();
8001 if (Opt.matches(options::OPT_fsjlj_exceptions))
8002 CmdArgs.push_back(
"-exception-model=sjlj");
8003 if (Opt.matches(options::OPT_fseh_exceptions))
8004 CmdArgs.push_back(
"-exception-model=seh");
8005 if (Opt.matches(options::OPT_fdwarf_exceptions))
8006 CmdArgs.push_back(
"-exception-model=dwarf");
8007 if (Opt.matches(options::OPT_fwasm_exceptions))
8008 CmdArgs.push_back(
"-exception-model=wasm");
8009 if (Opt.matches(options::OPT_femscripten_exceptions))
8010 CmdArgs.push_back(
"-exception-model=emscripten");
8015 case llvm::ExceptionHandling::DwarfCFI:
8016 CmdArgs.push_back(
"-exception-model=dwarf");
8018 case llvm::ExceptionHandling::SjLj:
8019 CmdArgs.push_back(
"-exception-model=sjlj");
8021 case llvm::ExceptionHandling::WinEH:
8022 CmdArgs.push_back(
"-exception-model=seh");
8029 if (
const Arg *A = Args.getLastArg(options::OPT_winx64_eh_unwind_EQ)) {
8032 Args.MakeArgString(Twine(
"-fwinx64-eh-unwind=") + A->getValue()));
8033 }
else if (
const Arg *A =
8034 Args.getLastArg(options::OPT_winx64_eh_unwindv2_EQ)) {
8036 StringRef Val = A->getValue();
8037 if (Val ==
"best-effort")
8038 CmdArgs.push_back(
"-fwinx64-eh-unwind=v2-best-effort");
8039 else if (Val ==
"required")
8040 CmdArgs.push_back(
"-fwinx64-eh-unwind=v2-required");
8042 else if (Val !=
"disabled")
8043 D.
Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
8047 Args.AddLastArg(CmdArgs, options::OPT_win_cfg_mechanism);
8050 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
8051 options::OPT_fno_assume_sane_operator_new);
8054 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
8055 options::OPT_fno_assume_unique_vtables);
8059 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
8060 options::OPT_fno_sized_deallocation);
8064 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
8065 options::OPT_fno_aligned_allocation,
8066 options::OPT_faligned_new_EQ)) {
8067 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
8068 CmdArgs.push_back(
"-fno-aligned-allocation");
8070 CmdArgs.push_back(
"-faligned-allocation");
8075 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
8076 options::OPT_faligned_new_EQ))
8078 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
8082 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
8083 options::OPT_fno_constant_cfstrings,
true) ||
8084 !Args.hasFlag(options::OPT_mconstant_cfstrings,
8085 options::OPT_mno_constant_cfstrings,
true))
8086 CmdArgs.push_back(
"-fno-constant-cfstrings");
8088 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
8089 options::OPT_fno_pascal_strings);
8093 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
8095 Args.MakeArgString(
"-fpack-struct=" + Twine(A->getValue())));
8096 }
else if (Args.hasFlag(options::OPT_fpack_struct,
8097 options::OPT_fno_pack_struct,
false)) {
8098 CmdArgs.push_back(
"-fpack-struct=1");
8102 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
8103 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
8104 if (!SkipMaxTypeAlign) {
8105 std::string MaxTypeAlignStr =
"-fmax-type-align=";
8106 MaxTypeAlignStr += A->getValue();
8107 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
8109 }
else if (RawTriple.isOSDarwin()) {
8110 if (!SkipMaxTypeAlign) {
8111 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
8112 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
8116 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
8117 CmdArgs.push_back(
"-Qn");
8120 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
8124 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
8125 options::OPT_funsigned_bitfields,
true))
8126 D.
Diag(diag::warn_drv_clang_unsupported)
8127 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
8130 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
8131 D.
Diag(diag::err_drv_clang_unsupported)
8132 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
8135 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
8136 StringRef value = inputCharset->getValue();
8137 if (!value.equals_insensitive(
"utf-8"))
8138 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
8143 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
8144 StringRef value = execCharset->getValue();
8145 if (!value.equals_insensitive(
"utf-8"))
8146 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
8152 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
8153 options::OPT_fno_asm_blocks);
8155 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
8156 options::OPT_fno_gnu_inline_asm);
8162 if (!VecWidth.empty())
8163 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + VecWidth));
8165 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
8166 Args.AddLastArg(CmdArgs,
8167 options::OPT_fsanitize_undefined_strip_path_components_EQ);
8171 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
8172 options::OPT_fno_dollars_in_identifiers)) {
8173 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
8174 CmdArgs.push_back(
"-fdollars-in-identifiers");
8176 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
8179 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
8180 options::OPT_fno_apple_pragma_pack);
8186 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
8187 options::OPT_fno_rewrite_imports,
false);
8189 CmdArgs.push_back(
"-frewrite-imports");
8191 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
8192 options::OPT_fno_directives_only);
8198 if (Args.hasFlag(options::OPT_frewrite_includes,
8199 options::OPT_fno_rewrite_includes,
false) ||
8200 (
C.isForDiagnostics() && !HaveModules))
8201 CmdArgs.push_back(
"-frewrite-includes");
8203 if (Args.hasFlag(options::OPT_fzos_extensions,
8204 options::OPT_fno_zos_extensions,
false))
8205 CmdArgs.push_back(
"-fzos-extensions");
8206 else if (Args.hasArg(options::OPT_fno_zos_extensions))
8207 CmdArgs.push_back(
"-fno-zos-extensions");
8210 if (Arg *A = Args.getLastArg(options::OPT_traditional,
8211 options::OPT_traditional_cpp)) {
8213 CmdArgs.push_back(
"-traditional-cpp");
8215 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
8218 Args.AddLastArg(CmdArgs, options::OPT_dM);
8219 Args.AddLastArg(CmdArgs, options::OPT_dD);
8220 Args.AddLastArg(CmdArgs, options::OPT_dI);
8222 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
8224 Args.AddLastArg(CmdArgs, options::OPT__ssaf_extract_summaries);
8225 Args.AddLastArg(CmdArgs, options::OPT__ssaf_tu_summary_file);
8226 Args.AddLastArg(CmdArgs, options::OPT__ssaf_compilation_unit_id);
8227 Args.AddLastArg(CmdArgs, options::OPT__ssaf_include_local_entities);
8228 Args.AddLastArg(CmdArgs, options::OPT__ssaf_no_extract_from_system_headers);
8229 Args.AddLastArg(CmdArgs, options::OPT__ssaf_source_transformation);
8230 Args.AddLastArg(CmdArgs, options::OPT__ssaf_global_scope_analysis_result);
8231 Args.AddLastArg(CmdArgs, options::OPT__ssaf_link_unit_id);
8232 Args.AddLastArg(CmdArgs, options::OPT__ssaf_src_edit_file);
8233 Args.AddLastArg(CmdArgs, options::OPT__ssaf_transformation_report_file);
8236 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
8237 CmdArgs.push_back(
"-serialize-diagnostic-file");
8238 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
8241 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
8242 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
8244 if (Arg *A = Args.getLastArg(options::OPT_fextend_variable_liveness_EQ)) {
8245 A->render(Args, CmdArgs);
8246 }
else if (Arg *A = Args.getLastArg(options::OPT_O_Group);
8247 A && A->containsValue(
"g")) {
8249 CmdArgs.push_back(
"-fextend-variable-liveness=all");
8253 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
8255 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
8257 Args.AddAllArgs(CmdArgs, options::OPT_fretain_comments);
8260 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
8261 CmdArgs.push_back(
"-load");
8262 CmdArgs.push_back(A->getValue());
8274 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
8275 auto ArgValue = StringRef(A->getValue());
8276 auto FirstDashIndex = ArgValue.find(
'-');
8277 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
8278 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
8281 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
8282 if (PluginName.empty()) {
8283 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
8285 D.
Diag(diag::warn_drv_missing_plugin_arg)
8286 << PluginName << A->getAsString(Args);
8291 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
8292 CmdArgs.push_back(Args.MakeArgString(Arg));
8296 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
8298 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
8303 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
8304 CmdArgs.push_back(
"--vfsoverlay");
8305 CmdArgs.push_back(A->getValue());
8309 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
8310 options::OPT_fno_safe_buffer_usage_suggestions);
8312 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
8313 options::OPT_fno_experimental_late_parse_attributes);
8315 if (Args.hasFlag(options::OPT_funique_source_file_names,
8316 options::OPT_fno_unique_source_file_names,
false)) {
8317 if (Arg *A = Args.getLastArg(options::OPT_unique_source_file_identifier_EQ))
8318 A->render(Args, CmdArgs);
8320 CmdArgs.push_back(Args.MakeArgString(
8321 Twine(
"-funique-source-file-identifier=") + Input.
getBaseInput()));
8325 options::OPT_fexperimental_allow_pointer_field_protection_attr,
8326 options::OPT_fno_experimental_allow_pointer_field_protection_attr,
8328 Args.hasFlag(options::OPT_fexperimental_pointer_field_protection_abi,
8329 options::OPT_fno_experimental_pointer_field_protection_abi,
8331 CmdArgs.push_back(
"-fexperimental-allow-pointer-field-protection-attr");
8333 if (!IsCudaDevice) {
8335 CmdArgs, options::OPT_fexperimental_pointer_field_protection_abi,
8336 options::OPT_fno_experimental_pointer_field_protection_abi);
8338 CmdArgs, options::OPT_fexperimental_pointer_field_protection_tagged,
8339 options::OPT_fno_experimental_pointer_field_protection_tagged);
8344 if (!StatsFile.empty()) {
8345 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
8347 CmdArgs.push_back(
"-stats-file-append");
8352 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
8356 if (
C.getDriver().isSaveTempsEnabled() &&
8358 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
8361 CmdArgs.push_back(Arg->getValue());
8363 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
8369 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
8370 CmdArgs.push_back(
"-disable-llvm-optzns");
8372 A->render(Args, CmdArgs);
8378 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
8380 Args.AddLastArg(CmdArgs, options::OPT_falloc_token_max_EQ);
8384 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
8386 A->render(Args, CmdArgs);
8398 if ((
C.getDriver().isSaveTempsEnabled() ||
8400 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
8402 CmdArgs.push_back(
"-disable-llvm-passes");
8404 Args.AddAllArgs(CmdArgs, options::OPT_undef);
8413 auto GRecordSwitches =
false;
8414 auto FRecordSwitches =
false;
8415 bool DXRecordSwitches =
false;
8417 DXRecordSwitches)) {
8420 CmdArgs.push_back(
"-dwarf-debug-flags");
8421 CmdArgs.push_back(FlagsArgString);
8423 if (FRecordSwitches) {
8424 CmdArgs.push_back(
"-record-command-line");
8425 CmdArgs.push_back(FlagsArgString);
8427 if (DXRecordSwitches) {
8428 CmdArgs.push_back(
"-fdx-record-command-line");
8429 CmdArgs.push_back(FlagsArgString);
8435 if (!HostOffloadingInputs.empty()) {
8436 bool UseOffloadIncludeBinary =
8437 (IsCuda || IsHIP) &&
8438 (!IsRDCMode || Args.hasArg(options::OPT_cuda_emit_nvcc_abi)) &&
8439 !UsesLLVMOffloading;
8440 UseOffloadIncludeBinary |= IsSYCL && !IsRDCMode;
8441 if (UseOffloadIncludeBinary) {
8442 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
8443 CmdArgs.push_back(
"-foffload-include-binary");
8444 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
8446 for (
const InputInfo Input : HostOffloadingInputs)
8447 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
8453 if (Args.hasArg(options::OPT_cuda_emit_nvcc_abi))
8454 CmdArgs.push_back(
"--cuda-emit-nvcc-abi");
8457 if (IsCuda || IsHIP) {
8459 const Action *SourceAction = &JA;
8461 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
8462 SourceAction = SourceAction->
getInputs()[0];
8466 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
8470 bool UseApproxTranscendentals = Args.hasFlag(
8471 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
8472 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
8473 options::OPT_fno_gpu_approx_transcendentals,
8474 UseApproxTranscendentals))
8475 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
8477 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
8478 options::OPT_fno_gpu_approx_transcendentals);
8482 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
8483 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
8486 Args.AddAllArgs(CmdArgs,
8487 options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);
8489 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
8490 options::OPT_fno_offload_uniform_block);
8492 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
8493 options::OPT_fno_offload_implicit_host_device_templates);
8495 if (IsCudaDevice || IsHIPDevice) {
8496 StringRef InlineThresh =
8497 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
8498 if (!InlineThresh.empty()) {
8499 std::string ArgStr =
8500 std::string(
"-inline-threshold=") + InlineThresh.str();
8501 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
8506 Args.addOptOutFlag(CmdArgs,
8507 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
8508 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
8515 if (IsOpenMPDevice) {
8516 CmdArgs.push_back(
"-fopenmp-is-target-device");
8518 if (Args.hasArg(options::OPT_foffload_via_llvm))
8519 CmdArgs.push_back(
"-fcuda-is-device");
8521 if (OpenMPDeviceInput) {
8522 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
8523 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
8527 if (Triple.isAMDGPU() ||
8528 (Triple.isSPIRV() && Triple.getVendor() == llvm::Triple::AMD)) {
8531 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
8532 options::OPT_mno_unsafe_fp_atomics);
8533 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
8534 options::OPT_mno_amdgpu_ieee);
8539 if (Args.hasFlag(options::OPT_fdevirtualize_speculatively,
8540 options::OPT_fno_devirtualize_speculatively,
8542 CmdArgs.push_back(
"-fdevirtualize-speculatively");
8544 bool VirtualFunctionElimination =
8545 Args.hasFlag(options::OPT_fvirtual_function_elimination,
8546 options::OPT_fno_virtual_function_elimination,
false);
8547 if (VirtualFunctionElimination) {
8551 D.
Diag(diag::err_drv_argument_only_allowed_with)
8552 <<
"-fvirtual-function-elimination"
8555 CmdArgs.push_back(
"-fvirtual-function-elimination");
8559 bool WholeProgramVTables = Args.hasFlag(
8560 options::OPT_fwhole_program_vtables,
8561 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
8562 if (VirtualFunctionElimination && !WholeProgramVTables) {
8563 D.
Diag(diag::err_drv_argument_not_allowed_with)
8564 <<
"-fno-whole-program-vtables"
8565 <<
"-fvirtual-function-elimination";
8568 if (WholeProgramVTables) {
8582 C.getActiveOffloadKinds()));
8583 auto OtherIsUsingLTO = OtherLTOMode !=
LTOK_None;
8585 if ((!IsUsingLTO && !OtherIsUsingLTO) ||
8587 D.
Diag(diag::err_drv_argument_only_allowed_with)
8588 <<
"-fwhole-program-vtables"
8589 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
8593 CmdArgs.push_back(
"-fwhole-program-vtables");
8596 bool DefaultsSplitLTOUnit =
8597 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
8599 (!Triple.isPS4() && UnifiedLTO);
8601 Args.hasFlag(options::OPT_fsplit_lto_unit,
8602 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
8603 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
8604 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
8605 <<
"-fsanitize=cfi";
8607 CmdArgs.push_back(
"-fsplit-lto-unit");
8609 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
8610 options::OPT_fno_fat_lto_objects)) {
8611 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
8613 if (!Triple.isOSBinFormatELF() && !Triple.isOSBinFormatCOFF()) {
8614 D.
Diag(diag::err_drv_unsupported_opt_for_target)
8617 CmdArgs.push_back(Args.MakeArgString(
8618 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
8619 CmdArgs.push_back(
"-flto-unit");
8620 CmdArgs.push_back(
"-ffat-lto-objects");
8621 A->render(Args, CmdArgs);
8627 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
8628 options::OPT_fno_force_enable_int128)) {
8629 if (A->getOption().matches(options::OPT_fforce_enable_int128))
8630 CmdArgs.push_back(
"-fforce-enable-int128");
8633 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
8634 options::OPT_fno_keep_static_consts);
8635 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
8636 options::OPT_fno_keep_persistent_storage_variables);
8637 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_inline_functions,
8638 options::OPT_fno_keep_inline_functions);
8639 Args.addOptOutFlag(CmdArgs, options::OPT_fmodule_local_hints,
8640 options::OPT_fno_module_local_hints);
8641 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
8642 options::OPT_fno_complete_member_pointers);
8643 if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
8644 A->render(Args, CmdArgs);
8650 if (Triple.isAArch64() &&
8651 (Args.hasArg(options::OPT_mno_fmv) ||
8654 CmdArgs.push_back(
"-target-feature");
8655 CmdArgs.push_back(
"-fmv");
8658 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
8665 CmdArgs.push_back(
"-faddrsig");
8667 const bool HasDefaultDwarf2CFIASM =
8668 (Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
8669 (EH || UnwindTables || AsyncUnwindTables ||
8670 DebugInfoKind != llvm::codegenoptions::NoDebugInfo);
8671 if (Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
8672 options::OPT_fno_dwarf2_cfi_asm, HasDefaultDwarf2CFIASM))
8673 CmdArgs.push_back(
"-fdwarf2-cfi-asm");
8675 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
8676 std::string Str = A->getAsString(Args);
8678 D.
Diag(diag::err_drv_unsupported_opt_for_target)
8680 CmdArgs.push_back(Args.MakeArgString(Str));
8685 if (Output.
getType() == types::TY_Dependencies) {
8688 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
8689 Output.
getType() == clang::driver::types::TY_IFS) {
8691 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
8692 CmdArgs.push_back(
"-o");
8693 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
8695 CmdArgs.push_back(
"-o");
8699 assert(Output.
isNothing() &&
"Invalid output.");
8706 FrontendInputs = ExtractAPIInputs;
8708 FrontendInputs = {};
8710 for (
const InputInfo &Input : FrontendInputs) {
8719 C.addCommand(std::make_unique<CC1Command>(
8723 C.addCommand(std::make_unique<Command>(
8729 if (Output.
getType() == types::TY_Object &&
8730 Args.hasFlag(options::OPT__SLASH_showFilenames,
8731 options::OPT__SLASH_showFilenames_,
false)) {
8732 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
8735 if (Arg *A = Args.getLastArg(options::OPT_pg))
8737 !Args.hasArg(options::OPT_mfentry))
8738 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
8739 << A->getAsString(Args);
8745 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
8749 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8750 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8753 Args.ClaimAllArgs(options::OPT_emit_llvm);