4786 const ArgList &Args,
const char *LinkingOutput)
const {
4788 const llvm::Triple &RawTriple = TC.
getTriple();
4790 const std::string &TripleStr = Triple.getTriple();
4793 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4795 ArgStringList CmdArgs;
4797 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4815 bool IsHostOffloadingAction =
4819 Args.hasFlag(options::OPT_offload_new_driver,
4820 options::OPT_no_offload_new_driver,
4824 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4835 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4839 const InputInfo *CudaDeviceInput =
nullptr;
4840 const InputInfo *OpenMPDeviceInput =
nullptr;
4842 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4844 }
else if (IsExtractAPI) {
4845 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4846 if (I.getType() != ExpectedInputType) {
4847 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4851 ExtractAPIInputs.push_back(I);
4852 }
else if (IsHostOffloadingAction) {
4853 HostOffloadingInputs.push_back(I);
4854 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4855 CudaDeviceInput = &I;
4856 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4857 OpenMPDeviceInput = &I;
4859 llvm_unreachable(
"unexpectedly given multiple inputs");
4863 const llvm::Triple *AuxTriple =
4865 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4866 bool IsUEFI = RawTriple.isUEFI();
4867 bool IsIAMCU = RawTriple.isOSIAMCU();
4872 if (IsCuda || IsHIP || IsSYCL)
4873 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4877 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4882 CmdArgs.push_back(
"-cc1");
4885 CmdArgs.push_back(
"-triple");
4886 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4888 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4889 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4890 Args.ClaimAllArgs(options::OPT_MJ);
4891 }
else if (
const Arg *GenCDBFragment =
4892 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4893 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4894 TripleStr, Output, Input, Args);
4895 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4898 if (IsCuda || IsHIP) {
4901 std::string NormalizedTriple;
4919 assert(CTC &&
"Expected valid CUDA Toolchain.");
4921 CmdArgs.push_back(Args.MakeArgString(
4922 Twine(
"-target-sdk-version=") +
4930 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4933 CmdArgs.push_back(
"-aux-triple");
4934 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4939 getToolChain().getTriple().getVendor() == llvm::Triple::AMD))) {
4941 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4942 CmdArgs.push_back(Args.MakeArgString(
4944 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4947 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4953 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4954 if (A->getOption().matches(options::OPT_O4)) {
4955 CmdArgs.push_back(
"-O3");
4956 D.
Diag(diag::warn_O4_is_O3);
4958 A->render(Args, CmdArgs);
4963 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
4969 llvm::Triple AuxT =
C.getDefaultToolChain().getTriple();
4970 std::string NormalizedTriple = AuxT.normalize();
4971 CmdArgs.push_back(
"-aux-triple");
4972 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4975 CmdArgs.push_back(
"-fsycl-is-device");
4978 if (!Args.getLastArg(options::OPT_O_Group))
4979 CmdArgs.push_back(
"-O2");
4986 CmdArgs.push_back(
"-fsycl-is-host");
4990 Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
4992 SYCLStdArg->render(Args, CmdArgs);
4995 CmdArgs.push_back(
"-sycl-std=2020");
4999 if (Args.hasArg(options::OPT_fclangir))
5000 CmdArgs.push_back(
"-fclangir");
5002 if (IsOpenMPDevice) {
5004 std::string NormalizedTriple =
5008 CmdArgs.push_back(
"-aux-triple");
5009 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5012 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
5013 Triple.getArch() == llvm::Triple::thumb)) {
5014 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5015 unsigned Version = 0;
5017 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
5018 if (Failure || Version < 7)
5019 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
5029 if (Triple.isSPIR() || Triple.isSPIRV())
5030 CmdArgs.push_back(
"-Wspir-compat");
5033 RewriteKind rewriteKind = RK_None;
5035 bool UnifiedLTO =
false;
5037 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5038 options::OPT_fno_unified_lto, Triple.isPS());
5040 CmdArgs.push_back(
"-funified-lto");
5054 Args.ClaimAllArgs(options::OPT_mrelax_all);
5055 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5056 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5057 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5058 switch (
C.getDefaultToolChain().getArch()) {
5059 case llvm::Triple::arm:
5060 case llvm::Triple::armeb:
5061 case llvm::Triple::thumb:
5062 case llvm::Triple::thumbeb:
5063 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5069 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5070 Args.ClaimAllArgs(options::OPT_Xassembler);
5071 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5075 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5076 CmdArgs.push_back(
"-analyze");
5078 if (Output.
getType() == types::TY_Dependencies)
5079 CmdArgs.push_back(
"-Eonly");
5081 CmdArgs.push_back(
"-E");
5082 if (Args.hasArg(options::OPT_rewrite_objc) &&
5083 !Args.hasArg(options::OPT_g_Group))
5084 CmdArgs.push_back(
"-P");
5085 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5086 CmdArgs.push_back(
"-fdirectives-only");
5089 CmdArgs.push_back(
"-emit-obj");
5094 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5096 if (JA.
getType() == types::TY_Nothing)
5097 CmdArgs.push_back(
"-fsyntax-only");
5098 else if (JA.
getType() == types::TY_ModuleFile)
5099 CmdArgs.push_back(
"-emit-module-interface");
5100 else if (JA.
getType() == types::TY_HeaderUnit)
5101 CmdArgs.push_back(
"-emit-header-unit");
5102 else if (!Args.hasArg(options::OPT_ignore_pch))
5103 CmdArgs.push_back(
"-emit-pch");
5105 CmdArgs.push_back(
"-verify-pch");
5107 assert(JA.
getType() == types::TY_API_INFO &&
5108 "Extract API actions must generate a API information.");
5109 CmdArgs.push_back(
"-extract-api");
5111 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5112 PrettySGFArg->render(Args, CmdArgs);
5114 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5116 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5117 ProductNameArg->render(Args, CmdArgs);
5118 if (Arg *ExtractAPIIgnoresFileArg =
5119 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5120 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5121 if (Arg *EmitExtensionSymbolGraphs =
5122 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5123 if (!SymbolGraphDirArg)
5124 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5126 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5128 if (SymbolGraphDirArg)
5129 SymbolGraphDirArg->render(Args, CmdArgs);
5132 "Invalid action for clang tool.");
5133 if (JA.
getType() == types::TY_Nothing) {
5134 CmdArgs.push_back(
"-fsyntax-only");
5135 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5136 JA.
getType() == types::TY_LTO_IR) {
5137 CmdArgs.push_back(
"-emit-llvm");
5138 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5139 JA.
getType() == types::TY_LTO_BC) {
5141 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5142 Args.hasArg(options::OPT_emit_llvm)) {
5143 CmdArgs.push_back(
"-emit-llvm");
5145 CmdArgs.push_back(
"-emit-llvm-bc");
5147 }
else if (JA.
getType() == types::TY_IFS ||
5148 JA.
getType() == types::TY_IFS_CPP) {
5150 Args.hasArg(options::OPT_interface_stub_version_EQ)
5151 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5153 CmdArgs.push_back(
"-emit-interface-stubs");
5155 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5156 }
else if (JA.
getType() == types::TY_PP_Asm) {
5157 CmdArgs.push_back(
"-S");
5158 }
else if (JA.
getType() == types::TY_AST) {
5159 if (!Args.hasArg(options::OPT_ignore_pch))
5160 CmdArgs.push_back(
"-emit-pch");
5161 }
else if (JA.
getType() == types::TY_ModuleFile) {
5162 CmdArgs.push_back(
"-module-file-info");
5163 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5164 CmdArgs.push_back(
"-rewrite-objc");
5165 rewriteKind = RK_NonFragile;
5166 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5167 CmdArgs.push_back(
"-rewrite-objc");
5168 rewriteKind = RK_Fragile;
5169 }
else if (JA.
getType() == types::TY_CIR) {
5170 CmdArgs.push_back(
"-emit-cir");
5172 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5179 if (JA.
getType() == types::TY_LLVM_BC)
5180 CmdArgs.push_back(
"-emit-llvm-uselists");
5184 !Args.hasFlag(options::OPT_offload_new_driver,
5185 options::OPT_no_offload_new_driver,
5187 !Triple.isAMDGPU()) {
5188 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5189 << Args.getLastArg(options::OPT_foffload_lto,
5190 options::OPT_foffload_lto_EQ)
5192 << Triple.getTriple();
5193 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5195 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5196 << Args.getLastArg(options::OPT_foffload_lto,
5197 options::OPT_foffload_lto_EQ)
5202 CmdArgs.push_back(Args.MakeArgString(
5203 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5206 if (!RawTriple.isPS4() ||
5208 CmdArgs.push_back(
"-flto-unit");
5213 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5215 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5217 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5218 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5222 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5223 options::OPT_mno_regnames);
5225 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5226 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5228 if (Args.getLastArg(options::OPT_save_temps_EQ))
5229 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5231 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5232 options::OPT_fmemory_profile_EQ,
5233 options::OPT_fno_memory_profile);
5235 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5236 MemProfArg->render(Args, CmdArgs);
5238 if (
auto *MemProfUseArg =
5239 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5241 D.
Diag(diag::err_drv_argument_not_allowed_with)
5242 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5243 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5244 options::OPT_fprofile_generate_EQ))
5245 D.
Diag(diag::err_drv_argument_not_allowed_with)
5246 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5247 MemProfUseArg->render(Args, CmdArgs);
5252 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5255 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5257 CmdArgs.push_back(
"-disable-llvm-passes");
5264 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5265 options::OPT_mkernel,
5266 options::OPT_fapple_kext,
5267 options::OPT_ffunction_sections,
5268 options::OPT_fno_function_sections,
5269 options::OPT_fdata_sections,
5270 options::OPT_fno_data_sections,
5271 options::OPT_fbasic_block_sections_EQ,
5272 options::OPT_funique_internal_linkage_names,
5273 options::OPT_fno_unique_internal_linkage_names,
5274 options::OPT_funique_section_names,
5275 options::OPT_fno_unique_section_names,
5276 options::OPT_funique_basic_block_section_names,
5277 options::OPT_fno_unique_basic_block_section_names,
5278 options::OPT_mrestrict_it,
5279 options::OPT_mno_restrict_it,
5280 options::OPT_mstackrealign,
5281 options::OPT_mno_stackrealign,
5282 options::OPT_mstack_alignment,
5283 options::OPT_mcmodel_EQ,
5284 options::OPT_mlong_calls,
5285 options::OPT_mno_long_calls,
5286 options::OPT_ggnu_pubnames,
5287 options::OPT_gdwarf_aranges,
5288 options::OPT_fdebug_types_section,
5289 options::OPT_fno_debug_types_section,
5290 options::OPT_fdwarf_directory_asm,
5291 options::OPT_fno_dwarf_directory_asm,
5292 options::OPT_mrelax_all,
5293 options::OPT_mno_relax_all,
5294 options::OPT_ftrap_function_EQ,
5295 options::OPT_ffixed_r9,
5296 options::OPT_mfix_cortex_a53_835769,
5297 options::OPT_mno_fix_cortex_a53_835769,
5298 options::OPT_ffixed_x18,
5299 options::OPT_mglobal_merge,
5300 options::OPT_mno_global_merge,
5301 options::OPT_mred_zone,
5302 options::OPT_mno_red_zone,
5303 options::OPT_Wa_COMMA,
5304 options::OPT_Xassembler,
5308 for (
const auto &A : Args)
5309 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5310 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5313 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5314 options::OPT_fno_optimize_sibling_calls);
5322 case llvm::Triple::arm:
5323 case llvm::Triple::armeb:
5324 case llvm::Triple::thumbeb:
5325 RenderARMABI(D, Triple, Args, CmdArgs);
5327 case llvm::Triple::aarch64:
5328 case llvm::Triple::aarch64_32:
5329 case llvm::Triple::aarch64_be:
5330 RenderAArch64ABI(Triple, Args, CmdArgs);
5335 if (Output.
getType() == types::TY_Dependencies) {
5338 CmdArgs.push_back(
"-o");
5341 assert(Output.
isNothing() &&
"Input output.");
5344 for (
const auto &II : Inputs) {
5346 if (II.isFilename())
5347 CmdArgs.push_back(II.getFilename());
5349 II.getInputArg().renderAsInput(Args, CmdArgs);
5352 C.addCommand(std::make_unique<Command>(
5358 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5359 CmdArgs.push_back(
"-fembed-bitcode=marker");
5364 if (!
C.isForDiagnostics())
5365 CmdArgs.push_back(
"-disable-free");
5366 CmdArgs.push_back(
"-clear-ast-before-backend");
5369 const bool IsAssertBuild =
false;
5371 const bool IsAssertBuild =
true;
5376 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5377 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5378 CmdArgs.push_back(
"-disable-llvm-verifier");
5382 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5383 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5384 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5386 return types::isLLVMIR(II.getType());
5388 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5390 CmdArgs.push_back(
"-discard-value-names");
5395 CmdArgs.push_back(
"-main-file-name");
5400 if (Args.hasArg(options::OPT_static))
5401 CmdArgs.push_back(
"-static-define");
5403 Args.AddLastArg(CmdArgs, options::OPT_static_libclosure);
5405 if (Args.hasArg(options::OPT_municode))
5406 CmdArgs.push_back(
"-DUNICODE");
5413 CmdArgs.push_back(
"-setup-static-analyzer");
5418 bool FoundAnalyzerConfig =
false;
5419 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5420 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5421 FoundAnalyzerConfig =
true;
5424 if (!FoundAnalyzerConfig)
5425 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5426 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5427 FoundAnalyzerConfig =
true;
5430 if (FoundAnalyzerConfig)
5431 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5436 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5437 if (FunctionAlignment) {
5438 CmdArgs.push_back(
"-function-alignment");
5439 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5444 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5446 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5448 << A->getAsString(Args) << A->getValue();
5450 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5451 << A->getAsString(Args) << A->getValue();
5454 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5455 Twine(std::min(
Value, 65536u))));
5458 if (Triple.isOSzOS()) {
5467 auto findMacroDefinition = [&](
const std::string &
Macro) {
5468 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5469 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5470 return M ==
Macro || M.find(
Macro +
'=') != std::string::npos;
5475 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5476 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5478 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5479 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5482 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5483 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5487 llvm::Reloc::Model RelocationModel;
5490 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5491 Arg *LastPICDataRelArg =
5492 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5493 options::OPT_mpic_data_is_text_relative);
5494 bool NoPICDataIsTextRelative =
false;
5495 if (LastPICDataRelArg) {
5496 if (LastPICDataRelArg->getOption().matches(
5497 options::OPT_mno_pic_data_is_text_relative)) {
5498 NoPICDataIsTextRelative =
true;
5500 D.
Diag(diag::err_drv_argument_only_allowed_with)
5501 <<
"-mno-pic-data-is-text-relative"
5504 if (!Triple.isSystemZ())
5505 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5506 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5507 :
"-mpic-data-is-text-relative")
5511 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5512 RelocationModel == llvm::Reloc::ROPI_RWPI;
5513 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5514 RelocationModel == llvm::Reloc::ROPI_RWPI;
5516 if (Args.hasArg(options::OPT_mcmse) &&
5517 !Args.hasArg(options::OPT_fallow_unsupported)) {
5519 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5521 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5525 !Args.hasArg(options::OPT_fallow_unsupported))
5526 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5530 CmdArgs.push_back(
"-mrelocation-model");
5531 CmdArgs.push_back(RMName);
5534 CmdArgs.push_back(
"-pic-level");
5535 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5537 CmdArgs.push_back(
"-pic-is-pie");
5538 if (NoPICDataIsTextRelative)
5539 CmdArgs.push_back(
"-mcmodel=medium");
5542 if (RelocationModel == llvm::Reloc::ROPI ||
5543 RelocationModel == llvm::Reloc::ROPI_RWPI)
5544 CmdArgs.push_back(
"-fropi");
5545 if (RelocationModel == llvm::Reloc::RWPI ||
5546 RelocationModel == llvm::Reloc::ROPI_RWPI)
5547 CmdArgs.push_back(
"-frwpi");
5549 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5550 CmdArgs.push_back(
"-meabi");
5551 CmdArgs.push_back(A->getValue());
5565 if (Triple.isOSBinFormatELF()) {
5566 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5567 options::OPT_fno_semantic_interposition);
5568 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5570 bool SupportsLocalAlias =
5571 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5573 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5574 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5575 A->render(Args, CmdArgs);
5576 else if (!SupportsLocalAlias)
5577 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5583 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5585 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5586 << A->getValue() << A->getAsString(Args);
5587 Model = A->getValue();
5590 if (Model !=
"posix") {
5591 CmdArgs.push_back(
"-mthread-model");
5592 CmdArgs.push_back(Args.MakeArgString(Model));
5596 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5597 StringRef Name = A->getValue();
5598 if (Name ==
"SVML") {
5599 if (Triple.getArch() != llvm::Triple::x86 &&
5600 Triple.getArch() != llvm::Triple::x86_64)
5601 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5602 << Name << Triple.getArchName();
5603 }
else if (Name ==
"AMDLIBM") {
5604 if (Triple.getArch() != llvm::Triple::x86 &&
5605 Triple.getArch() != llvm::Triple::x86_64)
5606 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5607 << Name << Triple.getArchName();
5608 }
else if (Name ==
"libmvec") {
5609 if (Triple.getArch() != llvm::Triple::x86 &&
5610 Triple.getArch() != llvm::Triple::x86_64 &&
5611 Triple.getArch() != llvm::Triple::aarch64 &&
5612 Triple.getArch() != llvm::Triple::aarch64_be)
5613 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5614 << Name << Triple.getArchName();
5615 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5616 if (Triple.getArch() != llvm::Triple::aarch64 &&
5617 Triple.getArch() != llvm::Triple::aarch64_be &&
5618 Triple.getArch() != llvm::Triple::riscv64)
5619 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5620 << Name << Triple.getArchName();
5622 A->render(Args, CmdArgs);
5625 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5626 options::OPT_fno_merge_all_constants,
false))
5627 CmdArgs.push_back(
"-fmerge-all-constants");
5629 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5630 options::OPT_fno_delete_null_pointer_checks);
5634 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5635 if (!Triple.isOSAIX() || Triple.isPPC32())
5636 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5637 << A->getSpelling() << RawTriple.str();
5638 CmdArgs.push_back(
"-mabi=quadword-atomics");
5641 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5644 if (Triple.isOSAIX())
5645 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5646 << A->getSpelling() << RawTriple.str();
5649 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5650 StringRef
V = A->getValue(), V1 =
V;
5652 if (V1.consumeInteger(10, Size) || !V1.empty())
5653 D.
Diag(diag::err_drv_invalid_argument_to_option)
5654 <<
V << A->getOption().getName();
5656 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5659 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5660 options::OPT_fno_jump_tables);
5661 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5662 options::OPT_fno_profile_sample_accurate);
5663 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5664 options::OPT_fno_preserve_as_comments);
5666 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5667 CmdArgs.push_back(
"-mregparm");
5668 CmdArgs.push_back(A->getValue());
5671 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5672 options::OPT_msvr4_struct_return)) {
5674 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5675 << A->getSpelling() << RawTriple.str();
5676 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5677 CmdArgs.push_back(
"-maix-struct-return");
5679 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5680 CmdArgs.push_back(
"-msvr4-struct-return");
5684 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5685 options::OPT_freg_struct_return)) {
5686 if (TC.
getArch() != llvm::Triple::x86) {
5687 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5688 << A->getSpelling() << RawTriple.str();
5689 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5690 CmdArgs.push_back(
"-fpcc-struct-return");
5692 assert(A->getOption().matches(options::OPT_freg_struct_return));
5693 CmdArgs.push_back(
"-freg-struct-return");
5697 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5698 if (Triple.getArch() == llvm::Triple::m68k)
5699 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5701 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5704 if (Args.hasArg(options::OPT_fenable_matrix)) {
5706 CmdArgs.push_back(
"-fenable-matrix");
5707 CmdArgs.push_back(
"-mllvm");
5708 CmdArgs.push_back(
"-enable-matrix");
5713 const char *FPKeepKindStr =
nullptr;
5714 switch (FPKeepKind) {
5716 FPKeepKindStr =
"-mframe-pointer=none";
5719 FPKeepKindStr =
"-mframe-pointer=reserved";
5722 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5725 FPKeepKindStr =
"-mframe-pointer=all";
5728 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5729 CmdArgs.push_back(FPKeepKindStr);
5731 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5732 options::OPT_fno_zero_initialized_in_bss);
5736 D.
Diag(diag::warn_drv_deprecated_arg_ofast);
5739 OptSpecifier StrictAliasingAliasOption =
5740 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5743 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5744 options::OPT_fno_strict_aliasing,
5745 !IsWindowsMSVC && !IsUEFI))
5746 CmdArgs.push_back(
"-relaxed-aliasing");
5747 if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
5749 CmdArgs.push_back(
"-no-pointer-tbaa");
5750 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5751 options::OPT_fno_struct_path_tbaa,
true))
5752 CmdArgs.push_back(
"-no-struct-path-tbaa");
5753 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5754 options::OPT_fno_strict_enums);
5755 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5756 options::OPT_fno_strict_return);
5757 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5758 options::OPT_fno_allow_editor_placeholders);
5759 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5760 options::OPT_fno_strict_vtable_pointers);
5761 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5762 options::OPT_fno_force_emit_vtables);
5763 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5764 options::OPT_fno_optimize_sibling_calls);
5765 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5766 options::OPT_fno_escaping_block_tail_calls);
5768 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5769 options::OPT_fno_fine_grained_bitfield_accesses);
5771 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5772 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5774 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5775 options::OPT_fno_experimental_omit_vtable_rtti);
5777 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
5778 options::OPT_fno_disable_block_signature_string);
5781 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5782 options::OPT_fno_split_stack);
5785 if (Args.hasFlag(options::OPT_fprotect_parens,
5786 options::OPT_fno_protect_parens,
false))
5787 CmdArgs.push_back(
"-fprotect-parens");
5791 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_remote_memory,
5792 options::OPT_fno_atomic_remote_memory);
5793 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_fine_grained_memory,
5794 options::OPT_fno_atomic_fine_grained_memory);
5795 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_ignore_denormal_mode,
5796 options::OPT_fno_atomic_ignore_denormal_mode);
5798 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5800 if (
Arch == llvm::Triple::x86 ||
Arch == llvm::Triple::x86_64) {
5801 StringRef
V = A->getValue();
5803 CmdArgs.push_back(
"-fextend-arguments=64");
5805 D.
Diag(diag::err_drv_invalid_argument_to_option)
5806 << A->getValue() << A->getOption().getName();
5808 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5809 << A->getOption().getName() << TripleStr;
5812 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5813 if (TC.
getArch() == llvm::Triple::avr)
5814 A->render(Args, CmdArgs);
5816 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5817 << A->getAsString(Args) << TripleStr;
5820 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5822 A->render(Args, CmdArgs);
5824 (A->getOption().getID() != options::OPT_mlong_double_80))
5825 A->render(Args, CmdArgs);
5827 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5828 << A->getAsString(Args) << TripleStr;
5834 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5835 IsIntegratedAssemblerDefault))
5836 CmdArgs.push_back(
"-fno-verbose-asm");
5840 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5841 StringRef
V = A->getValue();
5844 A->render(Args, CmdArgs);
5845 else if (!
V.consumeInteger(10,
Num) &&
Num > 0 &&
5846 (
V.empty() || (
V.consume_front(
".") &&
5847 !
V.consumeInteger(10,
Num) &&
V.empty())))
5848 A->render(Args, CmdArgs);
5850 D.
Diag(diag::err_drv_invalid_argument_to_option)
5851 << A->getValue() << A->getOption().getName();
5857 CmdArgs.push_back(
"-no-integrated-as");
5859 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5860 CmdArgs.push_back(
"-mdebug-pass");
5861 CmdArgs.push_back(
"Structure");
5863 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5864 CmdArgs.push_back(
"-mdebug-pass");
5865 CmdArgs.push_back(
"Arguments");
5871 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5872 CmdArgs.push_back(
"-mconstructor-aliases");
5876 if (KernelOrKext && RawTriple.isOSDarwin())
5877 CmdArgs.push_back(
"-fforbid-guard-variables");
5879 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5880 Triple.isWindowsGNUEnvironment())) {
5881 CmdArgs.push_back(
"-mms-bitfields");
5884 if (Triple.isOSCygMing()) {
5885 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5886 options::OPT_fno_auto_import);
5889 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5890 Triple.isX86() && IsWindowsMSVC))
5891 CmdArgs.push_back(
"-fms-volatile");
5896 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5897 options::OPT_fno_direct_access_external_data)) {
5898 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5900 A->render(Args, CmdArgs);
5901 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
5904 CmdArgs.push_back(
"-fno-direct-access-external-data");
5907 if (Triple.isOSBinFormatELF() && (Triple.isAArch64() || Triple.isX86()))
5908 Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);
5914 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5917 CmdArgs.push_back(
"-ffreestanding");
5919 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5922 Args.AddLastArg(CmdArgs,
5923 options::OPT_fallow_runtime_check_skip_hot_cutoff_EQ);
5928 bool IsAsyncUnwindTablesDefault =
5930 bool IsSyncUnwindTablesDefault =
5933 bool AsyncUnwindTables = Args.hasFlag(
5934 options::OPT_fasynchronous_unwind_tables,
5935 options::OPT_fno_asynchronous_unwind_tables,
5936 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5939 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5940 IsSyncUnwindTablesDefault && !Freestanding);
5941 if (AsyncUnwindTables)
5942 CmdArgs.push_back(
"-funwind-tables=2");
5943 else if (UnwindTables)
5944 CmdArgs.push_back(
"-funwind-tables=1");
5948 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5949 (IsCudaDevice || IsHIPDevice || IsSYCLDevice)) {
5950 const ArgList &HostArgs =
5952 std::string HostCPU =
5954 if (!HostCPU.empty()) {
5955 CmdArgs.push_back(
"-aux-target-cpu");
5956 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5964 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
5966 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
5967 StringRef
Value = A->getValue();
5968 unsigned TLSSize = 0;
5969 Value.getAsInteger(10, TLSSize);
5970 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
5971 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5972 << A->getOption().getName() << TripleStr;
5973 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
5974 D.
Diag(diag::err_drv_invalid_int_value)
5975 << A->getOption().getName() <<
Value;
5976 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
5980 CmdArgs.push_back(
"-enable-tlsdesc");
5983 std::string CPU =
getCPUName(D, Args, Triple,
false);
5985 CmdArgs.push_back(
"-target-cpu");
5986 CmdArgs.push_back(Args.MakeArgString(CPU));
5989 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
5994 AddClangCLArgs(Args, InputType, CmdArgs);
5996 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
5997 llvm::codegenoptions::NoDebugInfo;
6000 DebugInfoKind, DwarfFission);
6011 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6012 CmdArgs.push_back(
"-split-dwarf-file");
6013 CmdArgs.push_back(SplitDWARFOut);
6015 CmdArgs.push_back(
"-split-dwarf-output");
6016 CmdArgs.push_back(SplitDWARFOut);
6021 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6022 CmdArgs.push_back(
"-target-linker-version");
6023 CmdArgs.push_back(A->getValue());
6028 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6030 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6031 TC.
getArch() == llvm::Triple::x86) {
6032 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6033 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6034 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6035 << Unsupported->getOption().getName();
6038 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6039 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6040 << Unsupported->getOption().getName()
6041 <<
"please use -maltivec and include altivec.h explicitly";
6042 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6043 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6044 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6047 Args.AddAllArgs(CmdArgs, options::OPT_v);
6049 if (Args.getLastArg(options::OPT_H)) {
6050 CmdArgs.push_back(
"-H");
6051 CmdArgs.push_back(
"-sys-header-deps");
6053 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6056 CmdArgs.push_back(
"-header-include-file");
6060 CmdArgs.push_back(
"-sys-header-deps");
6061 CmdArgs.push_back(Args.MakeArgString(
6062 "-header-include-format=" +
6065 Args.MakeArgString(
"-header-include-filtering=" +
6069 Args.AddLastArg(CmdArgs, options::OPT_P);
6070 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6073 CmdArgs.push_back(
"-diagnostic-log-file");
6082 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6086 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6087 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6088 CmdArgs.push_back(
"-mllvm");
6089 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6094 if (Args.hasFlag(options::OPT_ffunction_sections,
6095 options::OPT_fno_function_sections, UseSeparateSections)) {
6096 CmdArgs.push_back(
"-ffunction-sections");
6099 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6100 options::OPT_fno_basic_block_address_map)) {
6101 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6102 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6103 A->render(Args, CmdArgs);
6105 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6106 << A->getAsString(Args) << TripleStr;
6110 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6111 StringRef Val = A->getValue();
6112 if (Val ==
"labels") {
6113 D.
Diag(diag::warn_drv_deprecated_arg)
6114 << A->getAsString(Args) <<
true
6115 <<
"-fbasic-block-address-map";
6116 CmdArgs.push_back(
"-fbasic-block-address-map");
6117 }
else if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6118 if (Val !=
"all" && Val !=
"none" && !Val.starts_with(
"list="))
6119 D.
Diag(diag::err_drv_invalid_value)
6120 << A->getAsString(Args) << A->getValue();
6122 A->render(Args, CmdArgs);
6123 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6126 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6127 D.
Diag(diag::err_drv_invalid_value)
6128 << A->getAsString(Args) << A->getValue();
6130 A->render(Args, CmdArgs);
6131 }
else if (Triple.isNVPTX()) {
6134 }
else if (Val !=
"none") {
6137 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6138 << A->getAsString(Args) << TripleStr;
6142 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6143 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6144 UseSeparateSections || HasDefaultDataSections)) {
6145 CmdArgs.push_back(
"-fdata-sections");
6148 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6149 options::OPT_fno_unique_section_names);
6150 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6151 options::OPT_fno_separate_named_sections);
6152 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6153 options::OPT_fno_unique_internal_linkage_names);
6154 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6155 options::OPT_fno_unique_basic_block_section_names);
6157 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6158 options::OPT_fno_split_machine_functions)) {
6159 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6161 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6162 A->render(Args, CmdArgs);
6164 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6165 << A->getAsString(Args) << TripleStr;
6169 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6170 options::OPT_finstrument_functions_after_inlining,
6171 options::OPT_finstrument_function_entry_bare);
6172 Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6173 options::OPT_fno_convergent_functions);
6176 if (!Triple.isNVPTX())
6179 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6182 Args.hasFlag(options::OPT_fsample_profile_use_profi,
6183 options::OPT_fno_sample_profile_use_profi,
true)) {
6184 CmdArgs.push_back(
"-mllvm");
6185 CmdArgs.push_back(
"-sample-profile-use-profi");
6189 if (RawTriple.isPS() &&
6190 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6196 if (Args.hasArg(options::OPT_nostdinc)) {
6197 CmdArgs.push_back(
"-nostdsysteminc");
6198 CmdArgs.push_back(
"-nobuiltininc");
6200 if (Args.hasArg(options::OPT_nostdlibinc))
6201 CmdArgs.push_back(
"-nostdsysteminc");
6202 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6203 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6207 CmdArgs.push_back(
"-resource-dir");
6210 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6217 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6223 Args.ClaimAllArgs(options::OPT_D);
6227 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6228 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6233 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6234 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6240 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6243 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6245 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6246 unsigned WarningNumber;
6247 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6248 D.
Diag(diag::err_drv_invalid_int_value)
6249 << A->getAsString(Args) << A->getValue();
6254 CmdArgs.push_back(Args.MakeArgString(
6259 A->render(Args, CmdArgs);
6262 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6264 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6265 CmdArgs.push_back(
"-pedantic");
6266 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6267 Args.AddLastArg(CmdArgs, options::OPT_w);
6269 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6270 options::OPT_fno_fixed_point);
6272 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6273 A->render(Args, CmdArgs);
6275 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6276 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6278 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6279 options::OPT_fno_experimental_omit_vtable_rtti);
6281 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6282 A->render(Args, CmdArgs);
6289 bool ImplyVCPPCVer =
false;
6290 bool ImplyVCPPCXXVer =
false;
6291 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6293 if (Std->getOption().matches(options::OPT_ansi))
6295 CmdArgs.push_back(
"-std=c++98");
6297 CmdArgs.push_back(
"-std=c89");
6299 Std->render(Args, CmdArgs);
6302 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6303 options::OPT_ftrigraphs,
6304 options::OPT_fno_trigraphs))
6306 A->render(Args, CmdArgs);
6315 if (!Args.hasArg(options::OPT__SLASH_std)) {
6316 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6319 ImplyVCPPCVer =
true;
6321 else if (IsWindowsMSVC)
6322 ImplyVCPPCXXVer =
true;
6324 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6325 options::OPT_fno_trigraphs);
6341 Args.getLastArg(options::OPT_Wwrite_strings,
6342 options::OPT_Wno_write_strings, options::OPT_w);
6344 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6345 CmdArgs.push_back(
"-fconst-strings");
6352 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6354 CmdArgs.push_back(
"-fdeprecated-macro");
6358 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6359 if (
Asm->getOption().matches(options::OPT_fasm))
6360 CmdArgs.push_back(
"-fgnu-keywords");
6362 CmdArgs.push_back(
"-fno-gnu-keywords");
6366 CmdArgs.push_back(
"-fno-autolink");
6368 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6369 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6370 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6371 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6373 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6375 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6376 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6378 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6379 CmdArgs.push_back(
"-fbracket-depth");
6380 CmdArgs.push_back(A->getValue());
6383 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6384 options::OPT_Wlarge_by_value_copy_def)) {
6385 if (A->getNumValues()) {
6386 StringRef
bytes = A->getValue();
6387 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6389 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6392 if (Args.hasArg(options::OPT_relocatable_pch))
6393 CmdArgs.push_back(
"-relocatable-pch");
6395 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6396 static const char *kCFABIs[] = {
6397 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6400 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6401 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6403 A->render(Args, CmdArgs);
6406 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6407 CmdArgs.push_back(
"-fconstant-string-class");
6408 CmdArgs.push_back(A->getValue());
6411 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6412 CmdArgs.push_back(
"-ftabstop");
6413 CmdArgs.push_back(A->getValue());
6416 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6417 options::OPT_fno_stack_size_section);
6419 if (Args.hasArg(options::OPT_fstack_usage)) {
6420 CmdArgs.push_back(
"-stack-usage-file");
6422 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6424 llvm::sys::path::replace_extension(OutputFilename,
"su");
6425 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6431 CmdArgs.push_back(
"-ferror-limit");
6432 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6433 CmdArgs.push_back(A->getValue());
6435 CmdArgs.push_back(
"19");
6437 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6438 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6439 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6440 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6441 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6444 unsigned MessageLength = 0;
6445 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6446 StringRef
V(A->getValue());
6447 if (
V.getAsInteger(0, MessageLength))
6448 D.
Diag(diag::err_drv_invalid_argument_to_option)
6449 <<
V << A->getOption().getName();
6453 MessageLength = llvm::sys::Process::StandardErrColumns();
6455 if (MessageLength != 0)
6457 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6459 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6461 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6463 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6464 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6465 Twine(A->getValue(0))));
6468 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6469 options::OPT_fvisibility_ms_compat)) {
6470 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6471 A->render(Args, CmdArgs);
6473 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6474 CmdArgs.push_back(
"-fvisibility=hidden");
6475 CmdArgs.push_back(
"-ftype-visibility=default");
6477 }
else if (IsOpenMPDevice) {
6481 CmdArgs.push_back(
"-fvisibility=protected");
6485 if (!RawTriple.isPS()) {
6487 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6488 options::OPT_fno_visibility_from_dllstorageclass)) {
6489 if (A->getOption().matches(
6490 options::OPT_fvisibility_from_dllstorageclass)) {
6491 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6492 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6493 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6494 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6495 Args.AddLastArg(CmdArgs,
6496 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6501 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6502 options::OPT_fno_visibility_inlines_hidden,
false))
6503 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6505 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6506 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6511 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6512 D.
Diag(diag::warn_drv_deprecated_arg)
6513 << A->getAsString(Args) <<
true
6514 <<
"-fvisibility-global-new-delete=force-hidden";
6518 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6519 options::OPT_fvisibility_global_new_delete_hidden)) {
6520 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6521 A->render(Args, CmdArgs);
6523 assert(A->getOption().matches(
6524 options::OPT_fvisibility_global_new_delete_hidden));
6525 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6529 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6531 if (Args.hasFlag(options::OPT_fnew_infallible,
6532 options::OPT_fno_new_infallible,
false))
6533 CmdArgs.push_back(
"-fnew-infallible");
6535 if (Args.hasFlag(options::OPT_fno_operator_names,
6536 options::OPT_foperator_names,
false))
6537 CmdArgs.push_back(
"-fno-operator-names");
6540 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6541 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6542 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6543 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6544 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
6545 options::OPT_fno_raw_string_literals);
6547 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6548 Triple.hasDefaultEmulatedTLS()))
6549 CmdArgs.push_back(
"-femulated-tls");
6551 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6552 options::OPT_fno_check_new);
6554 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6558 if (!Triple.isX86() && !Triple.isAArch64())
6559 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6560 << A->getAsString(Args) << TripleStr;
6565 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6567 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6568 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6572 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6573 options::OPT_fno_openmp,
false) &&
6574 !Args.hasFlag(options::OPT_foffload_via_llvm,
6575 options::OPT_fno_offload_via_llvm,
false) &&
6582 CmdArgs.push_back(
"-fopenmp");
6587 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6588 options::OPT_fnoopenmp_use_tls,
true))
6589 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6590 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6591 options::OPT_fno_openmp_simd);
6592 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6593 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6594 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6595 options::OPT_fno_openmp_extensions,
true))
6596 CmdArgs.push_back(
"-fno-openmp-extensions");
6597 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6598 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6599 Args.AddAllArgs(CmdArgs,
6600 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6601 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6602 options::OPT_fno_openmp_optimistic_collapse,
6604 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6608 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6609 options::OPT_fno_openmp_cuda_mode,
false))
6610 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6613 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6614 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6615 options::OPT_fno_openmp_target_debug,
false))
6616 CmdArgs.push_back(
"-fopenmp-target-debug");
6620 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6621 options::OPT_fno_openmp_assume_teams_oversubscription,
6623 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6624 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6625 options::OPT_fno_openmp_assume_threads_oversubscription,
6627 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6628 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6629 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6630 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6631 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6632 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6633 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6634 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6635 CmdArgs.push_back(
"-fopenmp-force-usm");
6647 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6648 options::OPT_fno_openmp_simd);
6649 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6650 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6651 options::OPT_fno_openmp_extensions);
6656 if (Args.hasFlag(options::OPT_foffload_via_llvm,
6657 options::OPT_fno_offload_via_llvm,
false)) {
6658 CmdArgs.append({
"--offload-new-driver",
"-foffload-via-llvm"});
6659 }
else if (Args.hasFlag(options::OPT_offload_new_driver,
6660 options::OPT_no_offload_new_driver,
6662 CmdArgs.push_back(
"--offload-new-driver");
6666 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6668 for (
const auto &Filename :
6669 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6670 if (D.
getVFS().exists(Filename))
6671 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" + Filename));
6673 D.
Diag(clang::diag::err_drv_no_such_file) << Filename;
6676 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6677 StringRef S0 = A->getValue(), S = S0;
6678 unsigned Size, Offset = 0;
6679 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6681 !(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||
6682 Triple.getArch() == llvm::Triple::ppc64 ||
6683 Triple.getArch() == llvm::Triple::ppc64le)))
6684 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6685 << A->getAsString(Args) << TripleStr;
6686 else if (S.consumeInteger(10, Size) ||
6688 (!S.consume_front(
",") || S.consumeInteger(10, Offset))) ||
6689 (!S.empty() && (!S.consume_front(
",") || S.empty())))
6690 D.
Diag(diag::err_drv_invalid_argument_to_option)
6691 << S0 << A->getOption().getName();
6692 else if (Size < Offset)
6693 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6695 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6696 CmdArgs.push_back(Args.MakeArgString(
6697 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6700 Args.MakeArgString(
"-fpatchable-function-entry-section=" + S));
6704 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6706 if (Args.hasArg(options::OPT_fms_secure_hotpatch_functions_file))
6707 Args.AddLastArg(CmdArgs, options::OPT_fms_secure_hotpatch_functions_file);
6709 for (
const auto &A :
6710 Args.getAllArgValues(options::OPT_fms_secure_hotpatch_functions_list))
6712 Args.MakeArgString(
"-fms-secure-hotpatch-functions-list=" + Twine(A)));
6715 Args.AddLastArg(CmdArgs, options::OPT_pg);
6718 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6719 if (
Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6720 A->render(Args, CmdArgs);
6722 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6723 << A->getAsString(Args) << TripleStr;
6725 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6726 if (
Arch == llvm::Triple::systemz)
6727 A->render(Args, CmdArgs);
6729 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6730 << A->getAsString(Args) << TripleStr;
6732 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6733 if (
Arch == llvm::Triple::systemz)
6734 A->render(Args, CmdArgs);
6736 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6737 << A->getAsString(Args) << TripleStr;
6741 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6743 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6744 << A->getAsString(Args) << TripleStr;
6747 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6749 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6750 << A->getAsString(Args) << TripleStr;
6753 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6754 if (A->getOption().matches(options::OPT_p)) {
6756 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6757 CmdArgs.push_back(
"-pg");
6763 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6764 options::OPT_mxcoff_build_id_EQ)) {
6765 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6766 << A->getSpelling() << TripleStr;
6770 if (Args.getLastArg(options::OPT_fapple_kext) ||
6771 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6772 CmdArgs.push_back(
"-fapple-kext");
6774 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6775 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6776 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6777 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6778 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6779 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6780 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6781 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_json);
6782 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6783 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6784 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6786 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
6787 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
6788 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6789 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
6792 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6793 CmdArgs.push_back(
"-ftrapv-handler");
6794 CmdArgs.push_back(A->getValue());
6797 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6803 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6804 options::OPT_fno_finite_loops);
6806 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6807 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6808 options::OPT_fno_unroll_loops);
6809 Args.AddLastArg(CmdArgs, options::OPT_floop_interchange,
6810 options::OPT_fno_loop_interchange);
6811 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_loop_fusion,
6812 options::OPT_fno_experimental_loop_fusion);
6814 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6816 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6818 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6819 options::OPT_mno_speculative_load_hardening);
6825 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6827 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6828 options::OPT_mno_stackrealign);
6830 if (
const Arg *A = Args.getLastArg(options::OPT_mstack_alignment)) {
6831 StringRef
Value = A->getValue();
6832 int64_t Alignment = 0;
6833 if (
Value.getAsInteger(10, Alignment) || Alignment < 0)
6834 D.
Diag(diag::err_drv_invalid_argument_to_option)
6835 <<
Value << A->getOption().getName();
6836 else if (Alignment & (Alignment - 1))
6837 D.
Diag(diag::err_drv_alignment_not_power_of_two)
6838 << A->getAsString(Args) <<
Value;
6840 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" +
Value));
6843 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6844 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6847 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6849 CmdArgs.push_back(
"-mstack-probe-size=0");
6852 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6853 options::OPT_mno_stack_arg_probe);
6855 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6856 options::OPT_mno_restrict_it)) {
6857 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6858 CmdArgs.push_back(
"-mllvm");
6859 CmdArgs.push_back(
"-arm-restrict-it");
6861 CmdArgs.push_back(
"-mllvm");
6862 CmdArgs.push_back(
"-arm-default-it");
6876 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6877 options::OPT_fno_hip_new_launch_api,
true))
6878 CmdArgs.push_back(
"-fhip-new-launch-api");
6879 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6880 options::OPT_fno_gpu_allow_device_init);
6881 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6882 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6883 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6884 options::OPT_fno_hip_kernel_arg_name);
6887 if (IsCuda || IsHIP) {
6889 CmdArgs.push_back(
"-fgpu-rdc");
6890 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6891 options::OPT_fno_gpu_defer_diag);
6892 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6893 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6895 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6896 CmdArgs.push_back(
"-fgpu-defer-diag");
6901 if (!Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
true))
6902 CmdArgs.push_back(
"--no-offloadlib");
6904 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6906 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
6908 if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
6909 CmdArgs.push_back(Args.MakeArgString(Twine(
"-mcf-branch-label-scheme=") +
6911 }
else if (Triple.isOSOpenBSD() && Triple.getArch() == llvm::Triple::x86_64) {
6913 CmdArgs.push_back(
"-fcf-protection=branch");
6915 CmdArgs.push_back(
"-fno-jump-tables");
6918 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6920 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
6922 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6927 if (!(IsCudaDevice || IsHIPDevice)) {
6929 auto *PGOArg = Args.getLastArg(
6930 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
6931 options::OPT_fcs_profile_generate,
6932 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
6933 options::OPT_fprofile_use_EQ);
6935 D.
Diag(diag::err_drv_argument_not_allowed_with)
6936 <<
"SampleUse with PGO options";
6938 StringRef fname = A->getValue();
6939 if (!llvm::sys::fs::exists(fname))
6940 D.
Diag(diag::err_drv_no_such_file) << fname;
6942 A->render(Args, CmdArgs);
6944 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6946 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6947 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
6948 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
6951 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6952 options::OPT_fno_unique_internal_linkage_names,
true))
6953 CmdArgs.push_back(
"-funique-internal-linkage-names");
6958 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6959 options::OPT_fno_assume_sane_operator_new);
6961 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
6962 CmdArgs.push_back(
"-fapinotes");
6963 if (Args.hasFlag(options::OPT_fapinotes_modules,
6964 options::OPT_fno_apinotes_modules,
false))
6965 CmdArgs.push_back(
"-fapinotes-modules");
6966 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
6968 if (Args.hasFlag(options::OPT_fswift_version_independent_apinotes,
6969 options::OPT_fno_swift_version_independent_apinotes,
false))
6970 CmdArgs.push_back(
"-fswift-version-independent-apinotes");
6973 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
6975 (Args.hasArg(options::OPT_fgnu_runtime) &&
6976 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
6977 !Args.hasArg(options::OPT_fno_blocks))) {
6978 CmdArgs.push_back(
"-fblocks");
6981 CmdArgs.push_back(
"-fblocks-runtime-optional");
6986 CmdArgs.push_back(
"-fencode-extended-block-signature");
6988 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
6989 options::OPT_fno_coro_aligned_allocation,
false) &&
6991 CmdArgs.push_back(
"-fcoro-aligned-allocation");
6993 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
6994 options::OPT_fno_double_square_bracket_attributes);
6996 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
6997 options::OPT_fno_access_control);
6998 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
6999 options::OPT_fno_elide_constructors);
7005 CmdArgs.push_back(
"-fno-rtti");
7008 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7009 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
7010 CmdArgs.push_back(
"-fshort-enums");
7016 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
7017 !RawTriple.isOSAIX() &&
7018 (!RawTriple.isOSWindows() ||
7019 RawTriple.isWindowsCygwinEnvironment()) &&
7020 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
7021 RawTriple.hasEnvironment())) ||
7023 CmdArgs.push_back(
"-fno-use-cxa-atexit");
7025 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7026 options::OPT_fno_register_global_dtors_with_atexit,
7027 RawTriple.isOSDarwin() && !KernelOrKext))
7028 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7030 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7031 options::OPT_fno_use_line_directives);
7034 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7035 options::OPT_fno_minimize_whitespace,
false)) {
7036 types::ID InputType = Inputs[0].getType();
7037 if (!isDerivedFromC(InputType))
7038 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7040 CmdArgs.push_back(
"-fminimize-whitespace");
7044 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7045 options::OPT_fno_keep_system_includes,
false)) {
7046 types::ID InputType = Inputs[0].getType();
7047 if (!isDerivedFromC(InputType))
7048 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7050 CmdArgs.push_back(
"-fkeep-system-includes");
7054 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7055 IsWindowsMSVC || IsUEFI))
7056 CmdArgs.push_back(
"-fms-extensions");
7059 bool IsMSVCCompat = Args.hasFlag(
7060 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7061 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7062 options::OPT_fno_ms_extensions,
true)));
7064 CmdArgs.push_back(
"-fms-compatibility");
7066 Args.hasArg(options::OPT_fms_define_stdc))
7067 CmdArgs.push_back(
"-fms-define-stdc");
7070 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7071 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7075 VersionTuple GNUCVer;
7076 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7079 StringRef Val = A->getValue();
7080 Val = Val.empty() ?
"0" : Val;
7081 bool Invalid = GNUCVer.tryParse(Val);
7082 unsigned Minor = GNUCVer.getMinor().value_or(0);
7083 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7084 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7085 D.
Diag(diag::err_drv_invalid_value)
7086 << A->getAsString(Args) << A->getValue();
7088 }
else if (!IsMSVCCompat) {
7090 GNUCVer = VersionTuple(4, 2, 1);
7092 if (!GNUCVer.empty()) {
7094 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7100 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7102 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7103 if (ImplyVCPPCVer) {
7105 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7108 .Case(
"c11",
"-std=c11")
7109 .Case(
"c17",
"-std=c17")
7111 .Case(
"clatest",
"-std=c23")
7114 D.
Diag(clang::diag::warn_drv_unused_argument)
7115 << StdArg->getAsString(Args);
7119 if (ImplyVCPPCXXVer) {
7121 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7124 .Case(
"c++14",
"-std=c++14")
7125 .Case(
"c++17",
"-std=c++17")
7126 .Case(
"c++20",
"-std=c++20")
7128 .Case(
"c++23preview",
"-std=c++23")
7129 .Case(
"c++latest",
"-std=c++26")
7132 D.
Diag(clang::diag::warn_drv_unused_argument)
7133 << StdArg->getAsString(Args);
7137 if (IsMSVC2015Compatible)
7146 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7147 options::OPT_fno_borland_extensions);
7150 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7152 CmdArgs.push_back(
"-fdeclspec");
7153 else if (Args.hasArg(options::OPT_fno_declspec))
7154 CmdArgs.push_back(
"-fno-declspec");
7158 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7159 options::OPT_fno_threadsafe_statics,
7161 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7162 CmdArgs.push_back(
"-fno-threadsafe-statics");
7164 if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7166 CmdArgs.push_back(
"-fno-ms-tls-guards");
7169 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7171 CmdArgs.push_back(
"-fno-assumptions");
7175 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7176 options::OPT_fno_gnu_keywords);
7178 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7179 options::OPT_fno_gnu89_inline);
7181 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7182 options::OPT_finline_hint_functions,
7183 options::OPT_fno_inline_functions);
7184 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7185 if (A->getOption().matches(options::OPT_fno_inline))
7186 A->render(Args, CmdArgs);
7187 }
else if (InlineArg) {
7188 InlineArg->render(Args, CmdArgs);
7191 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7196 (Std->containsValue(
"c++2a") || Std->containsValue(
"gnu++2a") ||
7197 Std->containsValue(
"c++20") || Std->containsValue(
"gnu++20") ||
7198 Std->containsValue(
"c++2b") || Std->containsValue(
"gnu++2b") ||
7199 Std->containsValue(
"c++23") || Std->containsValue(
"gnu++23") ||
7200 Std->containsValue(
"c++2c") || Std->containsValue(
"gnu++2c") ||
7201 Std->containsValue(
"c++26") || Std->containsValue(
"gnu++26") ||
7202 Std->containsValue(
"c++latest") || Std->containsValue(
"gnu++latest"));
7217 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7218 options::OPT_fno_delayed_template_parsing,
7219 IsWindowsMSVC && !HaveCxx20)) {
7221 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7223 CmdArgs.push_back(
"-fdelayed-template-parsing");
7226 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7227 options::OPT_fno_pch_validate_input_files_content,
false))
7228 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7229 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7230 options::OPT_fno_pch_instantiate_templates,
false))
7231 CmdArgs.push_back(
"-fpch-instantiate-templates");
7232 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7234 CmdArgs.push_back(
"-fmodules-codegen");
7235 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7237 CmdArgs.push_back(
"-fmodules-debuginfo");
7239 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7244 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7245 options::OPT_fno_objc_encode_cxx_class_template_spec,
7247 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7249 if (Args.hasFlag(options::OPT_fapplication_extension,
7250 options::OPT_fno_application_extension,
false))
7251 CmdArgs.push_back(
"-fapplication-extension");
7255 if (!
C.getDriver().IsCLMode())
7256 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7259 Arg *A = Args.getLastArg(
7260 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7261 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7263 const Option &Opt = A->getOption();
7264 if (Opt.matches(options::OPT_fsjlj_exceptions))
7265 CmdArgs.push_back(
"-exception-model=sjlj");
7266 if (Opt.matches(options::OPT_fseh_exceptions))
7267 CmdArgs.push_back(
"-exception-model=seh");
7268 if (Opt.matches(options::OPT_fdwarf_exceptions))
7269 CmdArgs.push_back(
"-exception-model=dwarf");
7270 if (Opt.matches(options::OPT_fwasm_exceptions))
7271 CmdArgs.push_back(
"-exception-model=wasm");
7276 case llvm::ExceptionHandling::DwarfCFI:
7277 CmdArgs.push_back(
"-exception-model=dwarf");
7279 case llvm::ExceptionHandling::SjLj:
7280 CmdArgs.push_back(
"-exception-model=sjlj");
7282 case llvm::ExceptionHandling::WinEH:
7283 CmdArgs.push_back(
"-exception-model=seh");
7289 Args.AddLastArg(CmdArgs, options::OPT_winx64_eh_unwindv2);
7292 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7293 options::OPT_fno_assume_sane_operator_new);
7296 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7297 options::OPT_fno_assume_unique_vtables);
7301 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
7302 options::OPT_fno_sized_deallocation);
7306 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7307 options::OPT_fno_aligned_allocation,
7308 options::OPT_faligned_new_EQ)) {
7309 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7310 CmdArgs.push_back(
"-fno-aligned-allocation");
7312 CmdArgs.push_back(
"-faligned-allocation");
7317 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7318 options::OPT_faligned_new_EQ))
7320 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7324 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7325 options::OPT_fno_constant_cfstrings,
true) ||
7326 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7327 options::OPT_mno_constant_cfstrings,
true))
7328 CmdArgs.push_back(
"-fno-constant-cfstrings");
7330 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7331 options::OPT_fno_pascal_strings);
7335 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7336 std::string PackStructStr =
"-fpack-struct=";
7337 PackStructStr += A->getValue();
7338 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7339 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7340 options::OPT_fno_pack_struct,
false)) {
7341 CmdArgs.push_back(
"-fpack-struct=1");
7345 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7346 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7347 if (!SkipMaxTypeAlign) {
7348 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7349 MaxTypeAlignStr += A->getValue();
7350 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7352 }
else if (RawTriple.isOSDarwin()) {
7353 if (!SkipMaxTypeAlign) {
7354 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7355 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7359 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7360 CmdArgs.push_back(
"-Qn");
7363 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7367 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7368 options::OPT_funsigned_bitfields,
true))
7369 D.
Diag(diag::warn_drv_clang_unsupported)
7370 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7373 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7374 D.
Diag(diag::err_drv_clang_unsupported)
7375 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7378 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7379 StringRef value = inputCharset->getValue();
7380 if (!value.equals_insensitive(
"utf-8"))
7381 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7386 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7387 StringRef value = execCharset->getValue();
7388 if (!value.equals_insensitive(
"utf-8"))
7389 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7395 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7396 options::OPT_fno_asm_blocks);
7398 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7399 options::OPT_fno_gnu_inline_asm);
7405 if (!VecWidth.empty())
7406 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + VecWidth));
7408 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7409 Args.AddLastArg(CmdArgs,
7410 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7414 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7415 options::OPT_fno_dollars_in_identifiers)) {
7416 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7417 CmdArgs.push_back(
"-fdollars-in-identifiers");
7419 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7422 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7423 options::OPT_fno_apple_pragma_pack);
7429 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7430 options::OPT_fno_rewrite_imports,
false);
7432 CmdArgs.push_back(
"-frewrite-imports");
7434 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7435 options::OPT_fno_directives_only);
7441 if (Args.hasFlag(options::OPT_frewrite_includes,
7442 options::OPT_fno_rewrite_includes,
false) ||
7443 (
C.isForDiagnostics() && !HaveModules))
7444 CmdArgs.push_back(
"-frewrite-includes");
7446 if (Args.hasFlag(options::OPT_fzos_extensions,
7447 options::OPT_fno_zos_extensions,
false))
7448 CmdArgs.push_back(
"-fzos-extensions");
7449 else if (Args.hasArg(options::OPT_fno_zos_extensions))
7450 CmdArgs.push_back(
"-fno-zos-extensions");
7453 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7454 options::OPT_traditional_cpp)) {
7456 CmdArgs.push_back(
"-traditional-cpp");
7458 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7461 Args.AddLastArg(CmdArgs, options::OPT_dM);
7462 Args.AddLastArg(CmdArgs, options::OPT_dD);
7463 Args.AddLastArg(CmdArgs, options::OPT_dI);
7465 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7468 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7469 CmdArgs.push_back(
"-serialize-diagnostic-file");
7470 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7473 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7474 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7476 if (Arg *A = Args.getLastArg(options::OPT_fextend_variable_liveness_EQ)) {
7477 A->render(Args, CmdArgs);
7478 }
else if (Arg *A = Args.getLastArg(options::OPT_O_Group);
7479 A && A->containsValue(
"g")) {
7481 CmdArgs.push_back(
"-fextend-variable-liveness=all");
7485 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7487 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7490 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7491 CmdArgs.push_back(
"-load");
7492 CmdArgs.push_back(A->getValue());
7504 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7505 auto ArgValue = StringRef(A->getValue());
7506 auto FirstDashIndex = ArgValue.find(
'-');
7507 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7508 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7511 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7512 if (PluginName.empty()) {
7513 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7515 D.
Diag(diag::warn_drv_missing_plugin_arg)
7516 << PluginName << A->getAsString(Args);
7521 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7522 CmdArgs.push_back(Args.MakeArgString(Arg));
7526 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7528 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7533 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7534 CmdArgs.push_back(
"--vfsoverlay");
7535 CmdArgs.push_back(A->getValue());
7539 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7540 options::OPT_fno_safe_buffer_usage_suggestions);
7542 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7543 options::OPT_fno_experimental_late_parse_attributes);
7545 if (Args.hasFlag(options::OPT_funique_source_file_names,
7546 options::OPT_fno_unique_source_file_names,
false)) {
7547 if (Arg *A = Args.getLastArg(options::OPT_unique_source_file_identifier_EQ))
7548 A->render(Args, CmdArgs);
7550 CmdArgs.push_back(Args.MakeArgString(
7551 Twine(
"-funique-source-file-identifier=") + Input.
getBaseInput()));
7556 if (!StatsFile.empty()) {
7557 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7559 CmdArgs.push_back(
"-stats-file-append");
7564 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7568 if (
C.getDriver().isSaveTempsEnabled() &&
7570 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7573 CmdArgs.push_back(Arg->getValue());
7575 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7581 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7582 CmdArgs.push_back(
"-disable-llvm-optzns");
7584 A->render(Args, CmdArgs);
7590 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
7594 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
7596 A->render(Args, CmdArgs);
7608 if ((
C.getDriver().isSaveTempsEnabled() ||
7610 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7612 CmdArgs.push_back(
"-disable-llvm-passes");
7614 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7623 auto GRecordSwitches =
false;
7624 auto FRecordSwitches =
false;
7628 CmdArgs.push_back(
"-dwarf-debug-flags");
7629 CmdArgs.push_back(FlagsArgString);
7631 if (FRecordSwitches) {
7632 CmdArgs.push_back(
"-record-command-line");
7633 CmdArgs.push_back(FlagsArgString);
7640 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7641 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7642 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7643 }
else if (!HostOffloadingInputs.empty()) {
7644 if (IsCuda && !IsRDCMode) {
7645 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7646 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7647 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7649 for (
const InputInfo Input : HostOffloadingInputs)
7650 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7656 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7657 options::OPT_fno_cuda_short_ptr,
false))
7658 CmdArgs.push_back(
"-fcuda-short-ptr");
7661 if (IsCuda || IsHIP) {
7663 const Action *SourceAction = &JA;
7665 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7666 SourceAction = SourceAction->
getInputs()[0];
7670 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7674 bool UseApproxTranscendentals = Args.hasFlag(
7675 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7676 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7677 options::OPT_fno_gpu_approx_transcendentals,
7678 UseApproxTranscendentals))
7679 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7681 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7682 options::OPT_fno_gpu_approx_transcendentals);
7686 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7687 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7690 Args.AddAllArgs(CmdArgs,
7691 options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);
7693 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7694 options::OPT_fno_offload_uniform_block);
7696 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7697 options::OPT_fno_offload_implicit_host_device_templates);
7699 if (IsCudaDevice || IsHIPDevice) {
7700 StringRef InlineThresh =
7701 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7702 if (!InlineThresh.empty()) {
7703 std::string ArgStr =
7704 std::string(
"-inline-threshold=") + InlineThresh.str();
7705 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7710 Args.addOptOutFlag(CmdArgs,
7711 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7712 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7719 if (IsOpenMPDevice) {
7720 CmdArgs.push_back(
"-fopenmp-is-target-device");
7722 if (Args.hasArg(options::OPT_foffload_via_llvm))
7723 CmdArgs.push_back(
"-fcuda-is-device");
7725 if (OpenMPDeviceInput) {
7726 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7727 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7731 if (Triple.isAMDGPU()) {
7734 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7735 options::OPT_mno_unsafe_fp_atomics);
7736 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7737 options::OPT_mno_amdgpu_ieee);
7742 bool VirtualFunctionElimination =
7743 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7744 options::OPT_fno_virtual_function_elimination,
false);
7745 if (VirtualFunctionElimination) {
7749 D.
Diag(diag::err_drv_argument_only_allowed_with)
7750 <<
"-fvirtual-function-elimination"
7753 CmdArgs.push_back(
"-fvirtual-function-elimination");
7757 bool WholeProgramVTables = Args.hasFlag(
7758 options::OPT_fwhole_program_vtables,
7759 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7760 if (VirtualFunctionElimination && !WholeProgramVTables) {
7761 D.
Diag(diag::err_drv_argument_not_allowed_with)
7762 <<
"-fno-whole-program-vtables"
7763 <<
"-fvirtual-function-elimination";
7766 if (WholeProgramVTables) {
7779 auto OtherIsUsingLTO = OtherLTOMode !=
LTOK_None;
7781 if ((!IsUsingLTO && !OtherIsUsingLTO) ||
7783 D.
Diag(diag::err_drv_argument_only_allowed_with)
7784 <<
"-fwhole-program-vtables"
7785 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7789 CmdArgs.push_back(
"-fwhole-program-vtables");
7792 bool DefaultsSplitLTOUnit =
7793 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7795 (!Triple.isPS4() && UnifiedLTO);
7797 Args.hasFlag(options::OPT_fsplit_lto_unit,
7798 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
7799 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
7800 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
7801 <<
"-fsanitize=cfi";
7803 CmdArgs.push_back(
"-fsplit-lto-unit");
7805 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7806 options::OPT_fno_fat_lto_objects)) {
7807 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
7809 if (!Triple.isOSBinFormatELF()) {
7810 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7813 CmdArgs.push_back(Args.MakeArgString(
7814 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
7815 CmdArgs.push_back(
"-flto-unit");
7816 CmdArgs.push_back(
"-ffat-lto-objects");
7817 A->render(Args, CmdArgs);
7821 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7822 options::OPT_fno_global_isel)) {
7823 CmdArgs.push_back(
"-mllvm");
7824 if (A->getOption().matches(options::OPT_fglobal_isel)) {
7825 CmdArgs.push_back(
"-global-isel=1");
7830 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
7831 bool IsOptLevelSupported =
false;
7833 Arg *A = Args.getLastArg(options::OPT_O_Group);
7834 if (Triple.getArch() == llvm::Triple::aarch64) {
7835 if (!A || A->getOption().matches(options::OPT_O0))
7836 IsOptLevelSupported =
true;
7838 if (!IsArchSupported || !IsOptLevelSupported) {
7839 CmdArgs.push_back(
"-mllvm");
7840 CmdArgs.push_back(
"-global-isel-abort=2");
7842 if (!IsArchSupported)
7843 D.
Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
7845 D.
Diag(diag::warn_drv_global_isel_incomplete_opt);
7848 CmdArgs.push_back(
"-global-isel=0");
7852 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7853 options::OPT_fno_force_enable_int128)) {
7854 if (A->getOption().matches(options::OPT_fforce_enable_int128))
7855 CmdArgs.push_back(
"-fforce-enable-int128");
7858 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7859 options::OPT_fno_keep_static_consts);
7860 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7861 options::OPT_fno_keep_persistent_storage_variables);
7862 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7863 options::OPT_fno_complete_member_pointers);
7864 if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
7865 A->render(Args, CmdArgs);
7871 if (Triple.isAArch64() &&
7872 (Args.hasArg(options::OPT_mno_fmv) ||
7873 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
7876 CmdArgs.push_back(
"-target-feature");
7877 CmdArgs.push_back(
"-fmv");
7880 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7887 CmdArgs.push_back(
"-faddrsig");
7889 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
7890 (EH || UnwindTables || AsyncUnwindTables ||
7891 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
7892 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
7894 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7895 std::string Str = A->getAsString(Args);
7897 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7899 CmdArgs.push_back(Args.MakeArgString(Str));
7904 if (Output.
getType() == types::TY_Dependencies) {
7907 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
7908 Output.
getType() == clang::driver::types::TY_IFS) {
7910 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
7911 CmdArgs.push_back(
"-o");
7912 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7914 CmdArgs.push_back(
"-o");
7918 assert(Output.
isNothing() &&
"Invalid output.");
7925 FrontendInputs = ExtractAPIInputs;
7927 FrontendInputs = {};
7929 for (
const InputInfo &Input : FrontendInputs) {
7938 C.addCommand(std::make_unique<CC1Command>(
7942 C.addCommand(std::make_unique<Command>(
7948 if (Output.
getType() == types::TY_Object &&
7949 Args.hasFlag(options::OPT__SLASH_showFilenames,
7950 options::OPT__SLASH_showFilenames_,
false)) {
7951 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
7954 if (Arg *A = Args.getLastArg(options::OPT_pg))
7956 !Args.hasArg(options::OPT_mfentry))
7957 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
7958 << A->getAsString(Args);
7964 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
7968 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
7969 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
7972 Args.ClaimAllArgs(options::OPT_emit_llvm);