5264 const ArgList &Args,
const char *LinkingOutput)
const {
5266 const llvm::Triple &RawTriple = TC.
getTriple();
5268 const std::string &TripleStr = Triple.getTriple();
5271 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
5273 ArgStringList CmdArgs;
5275 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
5291 bool UsesLLVMOffloading = Args.hasFlag(
5292 options::OPT_foffload_via_llvm, options::OPT_fno_offload_via_llvm,
false);
5295 bool IsHostOffloadingAction =
5301 bool IsRDCMode = Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
5313 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
5317 const InputInfo *OpenMPDeviceInput =
nullptr;
5319 if (&I == &Input || I.
getType() == types::TY_Nothing) {
5321 }
else if (IsExtractAPI) {
5322 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
5323 if (I.getType() != ExpectedInputType) {
5324 D.
Diag(diag::err_drv_extract_api_wrong_kind)
5328 ExtractAPIInputs.push_back(I);
5329 }
else if (IsHostOffloadingAction) {
5330 HostOffloadingInputs.push_back(I);
5331 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
5332 OpenMPDeviceInput = &I;
5334 llvm_unreachable(
"unexpectedly given multiple inputs");
5338 bool IsUEFI = RawTriple.isUEFI();
5339 bool IsIAMCU = RawTriple.isOSIAMCU();
5343 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
5348 CmdArgs.push_back(
"-cc1");
5351 CmdArgs.push_back(
"-triple");
5352 CmdArgs.push_back(Args.MakeArgStringRef(TripleStr));
5354 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
5358 CmdArgs.push_back(
"-aux-triple");
5359 CmdArgs.push_back(Args.MakeArgStringRef(AuxTriple->str()));
5364 IsWindowsMSVC |= AuxTriple->isWindowsMSVCEnvironment();
5371 if (OffloadToolChains.first == OffloadToolChains.second)
5374 const llvm::Triple &DeviceAuxTriple =
5375 OffloadToolChains.first->second->getTriple();
5376 CmdArgs.push_back(
"-aux-triple");
5377 CmdArgs.push_back(Args.MakeArgStringRef(DeviceAuxTriple.str()));
5382 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
5383 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
5384 Args.ClaimAllArgs(options::OPT_MJ);
5385 }
else if (
const Arg *GenCDBFragment =
5386 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
5387 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
5388 TripleStr, Output, Input, Args);
5389 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
5396 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
5397 CmdArgs.push_back(Args.MakeArgString(
5399 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
5402 Args.MakeArgStringRef(
"-Werror=format-invalid-specifier"));
5406 if (IsCuda && !IsCudaDevice && !UsesLLVMOffloading) {
5411 assert(CTC &&
"Expected valid CUDA Toolchain.");
5413 CmdArgs.push_back(Args.MakeArgString(
5414 Twine(
"-target-sdk-version=") +
5419 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
5420 if (A->getOption().matches(options::OPT_O4)) {
5421 CmdArgs.push_back(
"-O3");
5422 D.
Diag(diag::warn_O4_is_O3);
5424 A->render(Args, CmdArgs);
5429 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
5435 CmdArgs.push_back(
"-fsycl-is-device");
5438 if (!Args.getLastArg(options::OPT_O_Group))
5439 CmdArgs.push_back(
"-O2");
5446 CmdArgs.push_back(
"-fsycl-is-host");
5450 Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
5452 SYCLStdArg->render(Args, CmdArgs);
5455 CmdArgs.push_back(
"-sycl-std=2020");
5459 if (Args.hasFlag(options::OPT_fclangir, options::OPT_fno_clangir,
false))
5460 CmdArgs.push_back(
"-fclangir");
5462 if (IsOpenMPDevice) {
5464 const llvm::Triple &HostTriple =
5466 CmdArgs.push_back(
"-aux-triple");
5467 CmdArgs.push_back(HostTriple.str().c_str());
5470 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
5471 Triple.getArch() == llvm::Triple::thumb)) {
5472 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5473 unsigned Version = 0;
5475 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
5477 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
5487 if (Triple.isSPIR() || Triple.isSPIRV())
5488 CmdArgs.push_back(
"-Wspir-compat");
5491 RewriteKind rewriteKind = RK_None;
5493 bool UnifiedLTO =
false;
5495 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5496 options::OPT_fno_unified_lto, Triple.isPS());
5498 CmdArgs.push_back(
"-funified-lto");
5501 if (Args.hasArg(options::OPT_fdefined_pointer_subtraction))
5502 CmdArgs.push_back(
"-fdefined-pointer-subtraction");
5515 Args.ClaimAllArgs(options::OPT_mrelax_all);
5516 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5517 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5518 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5519 switch (
C.getDefaultToolChain().getArch()) {
5520 case llvm::Triple::arm:
5521 case llvm::Triple::armeb:
5522 case llvm::Triple::thumb:
5523 case llvm::Triple::thumbeb:
5524 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5530 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5531 Args.ClaimAllArgs(options::OPT_Xassembler);
5532 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5535 bool IsAMDSPIRVForHIPDevice =
5540 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5541 CmdArgs.push_back(
"-analyze");
5543 if (Output.
getType() == types::TY_Dependencies)
5544 CmdArgs.push_back(
"-Eonly");
5546 CmdArgs.push_back(
"-E");
5547 if (Args.hasArg(options::OPT_rewrite_objc) &&
5548 !Args.hasArg(options::OPT_g_Group))
5549 CmdArgs.push_back(
"-P");
5550 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5551 CmdArgs.push_back(
"-fdirectives-only");
5554 CmdArgs.push_back(
"-emit-obj");
5559 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5561 if (JA.
getType() == types::TY_Nothing)
5562 CmdArgs.push_back(
"-fsyntax-only");
5563 else if (JA.
getType() == types::TY_ModuleFile) {
5564 if (Args.hasArg(options::OPT__precompile_reduced_bmi) ||
5565 ((Input.
getType() == types::TY_CXXStdModule ||
5566 Input.
getType() == types::TY_PP_CXXStdModule) &&
5567 !Args.hasArg(options::OPT_fno_modules_reduced_bmi)))
5568 CmdArgs.push_back(
"-emit-reduced-module-interface");
5570 CmdArgs.push_back(
"-emit-module-interface");
5571 }
else if (JA.
getType() == types::TY_HeaderUnit)
5572 CmdArgs.push_back(
"-emit-header-unit");
5573 else if (!Args.hasArg(options::OPT_ignore_pch))
5574 CmdArgs.push_back(
"-emit-pch");
5576 CmdArgs.push_back(
"-verify-pch");
5578 assert(JA.
getType() == types::TY_API_INFO &&
5579 "Extract API actions must generate a API information.");
5580 CmdArgs.push_back(
"-extract-api");
5582 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5583 PrettySGFArg->render(Args, CmdArgs);
5585 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5587 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5588 ProductNameArg->render(Args, CmdArgs);
5589 if (Arg *ExtractAPIIgnoresFileArg =
5590 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5591 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5592 if (Arg *EmitExtensionSymbolGraphs =
5593 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5594 if (!SymbolGraphDirArg)
5595 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5597 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5599 if (SymbolGraphDirArg)
5600 SymbolGraphDirArg->render(Args, CmdArgs);
5603 "Invalid action for clang tool.");
5604 if (JA.
getType() == types::TY_Nothing) {
5605 CmdArgs.push_back(
"-fsyntax-only");
5606 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5607 JA.
getType() == types::TY_LTO_IR) {
5608 CmdArgs.push_back(
"-emit-llvm");
5609 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5610 JA.
getType() == types::TY_LTO_BC) {
5612 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5613 Args.hasArg(options::OPT_emit_llvm)) {
5614 CmdArgs.push_back(
"-emit-llvm");
5616 CmdArgs.push_back(
"-emit-llvm-bc");
5618 }
else if (JA.
getType() == types::TY_IFS ||
5619 JA.
getType() == types::TY_IFS_CPP) {
5621 Args.hasArg(options::OPT_interface_stub_version_EQ)
5622 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5624 CmdArgs.push_back(
"-emit-interface-stubs");
5626 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr));
5627 }
else if (JA.
getType() == types::TY_PP_Asm) {
5628 CmdArgs.push_back(
"-S");
5629 }
else if (JA.
getType() == types::TY_AST) {
5630 if (!Args.hasArg(options::OPT_ignore_pch))
5631 CmdArgs.push_back(
"-emit-pch");
5632 }
else if (JA.
getType() == types::TY_ModuleFile) {
5633 CmdArgs.push_back(
"-module-file-info");
5634 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5635 CmdArgs.push_back(
"-rewrite-objc");
5636 rewriteKind = RK_NonFragile;
5637 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5638 CmdArgs.push_back(
"-rewrite-objc");
5639 rewriteKind = RK_Fragile;
5640 }
else if (JA.
getType() == types::TY_CIR) {
5641 CmdArgs.push_back(
"-emit-cir");
5642 }
else if (JA.
getType() == types::TY_CIRBC) {
5643 CmdArgs.push_back(
"-emit-cir-bc");
5644 }
else if (JA.
getType() == types::TY_Image && IsAMDSPIRVForHIPDevice) {
5645 CmdArgs.push_back(
"-emit-obj");
5647 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5654 if (JA.
getType() == types::TY_LLVM_BC)
5655 CmdArgs.push_back(
"-emit-llvm-uselists");
5658 const Arg *LTOArg = Args.getLastArg(options::OPT_foffload_lto,
5659 options::OPT_foffload_lto_EQ);
5660 if (Triple.isNVPTX() && !IsRDCMode &&
5662 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5663 << (LTOArg ? LTOArg->getAsString(Args) :
"-foffload-lto")
5667 CmdArgs.push_back(Args.MakeArgString(
5668 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5671 if (!RawTriple.isPS4() || (LTOMode ==
LTOK_Full) || !UnifiedLTO)
5672 CmdArgs.push_back(
"-flto-unit");
5677 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5679 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5681 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5682 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5686 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5687 options::OPT_mno_regnames);
5689 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5690 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5692 if (Args.getLastArg(options::OPT_save_temps_EQ))
5693 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5695 if (Args.getLastArg(options::OPT_save_dynamic_debugging_temps))
5696 Args.AddLastArg(CmdArgs, options::OPT_save_dynamic_debugging_temps);
5698 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5699 options::OPT_fmemory_profile_EQ,
5700 options::OPT_fno_memory_profile);
5702 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5703 MemProfArg->render(Args, CmdArgs);
5705 if (
auto *MemProfUseArg =
5706 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5708 D.
Diag(diag::err_drv_argument_not_allowed_with)
5709 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5710 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5711 options::OPT_fprofile_generate_EQ))
5712 D.
Diag(diag::err_drv_argument_not_allowed_with)
5713 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5714 MemProfUseArg->render(Args, CmdArgs);
5718 Args.getLastArg(options::OPT_fcopyprof, options::OPT_fno_copyprof);
5720 !CopyProfArg->getOption().matches(options::OPT_fno_copyprof)) {
5721 CopyProfArg->render(Args, CmdArgs);
5722 Args.AddLastArg(CmdArgs, options::OPT_fcopyprof_static_size_threshold_EQ);
5727 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5730 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5732 CmdArgs.push_back(
"-disable-llvm-passes");
5740 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5741 options::OPT_mkernel,
5742 options::OPT_fapple_kext,
5743 options::OPT_ffunction_sections,
5744 options::OPT_fno_function_sections,
5745 options::OPT_fdata_sections,
5746 options::OPT_fno_data_sections,
5747 options::OPT_fbasic_block_sections_EQ,
5748 options::OPT_funique_internal_linkage_names,
5749 options::OPT_fno_unique_internal_linkage_names,
5750 options::OPT_funique_section_names,
5751 options::OPT_fno_unique_section_names,
5752 options::OPT_funique_basic_block_section_names,
5753 options::OPT_fno_unique_basic_block_section_names,
5754 options::OPT_mrestrict_it,
5755 options::OPT_mno_restrict_it,
5756 options::OPT_mstackrealign,
5757 options::OPT_mno_stackrealign,
5758 options::OPT_mstack_alignment,
5759 options::OPT_mcmodel_EQ,
5760 options::OPT_mlong_calls,
5761 options::OPT_mno_long_calls,
5762 options::OPT_ggnu_pubnames,
5763 options::OPT_gdwarf_aranges,
5764 options::OPT_fdebug_types_section,
5765 options::OPT_fno_debug_types_section,
5766 options::OPT_fdwarf_directory_asm,
5767 options::OPT_fno_dwarf_directory_asm,
5768 options::OPT_mrelax_all,
5769 options::OPT_mno_relax_all,
5770 options::OPT_ftrap_function_EQ,
5771 options::OPT_ffixed_r9,
5772 options::OPT_mfix_cortex_a53_835769,
5773 options::OPT_mno_fix_cortex_a53_835769,
5774 options::OPT_ffixed_x18,
5775 options::OPT_mglobal_merge,
5776 options::OPT_mno_global_merge,
5777 options::OPT_mred_zone,
5778 options::OPT_mno_red_zone,
5779 options::OPT_Wa_COMMA,
5780 options::OPT_Xassembler,
5784 for (
const auto &A : Args)
5785 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5786 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5789 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5790 options::OPT_fno_optimize_sibling_calls);
5798 case llvm::Triple::arm:
5799 case llvm::Triple::armeb:
5800 case llvm::Triple::thumbeb:
5801 RenderARMABI(D, Triple, Args, CmdArgs);
5803 case llvm::Triple::aarch64:
5804 case llvm::Triple::aarch64_32:
5805 case llvm::Triple::aarch64_be:
5806 RenderAArch64ABI(Triple, Args, CmdArgs);
5811 if (Output.
getType() == types::TY_Dependencies) {
5814 CmdArgs.push_back(
"-o");
5817 assert(Output.
isNothing() &&
"Input output.");
5820 for (
const auto &II : Inputs) {
5822 if (II.isFilename())
5823 CmdArgs.push_back(II.getFilename());
5825 II.getInputArg().renderAsInput(Args, CmdArgs);
5828 C.addCommand(std::make_unique<Command>(
5834 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5835 CmdArgs.push_back(
"-fembed-bitcode=marker");
5840 if (!
C.isForDiagnostics())
5841 CmdArgs.push_back(
"-disable-free");
5842 CmdArgs.push_back(
"-clear-ast-before-backend");
5845 const bool IsAssertBuild =
false;
5847 const bool IsAssertBuild =
true;
5852 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5853 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5854 CmdArgs.push_back(
"-disable-llvm-verifier");
5858 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5859 options::OPT_fno_discard_value_names, !IsAssertBuild))
5860 CmdArgs.push_back(
"-discard-value-names");
5864 CmdArgs.push_back(
"-main-file-name");
5869 if (Args.hasArg(options::OPT_static))
5870 CmdArgs.push_back(
"-static-define");
5872 Args.AddLastArg(CmdArgs, options::OPT_static_libclosure);
5874 if (Args.hasArg(options::OPT_municode))
5875 CmdArgs.push_back(
"-DUNICODE");
5882 CmdArgs.push_back(
"-setup-static-analyzer");
5887 bool FoundAnalyzerConfig =
false;
5888 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5889 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5890 FoundAnalyzerConfig =
true;
5893 if (!FoundAnalyzerConfig)
5894 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5895 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5896 FoundAnalyzerConfig =
true;
5899 if (FoundAnalyzerConfig)
5900 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5905 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5906 if (FunctionAlignment) {
5907 CmdArgs.push_back(
"-function-alignment");
5908 CmdArgs.push_back(Args.MakeArgString(Twine(FunctionAlignment)));
5912 Args.getLastArg(options::OPT_fpreferred_function_alignment_EQ)) {
5914 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5916 << A->getAsString(Args) << A->getValue();
5917 else if (!llvm::isPowerOf2_32(
Value))
5918 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5919 << A->getAsString(Args) << A->getValue();
5921 CmdArgs.push_back(Args.MakeArgString(
"-fpreferred-function-alignment=" +
5922 Twine(std::min(
Value, 65536u))));
5927 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5929 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5931 << A->getAsString(Args) << A->getValue();
5933 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5934 << A->getAsString(Args) << A->getValue();
5937 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5938 Twine(std::min(
Value, 65536u))));
5941 if (Triple.isOSzOS()) {
5950 auto findMacroDefinition = [&](
const std::string &
Macro) {
5951 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5952 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5953 return M ==
Macro || M.find(
Macro +
'=') != std::string::npos;
5958 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5959 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5961 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5962 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5965 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5966 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5970 llvm::Reloc::Model RelocationModel;
5973 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5974 Arg *LastPICDataRelArg =
5975 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5976 options::OPT_mpic_data_is_text_relative);
5977 bool NoPICDataIsTextRelative =
false;
5978 if (LastPICDataRelArg) {
5979 if (LastPICDataRelArg->getOption().matches(
5980 options::OPT_mno_pic_data_is_text_relative)) {
5981 NoPICDataIsTextRelative =
true;
5983 D.
Diag(diag::err_drv_argument_only_allowed_with)
5984 <<
"-mno-pic-data-is-text-relative"
5987 if (!Triple.isSystemZ())
5988 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5989 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5990 :
"-mpic-data-is-text-relative")
5994 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5995 RelocationModel == llvm::Reloc::ROPI_RWPI;
5996 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5997 RelocationModel == llvm::Reloc::ROPI_RWPI;
5999 if (Args.hasArg(options::OPT_mcmse) &&
6000 !Args.hasArg(options::OPT_fallow_unsupported)) {
6002 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
6004 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
6008 !Args.hasArg(options::OPT_fallow_unsupported))
6009 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
6013 CmdArgs.push_back(
"-mrelocation-model");
6014 CmdArgs.push_back(RMName);
6017 CmdArgs.push_back(
"-pic-level");
6018 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
6020 CmdArgs.push_back(
"-pic-is-pie");
6021 if (NoPICDataIsTextRelative)
6022 CmdArgs.push_back(
"-mcmodel=medium");
6025 if (RelocationModel == llvm::Reloc::ROPI ||
6026 RelocationModel == llvm::Reloc::ROPI_RWPI)
6027 CmdArgs.push_back(
"-fropi");
6028 if (RelocationModel == llvm::Reloc::RWPI ||
6029 RelocationModel == llvm::Reloc::ROPI_RWPI)
6030 CmdArgs.push_back(
"-frwpi");
6034 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
6035 StringRef
Value = A->getValue();
6037 CmdArgs.push_back(
"-meabi");
6038 CmdArgs.push_back(A->getValue());
6053 if (Triple.isOSBinFormatELF()) {
6054 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
6055 options::OPT_fno_semantic_interposition);
6056 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
6058 bool SupportsLocalAlias =
6059 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
6061 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
6062 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
6063 A->render(Args, CmdArgs);
6064 else if (!SupportsLocalAlias)
6065 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
6071 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
6073 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
6074 << A->getValue() << A->getAsString(Args);
6075 Model = A->getValue();
6078 if (Model !=
"posix") {
6079 CmdArgs.push_back(
"-mthread-model");
6080 CmdArgs.push_back(Args.MakeArgString(Model));
6084 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6085 StringRef Name = A->getValue();
6086 if (Name ==
"SVML") {
6087 if (Triple.getArch() != llvm::Triple::x86 &&
6088 Triple.getArch() != llvm::Triple::x86_64)
6089 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6090 << Name << Triple.getArchName();
6091 }
else if (Name ==
"AMDLIBM") {
6092 if (Triple.getArch() != llvm::Triple::x86 &&
6093 Triple.getArch() != llvm::Triple::x86_64)
6094 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6095 << Name << Triple.getArchName();
6096 }
else if (Name ==
"libmvec") {
6097 if (Triple.getArch() != llvm::Triple::x86 &&
6098 Triple.getArch() != llvm::Triple::x86_64 &&
6099 Triple.getArch() != llvm::Triple::aarch64 &&
6100 Triple.getArch() != llvm::Triple::aarch64_be)
6101 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6102 << Name << Triple.getArchName();
6103 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
6104 if (Triple.getArch() != llvm::Triple::aarch64 &&
6105 Triple.getArch() != llvm::Triple::aarch64_be && !Triple.isRISCV64())
6106 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6107 << Name << Triple.getArchName();
6109 A->render(Args, CmdArgs);
6112 if (Args.hasFlag(options::OPT_fmerge_all_constants,
6113 options::OPT_fno_merge_all_constants,
false))
6114 CmdArgs.push_back(
"-fmerge-all-constants");
6116 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
6117 options::OPT_fno_delete_null_pointer_checks);
6119 Args.addOptOutFlag(CmdArgs, options::OPT_flifetime_dse,
6120 options::OPT_fno_lifetime_dse);
6124 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
6125 if (!Triple.isOSAIX() || Triple.isPPC32())
6126 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6127 << A->getSpelling() << RawTriple.str();
6128 CmdArgs.push_back(
"-mabi=quadword-atomics");
6131 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
6134 if (Triple.isOSAIX())
6135 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6136 << A->getSpelling() << RawTriple.str();
6139 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
6140 StringRef
V = A->getValue(), V1 =
V;
6142 if (V1.consumeInteger(10, Size) || !V1.empty())
6143 D.
Diag(diag::err_drv_invalid_argument_to_option)
6144 <<
V << A->getOption().getName();
6146 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
6149 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
6150 options::OPT_fno_jump_tables);
6151 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
6152 options::OPT_fno_profile_sample_accurate);
6153 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
6154 options::OPT_fno_preserve_as_comments);
6156 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
6157 CmdArgs.push_back(
"-mregparm");
6158 CmdArgs.push_back(A->getValue());
6161 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
6162 options::OPT_msvr4_struct_return)) {
6164 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6165 << A->getSpelling() << RawTriple.str();
6166 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
6167 CmdArgs.push_back(
"-maix-struct-return");
6169 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
6170 CmdArgs.push_back(
"-msvr4-struct-return");
6174 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
6175 options::OPT_freg_struct_return)) {
6176 if (TC.
getArch() != llvm::Triple::x86) {
6177 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6178 << A->getSpelling() << RawTriple.str();
6179 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
6180 CmdArgs.push_back(
"-fpcc-struct-return");
6182 assert(A->getOption().matches(options::OPT_freg_struct_return));
6183 CmdArgs.push_back(
"-freg-struct-return");
6187 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
6188 if (Triple.getArch() == llvm::Triple::m68k)
6189 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
6191 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
6194 if (Args.hasArg(options::OPT_fenable_matrix)) {
6196 CmdArgs.push_back(
"-fenable-matrix");
6197 CmdArgs.push_back(
"-mllvm");
6198 CmdArgs.push_back(
"-enable-matrix");
6200 if (
const Arg *A = Args.getLastArg(options::OPT_fmatrix_memory_layout_EQ)) {
6201 StringRef Val = A->getValue();
6202 if (Val ==
"row-major" || Val ==
"column-major") {
6203 CmdArgs.push_back(Args.MakeArgString(
"-fmatrix-memory-layout=" + Val));
6204 CmdArgs.push_back(
"-mllvm");
6205 CmdArgs.push_back(Args.MakeArgString(
"-matrix-default-layout=" + Val));
6208 D.
Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
6215 const char *FPKeepKindStr =
nullptr;
6216 switch (FPKeepKind) {
6218 FPKeepKindStr =
"-mframe-pointer=none";
6221 FPKeepKindStr =
"-mframe-pointer=reserved";
6224 FPKeepKindStr =
"-mframe-pointer=non-leaf-no-reserve";
6227 FPKeepKindStr =
"-mframe-pointer=non-leaf";
6230 FPKeepKindStr =
"-mframe-pointer=all";
6233 assert(FPKeepKindStr &&
"unknown FramePointerKind");
6234 CmdArgs.push_back(FPKeepKindStr);
6236 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
6237 options::OPT_fno_zero_initialized_in_bss);
6240 if (Args.hasArg(options::OPT_Ofast))
6241 D.
Diag(diag::warn_drv_deprecated_arg_ofast);
6244 OptSpecifier StrictAliasingAliasOption =
6245 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
6248 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
6249 options::OPT_fno_strict_aliasing,
6250 !IsWindowsMSVC && !IsUEFI))
6251 CmdArgs.push_back(
"-relaxed-aliasing");
6252 if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
6254 CmdArgs.push_back(
"-no-pointer-tbaa");
6255 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
6256 options::OPT_fno_struct_path_tbaa,
true))
6257 CmdArgs.push_back(
"-no-struct-path-tbaa");
6259 if (Arg *A = Args.getLastArg(options::OPT_fstrict_bool,
6260 options::OPT_fno_strict_bool,
6261 options::OPT_fno_strict_bool_EQ)) {
6263 if (A->getOption().matches(options::OPT_fstrict_bool))
6265 else if (A->getOption().matches(options::OPT_fno_strict_bool))
6267 else if (A->getValue() == StringRef(
"truncate"))
6269 else if (A->getValue() == StringRef(
"nonzero"))
6272 D.
Diag(diag::err_drv_invalid_value)
6273 << A->getAsString(Args) << A->getValue();
6274 CmdArgs.push_back(Args.MakeArgString(
"-load-bool-from-mem=" + BFM));
6275 }
else if (KernelOrKext) {
6277 CmdArgs.push_back(
"-load-bool-from-mem=truncate");
6280 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
6281 options::OPT_fno_strict_enums);
6282 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
6283 options::OPT_fno_strict_return);
6284 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
6285 options::OPT_fno_allow_editor_placeholders);
6286 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
6287 options::OPT_fno_strict_vtable_pointers);
6288 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
6289 options::OPT_fno_force_emit_vtables);
6290 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
6291 options::OPT_fno_optimize_sibling_calls);
6292 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
6293 options::OPT_fno_escaping_block_tail_calls);
6295 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
6296 options::OPT_fno_fine_grained_bitfield_accesses);
6298 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6299 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6301 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6302 options::OPT_fno_experimental_omit_vtable_rtti);
6304 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
6305 options::OPT_fno_disable_block_signature_string);
6308 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
6309 options::OPT_fno_split_stack);
6312 if (Args.hasFlag(options::OPT_fprotect_parens,
6313 options::OPT_fno_protect_parens,
false))
6314 CmdArgs.push_back(
"-fprotect-parens");
6318 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_remote_memory,
6319 options::OPT_fno_atomic_remote_memory);
6320 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_fine_grained_memory,
6321 options::OPT_fno_atomic_fine_grained_memory);
6322 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_ignore_denormal_mode,
6323 options::OPT_fno_atomic_ignore_denormal_mode);
6325 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
6327 if (
Arch == llvm::Triple::x86 ||
Arch == llvm::Triple::x86_64) {
6328 StringRef
V = A->getValue();
6330 CmdArgs.push_back(
"-fextend-arguments=64");
6332 D.
Diag(diag::err_drv_invalid_argument_to_option)
6333 << A->getValue() << A->getOption().getName();
6335 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6336 << A->getOption().getName() << TripleStr;
6339 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
6340 if (TC.
getArch() == llvm::Triple::avr)
6341 A->render(Args, CmdArgs);
6343 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6344 << A->getAsString(Args) << TripleStr;
6347 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
6349 A->render(Args, CmdArgs);
6351 (A->getOption().getID() != options::OPT_mlong_double_80))
6352 A->render(Args, CmdArgs);
6354 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6355 << A->getAsString(Args) << TripleStr;
6361 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
6362 IsIntegratedAssemblerDefault))
6363 CmdArgs.push_back(
"-fno-verbose-asm");
6367 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
6368 StringRef
V = A->getValue();
6371 A->render(Args, CmdArgs);
6372 else if (!
V.consumeInteger(10,
Num) &&
Num > 0 &&
6373 (
V.empty() || (
V.consume_front(
".") &&
6374 !
V.consumeInteger(10,
Num) &&
V.empty())))
6375 A->render(Args, CmdArgs);
6377 D.
Diag(diag::err_drv_invalid_argument_to_option)
6378 << A->getValue() << A->getOption().getName();
6384 CmdArgs.push_back(
"-no-integrated-as");
6386 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
6387 CmdArgs.push_back(
"-mdebug-pass");
6388 CmdArgs.push_back(
"Structure");
6390 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
6391 CmdArgs.push_back(
"-mdebug-pass");
6392 CmdArgs.push_back(
"Arguments");
6398 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
6399 CmdArgs.push_back(
"-mconstructor-aliases");
6403 if (KernelOrKext && RawTriple.isOSDarwin())
6404 CmdArgs.push_back(
"-fforbid-guard-variables");
6406 if (Arg *A = Args.getLastArg(options::OPT_mms_bitfields,
6407 options::OPT_mno_ms_bitfields)) {
6408 if (A->getOption().matches(options::OPT_mms_bitfields))
6409 CmdArgs.push_back(
"-fms-layout-compatibility=microsoft");
6411 CmdArgs.push_back(
"-fms-layout-compatibility=itanium");
6414 if (Triple.isOSCygMing()) {
6415 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
6416 options::OPT_fno_auto_import);
6419 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
6420 Triple.isX86() && IsWindowsMSVC))
6421 CmdArgs.push_back(
"-fms-volatile");
6426 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
6427 options::OPT_fno_direct_access_external_data)) {
6428 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
6430 A->render(Args, CmdArgs);
6431 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
6434 CmdArgs.push_back(
"-fno-direct-access-external-data");
6437 if (Triple.isOSBinFormatELF() && (Triple.isAArch64() || Triple.isX86()))
6438 Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);
6444 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
6447 CmdArgs.push_back(
"-ffreestanding");
6449 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
6454 Args.AddLastArg(CmdArgs,
6455 options::OPT_fallow_runtime_check_skip_hot_cutoff_EQ);
6460 bool IsAsyncUnwindTablesDefault =
6462 bool IsSyncUnwindTablesDefault =
6465 bool AsyncUnwindTables = Args.hasFlag(
6466 options::OPT_fasynchronous_unwind_tables,
6467 options::OPT_fno_asynchronous_unwind_tables,
6468 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
6471 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
6472 IsSyncUnwindTablesDefault && !Freestanding);
6473 if (AsyncUnwindTables)
6474 CmdArgs.push_back(
"-funwind-tables=2");
6475 else if (UnwindTables)
6476 CmdArgs.push_back(
"-funwind-tables=1");
6480 if (Arg *A = Args.getLastArg(options::OPT_gsframe)) {
6481 if (Triple.isOSBinFormatELF() && Triple.isX86())
6482 CmdArgs.push_back(
"--gsframe");
6484 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6485 << A->getOption().getName() << TripleStr;
6490 if (AuxTriple && !Args.getLastArg(options::OPT_gpu_use_aux_triple_only)) {
6491 const ArgList &HostArgs =
6493 std::string HostCPU =
getCPUName(D, HostArgs, *AuxTriple,
false);
6494 if (!HostCPU.empty()) {
6495 CmdArgs.push_back(
"-aux-target-cpu");
6496 CmdArgs.push_back(Args.MakeArgString(HostCPU));
6505 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
6507 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
6508 StringRef
Value = A->getValue();
6509 unsigned TLSSize = 0;
6510 Value.getAsInteger(10, TLSSize);
6511 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
6512 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6513 << A->getOption().getName() << TripleStr;
6514 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
6515 D.
Diag(diag::err_drv_invalid_int_value)
6516 << A->getOption().getName() <<
Value;
6517 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6521 CmdArgs.push_back(
"-enable-tlsdesc");
6524 std::string CPU =
getCPUName(D, Args, Triple,
false);
6526 CmdArgs.push_back(
"-target-cpu");
6527 CmdArgs.push_back(Args.MakeArgString(CPU));
6530 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6535 AddClangCLArgs(Args, InputType, CmdArgs);
6537 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6538 llvm::codegenoptions::NoDebugInfo;
6541 DebugInfoKind, DwarfFission, IsUsingLTO);
6552 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6553 CmdArgs.push_back(
"-split-dwarf-file");
6554 CmdArgs.push_back(SplitDWARFOut);
6556 CmdArgs.push_back(
"-split-dwarf-output");
6557 CmdArgs.push_back(SplitDWARFOut);
6562 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6563 CmdArgs.push_back(
"-target-linker-version");
6564 CmdArgs.push_back(A->getValue());
6569 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6571 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6572 TC.
getArch() == llvm::Triple::x86) {
6573 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6574 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6575 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6576 << Unsupported->getOption().getName();
6579 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6580 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6581 << Unsupported->getOption().getName()
6582 <<
"please use -maltivec and include altivec.h explicitly";
6583 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6584 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6585 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6588 Args.AddAllArgs(CmdArgs, options::OPT_v);
6590 if (Args.getLastArg(options::OPT_H)) {
6591 CmdArgs.push_back(
"-H");
6592 CmdArgs.push_back(
"-sys-header-deps");
6594 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6597 CmdArgs.push_back(
"-header-include-file");
6601 CmdArgs.push_back(
"-sys-header-deps");
6602 CmdArgs.push_back(Args.MakeArgString(
6603 "-header-include-format=" +
6605 CmdArgs.push_back(Args.MakeArgString(
6606 "-header-include-filtering=" +
6609 Args.AddLastArg(CmdArgs, options::OPT_P);
6610 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6613 CmdArgs.push_back(
"-diagnostic-log-file");
6622 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6626 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6627 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6628 CmdArgs.push_back(
"-mllvm");
6629 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6634 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6635 options::OPT_fno_basic_block_address_map)) {
6636 if (((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) ||
6637 (Triple.isX86() && Triple.isOSBinFormatCOFF())) {
6638 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6639 A->render(Args, CmdArgs);
6641 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6642 << A->getAsString(Args) << TripleStr;
6646 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6647 StringRef Val = A->getValue();
6648 if (Val ==
"labels") {
6649 D.
Diag(diag::warn_drv_deprecated_arg)
6650 << A->getAsString(Args) <<
true
6651 <<
"-fbasic-block-address-map";
6652 CmdArgs.push_back(
"-fbasic-block-address-map");
6653 }
else if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6654 if (Val !=
"all" && Val !=
"none" && !Val.starts_with(
"list="))
6655 D.
Diag(diag::err_drv_invalid_value)
6656 << A->getAsString(Args) << A->getValue();
6658 A->render(Args, CmdArgs);
6659 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6662 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6663 D.
Diag(diag::err_drv_invalid_value)
6664 << A->getAsString(Args) << A->getValue();
6666 A->render(Args, CmdArgs);
6667 }
else if (Triple.isNVPTX()) {
6670 }
else if (Val !=
"none") {
6673 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6674 << A->getAsString(Args) << TripleStr;
6678 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6679 options::OPT_fno_unique_section_names);
6680 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6681 options::OPT_fno_separate_named_sections);
6682 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6683 options::OPT_fno_unique_internal_linkage_names);
6684 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6685 options::OPT_fno_unique_basic_block_section_names);
6690 Args.getLastArg(options::OPT_fpartition_static_data_sections,
6691 options::OPT_fno_partition_static_data_sections)) {
6692 if (!A->getOption().matches(
6693 options::OPT_fno_partition_static_data_sections)) {
6695 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6696 A->render(Args, CmdArgs);
6697 CmdArgs.push_back(
"-mllvm");
6698 CmdArgs.push_back(
"-memprof-annotate-static-data-prefix");
6700 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6701 << A->getAsString(Args) << TripleStr;
6705 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6706 options::OPT_finstrument_functions_after_inlining,
6707 options::OPT_finstrument_function_entry_bare);
6708 Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6709 options::OPT_fno_convergent_functions);
6712 if (!Triple.isNVPTX())
6715 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6718 Args.hasFlag(options::OPT_fsample_profile_use_profi,
6719 options::OPT_fno_sample_profile_use_profi,
true)) {
6720 CmdArgs.push_back(
"-mllvm");
6721 CmdArgs.push_back(
"-sample-profile-use-profi");
6725 if (RawTriple.isPS() &&
6726 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6732 if (Args.hasArg(options::OPT_nostdinc)) {
6733 CmdArgs.push_back(
"-nostdsysteminc");
6734 CmdArgs.push_back(
"-nobuiltininc");
6736 if (Args.hasArg(options::OPT_nostdlibinc))
6737 CmdArgs.push_back(
"-nostdsysteminc");
6738 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6739 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6743 CmdArgs.push_back(
"-resource-dir");
6746 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6753 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6759 Args.ClaimAllArgs(options::OPT_D);
6763 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6764 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6769 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6770 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6776 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6779 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6781 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6782 unsigned WarningNumber;
6783 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6784 D.
Diag(diag::err_drv_invalid_int_value)
6785 << A->getAsString(Args) << A->getValue();
6790 CmdArgs.push_back(Args.MakeArgString(
6795 A->render(Args, CmdArgs);
6798 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6800 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6801 CmdArgs.push_back(
"-pedantic");
6802 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6803 Args.AddLastArg(CmdArgs, options::OPT_w);
6805 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6806 options::OPT_fno_fixed_point);
6808 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_overflow_behavior_types,
6809 options::OPT_fno_experimental_overflow_behavior_types);
6811 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6812 A->render(Args, CmdArgs);
6814 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6815 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6817 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6818 options::OPT_fno_experimental_omit_vtable_rtti);
6820 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6821 A->render(Args, CmdArgs);
6828 bool ImplyVCPPCVer =
false;
6829 bool ImplyVCPPCXXVer =
false;
6830 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6832 if (Std->getOption().matches(options::OPT_ansi))
6834 CmdArgs.push_back(
"-std=c++98");
6836 CmdArgs.push_back(
"-std=c89");
6844 D.
Diag(diag::err_drv_argument_not_allowed_with)
6845 << Std->getAsString(Args) <<
"-fsycl";
6848 D.
Diag(diag::err_drv_sycl_requires_cxx17) << Std->getAsString(Args);
6851 Std->render(Args, CmdArgs);
6855 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6856 options::OPT_ftrigraphs,
6857 options::OPT_fno_trigraphs))
6859 A->render(Args, CmdArgs);
6868 if (!Args.hasArg(options::OPT__SLASH_std)) {
6869 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6872 ImplyVCPPCVer =
true;
6874 else if (IsWindowsMSVC)
6875 ImplyVCPPCXXVer =
true;
6878 !Args.hasArg(options::OPT__SLASH_std) && !IsWindowsMSVC)
6882 CmdArgs.push_back(
"-std=c++17");
6884 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6885 options::OPT_fno_trigraphs);
6901 Args.getLastArg(options::OPT_Wwrite_strings,
6902 options::OPT_Wno_write_strings, options::OPT_w);
6904 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6905 CmdArgs.push_back(
"-fconst-strings");
6912 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6914 CmdArgs.push_back(
"-fdeprecated-macro");
6918 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6919 if (
Asm->getOption().matches(options::OPT_fasm))
6920 CmdArgs.push_back(
"-fgnu-keywords");
6922 CmdArgs.push_back(
"-fno-gnu-keywords");
6926 CmdArgs.push_back(
"-fno-autolink");
6928 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6929 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6930 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6931 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6933 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6935 if (CLANG_USE_EXPERIMENTAL_CONST_INTERP) {
6936 Args.ClaimAllArgs(options::OPT_fexperimental_new_constant_interpreter);
6937 Args.AddLastArg(CmdArgs,
6938 options::OPT_fno_experimental_new_constant_interpreter);
6940 Args.ClaimAllArgs(options::OPT_fno_experimental_new_constant_interpreter);
6941 Args.AddLastArg(CmdArgs,
6942 options::OPT_fexperimental_new_constant_interpreter);
6945 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6946 CmdArgs.push_back(
"-fbracket-depth");
6947 CmdArgs.push_back(A->getValue());
6950 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6951 options::OPT_Wlarge_by_value_copy_def)) {
6952 if (A->getNumValues()) {
6953 StringRef
bytes = A->getValue();
6954 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6956 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6959 if (Args.hasArg(options::OPT_relocatable_pch))
6960 CmdArgs.push_back(
"-relocatable-pch");
6961 Args.AddLastArg(CmdArgs, options::OPT_fpch_base_dir_is_cwd);
6963 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6964 static const char *kCFABIs[] = {
6965 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6968 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6969 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6971 A->render(Args, CmdArgs);
6974 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6975 CmdArgs.push_back(
"-fconstant-string-class");
6976 CmdArgs.push_back(A->getValue());
6979 if (Arg *A = Args.getLastArg(options::OPT_fconstant_array_class_EQ)) {
6980 CmdArgs.push_back(
"-fconstant-array-class");
6981 CmdArgs.push_back(A->getValue());
6983 if (Arg *A = Args.getLastArg(options::OPT_fconstant_dictionary_class_EQ)) {
6984 CmdArgs.push_back(
"-fconstant-dictionary-class");
6985 CmdArgs.push_back(A->getValue());
6988 Args.getLastArg(options::OPT_fconstant_integer_number_class_EQ)) {
6989 CmdArgs.push_back(
"-fconstant-integer-number-class");
6990 CmdArgs.push_back(A->getValue());
6992 if (Arg *A = Args.getLastArg(options::OPT_fconstant_float_number_class_EQ)) {
6993 CmdArgs.push_back(
"-fconstant-float-number-class");
6994 CmdArgs.push_back(A->getValue());
6996 if (Arg *A = Args.getLastArg(options::OPT_fconstant_double_number_class_EQ)) {
6997 CmdArgs.push_back(
"-fconstant-double-number-class");
6998 CmdArgs.push_back(A->getValue());
7001 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
7002 CmdArgs.push_back(
"-ftabstop");
7003 CmdArgs.push_back(A->getValue());
7006 if (Args.hasFlag(options::OPT_fexperimental_call_graph_section,
7007 options::OPT_fno_experimental_call_graph_section,
false))
7008 CmdArgs.push_back(
"-fexperimental-call-graph-section");
7010 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
7011 options::OPT_fno_stack_size_section);
7013 if (Args.hasArg(options::OPT_fstack_usage)) {
7014 CmdArgs.push_back(
"-stack-usage-file");
7016 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
7018 llvm::sys::path::replace_extension(OutputFilename,
"su");
7019 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7025 CmdArgs.push_back(
"-ferror-limit");
7026 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
7027 CmdArgs.push_back(A->getValue());
7029 CmdArgs.push_back(
"19");
7031 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
7032 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
7033 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
7034 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
7035 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
7038 unsigned MessageLength = 0;
7039 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
7040 StringRef
V(A->getValue());
7041 if (
V.getAsInteger(0, MessageLength))
7042 D.
Diag(diag::err_drv_invalid_argument_to_option)
7043 <<
V << A->getOption().getName();
7047 MessageLength = llvm::sys::Process::StandardErrColumns();
7049 if (MessageLength != 0)
7051 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
7053 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
7055 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
7057 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
7058 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
7059 Twine(A->getValue(0))));
7062 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
7063 options::OPT_fvisibility_ms_compat)) {
7064 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
7065 A->render(Args, CmdArgs);
7067 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
7068 CmdArgs.push_back(
"-fvisibility=hidden");
7069 CmdArgs.push_back(
"-ftype-visibility=default");
7071 }
else if (IsOpenMPDevice) {
7075 CmdArgs.push_back(
"-fvisibility=protected");
7079 if (!RawTriple.isPS()) {
7081 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
7082 options::OPT_fno_visibility_from_dllstorageclass)) {
7083 if (A->getOption().matches(
7084 options::OPT_fvisibility_from_dllstorageclass)) {
7085 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
7086 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
7087 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
7088 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
7089 Args.AddLastArg(CmdArgs,
7090 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
7095 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
7096 options::OPT_fno_visibility_inlines_hidden,
false))
7097 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
7099 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
7100 options::OPT_fno_visibility_inlines_hidden_static_local_var);
7105 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
7106 D.
Diag(diag::warn_drv_deprecated_arg)
7107 << A->getAsString(Args) <<
true
7108 <<
"-fvisibility-global-new-delete=force-hidden";
7112 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
7113 options::OPT_fvisibility_global_new_delete_hidden)) {
7114 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
7115 A->render(Args, CmdArgs);
7117 assert(A->getOption().matches(
7118 options::OPT_fvisibility_global_new_delete_hidden));
7119 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
7123 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
7125 if (Args.hasFlag(options::OPT_fnew_infallible,
7126 options::OPT_fno_new_infallible,
false))
7127 CmdArgs.push_back(
"-fnew-infallible");
7129 if (Args.hasFlag(options::OPT_fno_operator_names,
7130 options::OPT_foperator_names,
false))
7131 CmdArgs.push_back(
"-fno-operator-names");
7134 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
7135 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
7136 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
7137 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
7138 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
7139 options::OPT_fno_raw_string_literals);
7141 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
7142 Triple.hasDefaultEmulatedTLS()))
7143 CmdArgs.push_back(
"-femulated-tls");
7145 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
7146 options::OPT_fno_check_new);
7148 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
7152 if (!Triple.isX86() && !Triple.isAArch64() && !Triple.isRISCV())
7153 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7154 << A->getAsString(Args) << TripleStr;
7159 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
7161 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
7162 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
7166 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
7167 options::OPT_fno_openmp,
false) &&
7168 !Args.hasFlag(options::OPT_foffload_via_llvm,
7169 options::OPT_fno_offload_via_llvm,
false) &&
7174 bool TargetFastUsed =
7175 Args.hasFlag(options::OPT_fopenmp_target_fast,
7176 options::OPT_fno_openmp_target_fast, OFastEnabled);
7181 CmdArgs.push_back(
"-fopenmp");
7186 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
7187 options::OPT_fnoopenmp_use_tls,
true))
7188 CmdArgs.push_back(
"-fnoopenmp-use-tls");
7189 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
7190 options::OPT_fno_openmp_simd);
7191 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
7192 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
7193 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
7194 options::OPT_fno_openmp_extensions,
true))
7195 CmdArgs.push_back(
"-fno-openmp-extensions");
7196 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
7197 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
7203 if (Arg *A = Args.getLastArg(
7204 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ))
7205 D.
Diag(diag::warn_drv_deprecated_custom)
7206 << A->getAsString(Args)
7207 <<
"the value is ignored; the teams reduction buffer is sized "
7208 "automatically at kernel launch";
7209 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
7210 options::OPT_fno_openmp_optimistic_collapse,
7212 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
7216 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
7217 options::OPT_fno_openmp_cuda_mode,
false))
7218 CmdArgs.push_back(
"-fopenmp-cuda-mode");
7221 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
7222 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
7223 options::OPT_fno_openmp_target_debug,
false))
7224 CmdArgs.push_back(
"-fopenmp-target-debug");
7228 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
7229 options::OPT_fno_openmp_assume_teams_oversubscription,
7231 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
7232 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
7233 options::OPT_fno_openmp_assume_threads_oversubscription,
7235 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
7238 if (Args.hasFlag(options::OPT_fopenmp_assume_no_thread_state,
7239 options::OPT_fno_openmp_assume_no_thread_state,
7241 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
7244 if (Args.hasFlag(options::OPT_fopenmp_assume_no_nested_parallelism,
7245 options::OPT_fno_openmp_assume_no_nested_parallelism,
7247 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
7250 if (Args.hasFlag(options::OPT_fopenmp_target_atomic_reduction,
7251 options::OPT_fno_openmp_target_atomic_reduction,
7253 CmdArgs.push_back(
"-fopenmp-target-atomic-reduction");
7255 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
7256 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
7257 if (Args.hasArg(options::OPT_fopenmp_force_usm))
7258 CmdArgs.push_back(
"-fopenmp-force-usm");
7270 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
7271 options::OPT_fno_openmp_simd);
7272 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
7273 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
7274 options::OPT_fno_openmp_extensions);
7278 if (Args.hasFlag(options::OPT_foffload_via_llvm,
7279 options::OPT_fno_offload_via_llvm,
false))
7280 CmdArgs.push_back(
"-foffload-via-llvm");
7283 XRay.
addArgs(TC, Args, CmdArgs, InputType);
7285 for (
const auto &Filename :
7286 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
7287 if (D.
getVFS().exists(Filename))
7288 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" + Filename));
7290 D.
Diag(clang::diag::err_drv_no_such_file) << Filename;
7293 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
7294 StringRef S0 = A->getValue(), S = S0;
7295 unsigned Size, Offset = 0;
7296 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
7297 !Triple.isX86() && !Triple.isSystemZ() &&
7298 !(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||
7299 Triple.getArch() == llvm::Triple::ppc64 ||
7300 Triple.getArch() == llvm::Triple::ppc64le)))
7301 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7302 << A->getAsString(Args) << TripleStr;
7303 else if (S.consumeInteger(10, Size) ||
7305 (!S.consume_front(
",") || S.consumeInteger(10, Offset))) ||
7306 (!S.empty() && (!S.consume_front(
",") || S.empty())))
7307 D.
Diag(diag::err_drv_invalid_argument_to_option)
7308 << S0 << A->getOption().getName();
7309 else if (Size < Offset)
7310 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
7312 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
7313 CmdArgs.push_back(Args.MakeArgString(
7314 "-fpatchable-function-entry-offset=" + Twine(Offset)));
7317 Args.MakeArgString(
"-fpatchable-function-entry-section=" + S));
7321 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
7323 if (Args.hasArg(options::OPT_fms_secure_hotpatch_functions_file))
7324 Args.AddLastArg(CmdArgs, options::OPT_fms_secure_hotpatch_functions_file);
7326 for (
const auto &A :
7327 Args.getAllArgValues(options::OPT_fms_secure_hotpatch_functions_list))
7329 Args.MakeArgString(
"-fms-secure-hotpatch-functions-list=" + Twine(A)));
7332 Args.AddLastArg(CmdArgs, options::OPT_pg);
7335 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
7336 if (
Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
7337 A->render(Args, CmdArgs);
7339 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7340 << A->getAsString(Args) << TripleStr;
7342 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
7343 if (
Arch == llvm::Triple::systemz ||
7345 A->render(Args, CmdArgs);
7347 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7348 << A->getAsString(Args) << TripleStr;
7350 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
7351 if (
Arch == llvm::Triple::systemz ||
7353 A->render(Args, CmdArgs);
7355 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7356 << A->getAsString(Args) << TripleStr;
7360 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
7362 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7363 << A->getAsString(Args) << TripleStr;
7366 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
7368 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7369 << A->getAsString(Args) << TripleStr;
7372 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
7373 if (A->getOption().matches(options::OPT_p)) {
7375 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
7376 CmdArgs.push_back(
"-pg");
7382 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
7383 options::OPT_mxcoff_build_id_EQ)) {
7384 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7385 << A->getSpelling() << TripleStr;
7389 if (Args.getLastArg(options::OPT_fapple_kext) ||
7390 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
7391 CmdArgs.push_back(
"-fapple-kext");
7393 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
7394 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
7395 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
7396 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
7397 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
7398 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
7399 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
7400 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_json);
7401 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
7402 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
7403 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
7405 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
7406 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
7407 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
7408 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
7409 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_compress_EQ);
7412 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
7413 CmdArgs.push_back(
"-ftrapv-handler");
7414 CmdArgs.push_back(A->getValue());
7417 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
7419 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
7420 options::OPT_fno_finite_loops);
7422 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
7423 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
7424 options::OPT_fno_unroll_loops);
7425 Args.AddLastArg(CmdArgs, options::OPT_floop_interchange,
7426 options::OPT_fno_loop_interchange);
7427 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_loop_fusion,
7428 options::OPT_fno_experimental_loop_fusion);
7430 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
7432 Args.AddLastArg(CmdArgs, options::OPT_pthread);
7434 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
7435 options::OPT_mno_speculative_load_hardening);
7441 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
7443 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
7444 options::OPT_mno_stackrealign);
7446 if (
const Arg *A = Args.getLastArg(options::OPT_mstack_alignment)) {
7447 StringRef
Value = A->getValue();
7448 int64_t Alignment = 0;
7449 if (
Value.getAsInteger(10, Alignment) || Alignment < 0)
7450 D.
Diag(diag::err_drv_invalid_argument_to_option)
7451 <<
Value << A->getOption().getName();
7452 else if (Alignment & (Alignment - 1))
7453 D.
Diag(diag::err_drv_alignment_not_power_of_two)
7454 << A->getAsString(Args) <<
Value;
7456 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" +
Value));
7459 if (Args.hasArg(options::OPT_mstack_probe_size)) {
7460 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
7463 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
7465 CmdArgs.push_back(
"-mstack-probe-size=0");
7468 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
7469 options::OPT_mno_stack_arg_probe);
7471 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
7472 options::OPT_mno_restrict_it)) {
7473 if (A->getOption().matches(options::OPT_mrestrict_it)) {
7474 CmdArgs.push_back(
"-mllvm");
7475 CmdArgs.push_back(
"-arm-restrict-it");
7477 CmdArgs.push_back(
"-mllvm");
7478 CmdArgs.push_back(
"-arm-default-it");
7492 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
7493 options::OPT_fno_hip_new_launch_api,
true))
7494 CmdArgs.push_back(
"-fhip-new-launch-api");
7495 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
7496 options::OPT_fno_gpu_allow_device_init);
7497 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
7498 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
7499 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
7500 options::OPT_fno_hip_kernel_arg_name);
7502 TC.
getTriple().getVendor() == llvm::Triple::VendorType::AMD)
7503 Args.addLastArg(CmdArgs, options::OPT_fenable_spirv_size_optimization);
7506 if ((IsCuda || IsHIP || IsSYCL) && IsRDCMode)
7507 CmdArgs.push_back(
"-fgpu-rdc");
7509 if (IsCuda || IsHIP) {
7510 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
7511 options::OPT_fno_gpu_defer_diag);
7512 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
7513 options::OPT_fno_gpu_exclude_wrong_side_overloads,
7515 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
7516 CmdArgs.push_back(
"-fgpu-defer-diag");
7521 if (!Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
true))
7522 CmdArgs.push_back(
"--no-offloadlib");
7524 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
7526 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
7528 if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
7529 CmdArgs.push_back(Args.MakeArgString(Twine(
"-mcf-branch-label-scheme=") +
7531 }
else if (Triple.isOSOpenBSD() && Triple.getArch() == llvm::Triple::x86_64) {
7533 CmdArgs.push_back(
"-fcf-protection=branch");
7535 CmdArgs.push_back(
"-fno-jump-tables");
7538 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
7540 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
7542 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
7547 if (!(IsCudaDevice || IsHIPDevice)) {
7549 auto *PGOArg = Args.getLastArg(
7550 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
7551 options::OPT_fcs_profile_generate,
7552 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
7553 options::OPT_fprofile_use_EQ);
7555 D.
Diag(diag::err_drv_argument_not_allowed_with)
7556 <<
"SampleUse with PGO options";
7558 StringRef fname = A->getValue();
7559 if (!llvm::sys::fs::exists(fname))
7560 D.
Diag(diag::err_drv_no_such_file) << fname;
7562 A->render(Args, CmdArgs);
7564 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
7566 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
7567 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
7568 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
7571 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
7572 options::OPT_fno_unique_internal_linkage_names,
true))
7573 CmdArgs.push_back(
"-funique-internal-linkage-names");
7578 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7579 options::OPT_fno_assume_sane_operator_new);
7581 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
7582 CmdArgs.push_back(
"-fapinotes");
7583 if (Args.hasFlag(options::OPT_fapinotes_modules,
7584 options::OPT_fno_apinotes_modules,
false))
7585 CmdArgs.push_back(
"-fapinotes-modules");
7586 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
7588 if (Args.hasFlag(options::OPT_fswift_version_independent_apinotes,
7589 options::OPT_fno_swift_version_independent_apinotes,
false))
7590 CmdArgs.push_back(
"-fswift-version-independent-apinotes");
7593 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
7595 (Args.hasArg(options::OPT_fgnu_runtime) &&
7596 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
7597 !Args.hasArg(options::OPT_fno_blocks))) {
7598 CmdArgs.push_back(
"-fblocks");
7601 CmdArgs.push_back(
"-fblocks-runtime-optional");
7606 CmdArgs.push_back(
"-fencode-extended-block-signature");
7608 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7609 options::OPT_fno_coro_aligned_allocation,
false) &&
7611 CmdArgs.push_back(
"-fcoro-aligned-allocation");
7613 if (Args.hasFlag(options::OPT_fdefer_ts, options::OPT_fno_defer_ts,
7615 CmdArgs.push_back(
"-fdefer-ts");
7617 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7618 options::OPT_fno_double_square_bracket_attributes);
7620 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7621 options::OPT_fno_access_control);
7622 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7623 options::OPT_fno_elide_constructors);
7629 CmdArgs.push_back(
"-fno-rtti");
7632 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7633 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
7634 CmdArgs.push_back(
"-fshort-enums");
7640 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
7641 !RawTriple.isOSAIX() &&
7642 (!RawTriple.isOSWindows() ||
7643 RawTriple.isWindowsCygwinEnvironment()) &&
7644 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
7645 RawTriple.hasEnvironment())) ||
7647 CmdArgs.push_back(
"-fno-use-cxa-atexit");
7649 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7650 options::OPT_fno_register_global_dtors_with_atexit,
7651 RawTriple.isOSDarwin() && !KernelOrKext))
7652 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7654 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7655 options::OPT_fno_use_line_directives);
7658 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7659 options::OPT_fno_minimize_whitespace,
false)) {
7660 types::ID InputType = Inputs[0].getType();
7661 if (!isDerivedFromC(InputType))
7662 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7664 CmdArgs.push_back(
"-fminimize-whitespace");
7668 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7669 options::OPT_fno_keep_system_includes,
false)) {
7670 types::ID InputType = Inputs[0].getType();
7671 if (!isDerivedFromC(InputType))
7672 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7674 CmdArgs.push_back(
"-fkeep-system-includes");
7678 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7679 IsWindowsMSVC || IsUEFI))
7680 CmdArgs.push_back(
"-fms-extensions");
7683 bool IsMSVCCompat = Args.hasFlag(
7684 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7685 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7686 options::OPT_fno_ms_extensions,
true)));
7688 CmdArgs.push_back(
"-fms-compatibility");
7690 Args.hasArg(options::OPT_fms_define_stdc))
7691 CmdArgs.push_back(
"-fms-define-stdc");
7712 auto MSAnonymousStructsOptionToUseOrNull =
7713 [](
const ArgList &Args) ->
const char * {
7714 const char *Option =
nullptr;
7715 constexpr const char *Enable =
"-fms-anonymous-structs";
7716 constexpr const char *Disable =
"-fno-ms-anonymous-structs";
7719 for (
const Arg *A : Args) {
7720 switch (A->getOption().getID()) {
7721 case options::OPT_fms_anonymous_structs:
7725 case options::OPT_fno_ms_anonymous_structs:
7731 case options::OPT_fms_extensions:
7732 case options::OPT_fms_compatibility:
7737 case options::OPT_fno_ms_extensions:
7738 case options::OPT_fno_ms_compatibility:
7749 if (
auto MSAnonOpt = MSAnonymousStructsOptionToUseOrNull(Args))
7750 CmdArgs.push_back(MSAnonOpt);
7752 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7753 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7757 VersionTuple GNUCVer;
7758 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7761 StringRef Val = A->getValue();
7762 Val = Val.empty() ?
"0" : Val;
7763 bool Invalid = GNUCVer.tryParse(Val);
7764 unsigned Minor = GNUCVer.getMinor().value_or(0);
7765 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7766 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7767 D.
Diag(diag::err_drv_invalid_value)
7768 << A->getAsString(Args) << A->getValue();
7770 }
else if (!IsMSVCCompat) {
7772 GNUCVer = VersionTuple(4, 2, 1);
7774 if (!GNUCVer.empty()) {
7776 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7782 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7784 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7785 if (ImplyVCPPCVer) {
7786 StringRef LanguageStandard;
7787 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7789 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7790 .Case(
"c11",
"-std=c11")
7791 .Case(
"c17",
"-std=c17")
7798 .Case(
"clatest",
"-std=c23")
7800 if (LanguageStandard.empty())
7801 D.
Diag(clang::diag::warn_drv_unused_argument)
7802 << StdArg->getAsString(Args);
7804 CmdArgs.push_back(LanguageStandard.data());
7806 if (ImplyVCPPCXXVer) {
7807 StringRef LanguageStandard;
7808 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7810 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
7811 .Case(
"c++14",
"-std=c++14")
7812 .Case(
"c++17",
"-std=c++17")
7813 .Case(
"c++20",
"-std=c++20")
7814 .Case(
"c++23",
"-std=c++23")
7822 .Case(
"c++23preview",
"-std=c++23")
7823 .Case(
"c++26preview",
"-std=c++26")
7824 .Case(
"c++latest",
"-std=c++2d")
7832 D.
Diag(diag::err_drv_argument_not_allowed_with)
7833 << StdArg->getAsString(Args) <<
"-fsycl";
7836 D.
Diag(diag::err_drv_sycl_requires_cxx17)
7837 << StdArg->getAsString(Args);
7840 if (LanguageStandard.empty())
7841 D.
Diag(clang::diag::warn_drv_unused_argument)
7842 << StdArg->getAsString(Args);
7845 if (LanguageStandard.empty()) {
7848 LanguageStandard =
"-std=c++17";
7849 else if (IsMSVC2015Compatible)
7850 LanguageStandard =
"-std=c++14";
7852 LanguageStandard =
"-std=c++11";
7855 CmdArgs.push_back(LanguageStandard.data());
7858 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7859 options::OPT_fno_borland_extensions);
7862 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7864 CmdArgs.push_back(
"-fdeclspec");
7865 else if (Args.hasArg(options::OPT_fno_declspec))
7866 CmdArgs.push_back(
"-fno-declspec");
7870 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7871 options::OPT_fno_threadsafe_statics,
7873 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7874 CmdArgs.push_back(
"-fno-threadsafe-statics");
7876 if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7878 CmdArgs.push_back(
"-fno-ms-tls-guards");
7881 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7883 CmdArgs.push_back(
"-fno-assumptions");
7887 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7888 options::OPT_fno_gnu_keywords);
7890 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7891 options::OPT_fno_gnu89_inline);
7893 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7894 options::OPT_finline_hint_functions,
7895 options::OPT_fno_inline_functions);
7896 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7897 if (A->getOption().matches(options::OPT_fno_inline))
7898 A->render(Args, CmdArgs);
7899 }
else if (InlineArg) {
7900 InlineArg->render(Args, CmdArgs);
7903 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7908 (Std->containsValue(
"c++2a") || Std->containsValue(
"gnu++2a") ||
7909 Std->containsValue(
"c++20") || Std->containsValue(
"gnu++20") ||
7910 Std->containsValue(
"c++2b") || Std->containsValue(
"gnu++2b") ||
7911 Std->containsValue(
"c++23") || Std->containsValue(
"gnu++23") ||
7912 Std->containsValue(
"c++23preview") || Std->containsValue(
"c++2c") ||
7913 Std->containsValue(
"gnu++2c") || Std->containsValue(
"c++26") ||
7914 Std->containsValue(
"gnu++26") || Std->containsValue(
"c++26preview") ||
7915 Std->containsValue(
"c++2d") || Std->containsValue(
"gnu++2d") ||
7916 Std->containsValue(
"c++latest") || Std->containsValue(
"gnu++latest"));
7931 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7932 options::OPT_fno_delayed_template_parsing,
7933 IsWindowsMSVC && !HaveCxx20)) {
7935 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7937 CmdArgs.push_back(
"-fdelayed-template-parsing");
7940 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7941 options::OPT_fno_pch_validate_input_files_content,
false))
7942 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7943 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7944 options::OPT_fno_pch_instantiate_templates,
false))
7945 CmdArgs.push_back(
"-fpch-instantiate-templates");
7946 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7948 CmdArgs.push_back(
"-fmodules-codegen");
7949 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7951 CmdArgs.push_back(
"-fmodules-debuginfo");
7953 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7958 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7959 options::OPT_fno_objc_encode_cxx_class_template_spec,
7961 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7963 if (Args.hasFlag(options::OPT_fapplication_extension,
7964 options::OPT_fno_application_extension,
false))
7965 CmdArgs.push_back(
"-fapplication-extension");
7969 if (!
C.getDriver().IsCLMode())
7971 IsDeviceOffloadAction, Runtime, CmdArgs);
7974 Arg *A = Args.getLastArg(
7975 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7976 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions,
7977 options::OPT_femscripten_exceptions);
7979 const Option &Opt = A->getOption();
7980 if (Opt.matches(options::OPT_fsjlj_exceptions))
7981 CmdArgs.push_back(
"-exception-model=sjlj");
7982 if (Opt.matches(options::OPT_fseh_exceptions))
7983 CmdArgs.push_back(
"-exception-model=seh");
7984 if (Opt.matches(options::OPT_fdwarf_exceptions))
7985 CmdArgs.push_back(
"-exception-model=dwarf");
7986 if (Opt.matches(options::OPT_fwasm_exceptions))
7987 CmdArgs.push_back(
"-exception-model=wasm");
7988 if (Opt.matches(options::OPT_femscripten_exceptions))
7989 CmdArgs.push_back(
"-exception-model=emscripten");
7994 case llvm::ExceptionHandling::DwarfCFI:
7995 CmdArgs.push_back(
"-exception-model=dwarf");
7997 case llvm::ExceptionHandling::SjLj:
7998 CmdArgs.push_back(
"-exception-model=sjlj");
8000 case llvm::ExceptionHandling::WinEH:
8001 CmdArgs.push_back(
"-exception-model=seh");
8008 if (
const Arg *A = Args.getLastArg(options::OPT_winx64_eh_unwind_EQ)) {
8011 Args.MakeArgString(Twine(
"-fwinx64-eh-unwind=") + A->getValue()));
8012 }
else if (
const Arg *A =
8013 Args.getLastArg(options::OPT_winx64_eh_unwindv2_EQ)) {
8015 StringRef Val = A->getValue();
8016 if (Val ==
"best-effort")
8017 CmdArgs.push_back(
"-fwinx64-eh-unwind=v2-best-effort");
8018 else if (Val ==
"required")
8019 CmdArgs.push_back(
"-fwinx64-eh-unwind=v2-required");
8021 else if (Val !=
"disabled")
8022 D.
Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
8026 Args.AddLastArg(CmdArgs, options::OPT_win_cfg_mechanism);
8029 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
8030 options::OPT_fno_assume_sane_operator_new);
8033 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
8034 options::OPT_fno_assume_unique_vtables);
8038 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
8039 options::OPT_fno_sized_deallocation);
8043 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
8044 options::OPT_fno_aligned_allocation,
8045 options::OPT_faligned_new_EQ)) {
8046 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
8047 CmdArgs.push_back(
"-fno-aligned-allocation");
8049 CmdArgs.push_back(
"-faligned-allocation");
8054 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
8055 options::OPT_faligned_new_EQ))
8057 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
8061 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
8062 options::OPT_fno_constant_cfstrings,
true) ||
8063 !Args.hasFlag(options::OPT_mconstant_cfstrings,
8064 options::OPT_mno_constant_cfstrings,
true))
8065 CmdArgs.push_back(
"-fno-constant-cfstrings");
8067 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
8068 options::OPT_fno_pascal_strings);
8072 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
8074 Args.MakeArgString(
"-fpack-struct=" + Twine(A->getValue())));
8075 }
else if (Args.hasFlag(options::OPT_fpack_struct,
8076 options::OPT_fno_pack_struct,
false)) {
8077 CmdArgs.push_back(
"-fpack-struct=1");
8081 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
8082 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
8083 if (!SkipMaxTypeAlign) {
8084 std::string MaxTypeAlignStr =
"-fmax-type-align=";
8085 MaxTypeAlignStr += A->getValue();
8086 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
8088 }
else if (RawTriple.isOSDarwin()) {
8089 if (!SkipMaxTypeAlign) {
8090 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
8091 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
8095 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
8096 CmdArgs.push_back(
"-Qn");
8099 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
8103 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
8104 options::OPT_funsigned_bitfields,
true))
8105 D.
Diag(diag::warn_drv_clang_unsupported)
8106 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
8109 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
8110 D.
Diag(diag::err_drv_clang_unsupported)
8111 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
8114 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
8115 StringRef value = inputCharset->getValue();
8116 if (!value.equals_insensitive(
"utf-8"))
8117 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
8122 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
8123 StringRef value = execCharset->getValue();
8124 if (!value.equals_insensitive(
"utf-8"))
8125 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
8131 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
8132 options::OPT_fno_asm_blocks);
8134 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
8135 options::OPT_fno_gnu_inline_asm);
8141 if (!VecWidth.empty())
8142 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + VecWidth));
8144 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
8145 Args.AddLastArg(CmdArgs,
8146 options::OPT_fsanitize_undefined_strip_path_components_EQ);
8150 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
8151 options::OPT_fno_dollars_in_identifiers)) {
8152 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
8153 CmdArgs.push_back(
"-fdollars-in-identifiers");
8155 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
8158 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
8159 options::OPT_fno_apple_pragma_pack);
8165 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
8166 options::OPT_fno_rewrite_imports,
false);
8168 CmdArgs.push_back(
"-frewrite-imports");
8170 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
8171 options::OPT_fno_directives_only);
8177 if (Args.hasFlag(options::OPT_frewrite_includes,
8178 options::OPT_fno_rewrite_includes,
false) ||
8179 (
C.isForDiagnostics() && !HaveModules))
8180 CmdArgs.push_back(
"-frewrite-includes");
8182 if (Args.hasFlag(options::OPT_fzos_extensions,
8183 options::OPT_fno_zos_extensions,
false))
8184 CmdArgs.push_back(
"-fzos-extensions");
8185 else if (Args.hasArg(options::OPT_fno_zos_extensions))
8186 CmdArgs.push_back(
"-fno-zos-extensions");
8189 if (Arg *A = Args.getLastArg(options::OPT_traditional,
8190 options::OPT_traditional_cpp)) {
8192 CmdArgs.push_back(
"-traditional-cpp");
8194 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
8197 Args.AddLastArg(CmdArgs, options::OPT_dM);
8198 Args.AddLastArg(CmdArgs, options::OPT_dD);
8199 Args.AddLastArg(CmdArgs, options::OPT_dI);
8201 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
8203 Args.AddLastArg(CmdArgs, options::OPT__ssaf_extract_summaries);
8204 Args.AddLastArg(CmdArgs, options::OPT__ssaf_tu_summary_file);
8205 Args.AddLastArg(CmdArgs, options::OPT__ssaf_compilation_unit_id);
8206 Args.AddLastArg(CmdArgs, options::OPT__ssaf_include_local_entities);
8207 Args.AddLastArg(CmdArgs, options::OPT__ssaf_no_extract_from_system_headers);
8208 Args.AddLastArg(CmdArgs, options::OPT__ssaf_source_transformation);
8209 Args.AddLastArg(CmdArgs, options::OPT__ssaf_global_scope_analysis_result);
8210 Args.AddLastArg(CmdArgs, options::OPT__ssaf_link_unit_id);
8211 Args.AddLastArg(CmdArgs, options::OPT__ssaf_src_edit_file);
8212 Args.AddLastArg(CmdArgs, options::OPT__ssaf_transformation_report_file);
8215 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
8216 CmdArgs.push_back(
"-serialize-diagnostic-file");
8217 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
8220 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
8221 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
8223 if (Arg *A = Args.getLastArg(options::OPT_fextend_variable_liveness_EQ)) {
8224 A->render(Args, CmdArgs);
8225 }
else if (Arg *A = Args.getLastArg(options::OPT_O_Group);
8226 A && A->containsValue(
"g")) {
8228 CmdArgs.push_back(
"-fextend-variable-liveness=all");
8232 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
8234 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
8236 Args.AddAllArgs(CmdArgs, options::OPT_fretain_comments);
8239 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
8240 CmdArgs.push_back(
"-load");
8241 CmdArgs.push_back(A->getValue());
8253 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
8254 auto ArgValue = StringRef(A->getValue());
8255 auto FirstDashIndex = ArgValue.find(
'-');
8256 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
8257 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
8260 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
8261 if (PluginName.empty()) {
8262 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
8264 D.
Diag(diag::warn_drv_missing_plugin_arg)
8265 << PluginName << A->getAsString(Args);
8270 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
8271 CmdArgs.push_back(Args.MakeArgString(Arg));
8275 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
8277 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
8282 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
8283 CmdArgs.push_back(
"--vfsoverlay");
8284 CmdArgs.push_back(A->getValue());
8288 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
8289 options::OPT_fno_safe_buffer_usage_suggestions);
8291 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
8292 options::OPT_fno_experimental_late_parse_attributes);
8294 if (Args.hasFlag(options::OPT_funique_source_file_names,
8295 options::OPT_fno_unique_source_file_names,
false)) {
8296 if (Arg *A = Args.getLastArg(options::OPT_unique_source_file_identifier_EQ))
8297 A->render(Args, CmdArgs);
8299 CmdArgs.push_back(Args.MakeArgString(
8300 Twine(
"-funique-source-file-identifier=") + Input.
getBaseInput()));
8304 options::OPT_fexperimental_allow_pointer_field_protection_attr,
8305 options::OPT_fno_experimental_allow_pointer_field_protection_attr,
8307 Args.hasFlag(options::OPT_fexperimental_pointer_field_protection_abi,
8308 options::OPT_fno_experimental_pointer_field_protection_abi,
8310 CmdArgs.push_back(
"-fexperimental-allow-pointer-field-protection-attr");
8312 if (!IsCudaDevice) {
8314 CmdArgs, options::OPT_fexperimental_pointer_field_protection_abi,
8315 options::OPT_fno_experimental_pointer_field_protection_abi);
8317 CmdArgs, options::OPT_fexperimental_pointer_field_protection_tagged,
8318 options::OPT_fno_experimental_pointer_field_protection_tagged);
8323 if (!StatsFile.empty()) {
8324 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
8326 CmdArgs.push_back(
"-stats-file-append");
8331 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
8335 if (
C.getDriver().isSaveTempsEnabled() &&
8337 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
8340 CmdArgs.push_back(Arg->getValue());
8342 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
8348 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
8349 CmdArgs.push_back(
"-disable-llvm-optzns");
8351 A->render(Args, CmdArgs);
8357 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
8359 Args.AddLastArg(CmdArgs, options::OPT_falloc_token_max_EQ);
8363 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
8365 A->render(Args, CmdArgs);
8377 if ((
C.getDriver().isSaveTempsEnabled() ||
8379 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
8381 CmdArgs.push_back(
"-disable-llvm-passes");
8383 Args.AddAllArgs(CmdArgs, options::OPT_undef);
8392 auto GRecordSwitches =
false;
8393 auto FRecordSwitches =
false;
8394 bool DXRecordSwitches =
false;
8396 DXRecordSwitches)) {
8399 CmdArgs.push_back(
"-dwarf-debug-flags");
8400 CmdArgs.push_back(FlagsArgString);
8402 if (FRecordSwitches) {
8403 CmdArgs.push_back(
"-record-command-line");
8404 CmdArgs.push_back(FlagsArgString);
8406 if (DXRecordSwitches) {
8407 CmdArgs.push_back(
"-fdx-record-command-line");
8408 CmdArgs.push_back(FlagsArgString);
8414 if (!HostOffloadingInputs.empty()) {
8415 bool UseOffloadIncludeBinary =
8416 (IsCuda || IsHIP) &&
8417 (!IsRDCMode || Args.hasArg(options::OPT_cuda_emit_nvcc_abi)) &&
8418 !UsesLLVMOffloading;
8419 UseOffloadIncludeBinary |= IsSYCL && !IsRDCMode;
8420 if (UseOffloadIncludeBinary) {
8421 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
8422 CmdArgs.push_back(
"-foffload-include-binary");
8423 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
8425 for (
const InputInfo Input : HostOffloadingInputs)
8426 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
8432 if (Args.hasArg(options::OPT_cuda_emit_nvcc_abi))
8433 CmdArgs.push_back(
"--cuda-emit-nvcc-abi");
8436 if (IsCuda || IsHIP) {
8438 const Action *SourceAction = &JA;
8440 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
8441 SourceAction = SourceAction->
getInputs()[0];
8445 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
8449 bool UseApproxTranscendentals = Args.hasFlag(
8450 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
8451 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
8452 options::OPT_fno_gpu_approx_transcendentals,
8453 UseApproxTranscendentals))
8454 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
8456 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
8457 options::OPT_fno_gpu_approx_transcendentals);
8461 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
8462 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
8465 Args.AddAllArgs(CmdArgs,
8466 options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);
8468 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
8469 options::OPT_fno_offload_uniform_block);
8471 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
8472 options::OPT_fno_offload_implicit_host_device_templates);
8474 if (IsCudaDevice || IsHIPDevice) {
8475 StringRef InlineThresh =
8476 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
8477 if (!InlineThresh.empty()) {
8478 std::string ArgStr =
8479 std::string(
"-inline-threshold=") + InlineThresh.str();
8480 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
8485 Args.addOptOutFlag(CmdArgs,
8486 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
8487 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
8494 if (IsOpenMPDevice) {
8495 CmdArgs.push_back(
"-fopenmp-is-target-device");
8497 if (Args.hasArg(options::OPT_foffload_via_llvm))
8498 CmdArgs.push_back(
"-fcuda-is-device");
8500 if (OpenMPDeviceInput) {
8501 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
8502 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
8506 if (Triple.isAMDGPU() ||
8507 (Triple.isSPIRV() && Triple.getVendor() == llvm::Triple::AMD)) {
8510 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
8511 options::OPT_mno_unsafe_fp_atomics);
8512 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
8513 options::OPT_mno_amdgpu_ieee);
8518 if (Args.hasFlag(options::OPT_fdevirtualize_speculatively,
8519 options::OPT_fno_devirtualize_speculatively,
8521 CmdArgs.push_back(
"-fdevirtualize-speculatively");
8523 bool VirtualFunctionElimination =
8524 Args.hasFlag(options::OPT_fvirtual_function_elimination,
8525 options::OPT_fno_virtual_function_elimination,
false);
8526 if (VirtualFunctionElimination) {
8530 D.
Diag(diag::err_drv_argument_only_allowed_with)
8531 <<
"-fvirtual-function-elimination"
8534 CmdArgs.push_back(
"-fvirtual-function-elimination");
8538 bool WholeProgramVTables = Args.hasFlag(
8539 options::OPT_fwhole_program_vtables,
8540 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
8541 if (VirtualFunctionElimination && !WholeProgramVTables) {
8542 D.
Diag(diag::err_drv_argument_not_allowed_with)
8543 <<
"-fno-whole-program-vtables"
8544 <<
"-fvirtual-function-elimination";
8547 if (WholeProgramVTables) {
8561 C.getActiveOffloadKinds()));
8562 auto OtherIsUsingLTO = OtherLTOMode !=
LTOK_None;
8564 if ((!IsUsingLTO && !OtherIsUsingLTO) ||
8566 D.
Diag(diag::err_drv_argument_only_allowed_with)
8567 <<
"-fwhole-program-vtables"
8568 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
8572 CmdArgs.push_back(
"-fwhole-program-vtables");
8575 bool DefaultsSplitLTOUnit =
8576 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
8578 (!Triple.isPS4() && UnifiedLTO);
8580 Args.hasFlag(options::OPT_fsplit_lto_unit,
8581 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
8582 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
8583 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
8584 <<
"-fsanitize=cfi";
8586 CmdArgs.push_back(
"-fsplit-lto-unit");
8588 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
8589 options::OPT_fno_fat_lto_objects)) {
8590 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
8592 if (!Triple.isOSBinFormatELF() && !Triple.isOSBinFormatCOFF()) {
8593 D.
Diag(diag::err_drv_unsupported_opt_for_target)
8596 CmdArgs.push_back(Args.MakeArgString(
8597 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
8598 CmdArgs.push_back(
"-flto-unit");
8599 CmdArgs.push_back(
"-ffat-lto-objects");
8600 A->render(Args, CmdArgs);
8606 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
8607 options::OPT_fno_force_enable_int128)) {
8608 if (A->getOption().matches(options::OPT_fforce_enable_int128))
8609 CmdArgs.push_back(
"-fforce-enable-int128");
8612 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
8613 options::OPT_fno_keep_static_consts);
8614 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
8615 options::OPT_fno_keep_persistent_storage_variables);
8616 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_inline_functions,
8617 options::OPT_fno_keep_inline_functions);
8618 Args.addOptInFlag(CmdArgs, options::OPT_fmodule_local_hints,
8619 options::OPT_fno_module_local_hints);
8620 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
8621 options::OPT_fno_complete_member_pointers);
8622 if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
8623 A->render(Args, CmdArgs);
8629 if (Triple.isAArch64() &&
8630 (Args.hasArg(options::OPT_mno_fmv) ||
8633 CmdArgs.push_back(
"-target-feature");
8634 CmdArgs.push_back(
"-fmv");
8637 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
8644 CmdArgs.push_back(
"-faddrsig");
8646 const bool HasDefaultDwarf2CFIASM =
8647 (Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
8648 (EH || UnwindTables || AsyncUnwindTables ||
8649 DebugInfoKind != llvm::codegenoptions::NoDebugInfo);
8650 if (Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
8651 options::OPT_fno_dwarf2_cfi_asm, HasDefaultDwarf2CFIASM))
8652 CmdArgs.push_back(
"-fdwarf2-cfi-asm");
8654 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
8655 std::string Str = A->getAsString(Args);
8657 D.
Diag(diag::err_drv_unsupported_opt_for_target)
8659 CmdArgs.push_back(Args.MakeArgString(Str));
8664 if (Output.
getType() == types::TY_Dependencies) {
8667 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
8668 Output.
getType() == clang::driver::types::TY_IFS) {
8670 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
8671 CmdArgs.push_back(
"-o");
8672 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
8674 CmdArgs.push_back(
"-o");
8678 assert(Output.
isNothing() &&
"Invalid output.");
8685 FrontendInputs = ExtractAPIInputs;
8687 FrontendInputs = {};
8689 for (
const InputInfo &Input : FrontendInputs) {
8698 C.addCommand(std::make_unique<CC1Command>(
8702 C.addCommand(std::make_unique<Command>(
8708 if (Output.
getType() == types::TY_Object &&
8709 Args.hasFlag(options::OPT__SLASH_showFilenames,
8710 options::OPT__SLASH_showFilenames_,
false)) {
8711 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
8714 if (Arg *A = Args.getLastArg(options::OPT_pg))
8716 !Args.hasArg(options::OPT_mfentry))
8717 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
8718 << A->getAsString(Args);
8724 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
8728 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8729 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8732 Args.ClaimAllArgs(options::OPT_emit_llvm);