4820 const ArgList &Args,
const char *LinkingOutput)
const {
4822 const llvm::Triple &RawTriple = TC.
getTriple();
4824 const std::string &TripleStr = Triple.getTriple();
4827 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
4829 ArgStringList CmdArgs;
4831 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
4849 bool IsHostOffloadingAction =
4853 Args.hasFlag(options::OPT_offload_new_driver,
4854 options::OPT_no_offload_new_driver,
4858 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
false);
4869 IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];
4873 const InputInfo *CudaDeviceInput =
nullptr;
4874 const InputInfo *OpenMPDeviceInput =
nullptr;
4876 if (&I == &Input || I.
getType() == types::TY_Nothing) {
4878 }
else if (IsExtractAPI) {
4879 auto ExpectedInputType = ExtractAPIPlaceholderInput.
getType();
4880 if (I.getType() != ExpectedInputType) {
4881 D.
Diag(diag::err_drv_extract_api_wrong_kind)
4885 ExtractAPIInputs.push_back(I);
4886 }
else if (IsHostOffloadingAction) {
4887 HostOffloadingInputs.push_back(I);
4888 }
else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
4889 CudaDeviceInput = &I;
4890 }
else if (IsOpenMPDevice && !OpenMPDeviceInput) {
4891 OpenMPDeviceInput = &I;
4893 llvm_unreachable(
"unexpectedly given multiple inputs");
4897 const llvm::Triple *AuxTriple =
4899 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
4900 bool IsUEFI = RawTriple.isUEFI();
4901 bool IsIAMCU = RawTriple.isOSIAMCU();
4906 if (IsCuda || IsHIP || IsSYCL)
4907 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
4911 D.
Diag(diag::err_drv_clang_unsupported) <<
"C++ for IAMCU";
4916 CmdArgs.push_back(
"-cc1");
4919 CmdArgs.push_back(
"-triple");
4920 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4922 if (
const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
4923 DumpCompilationDatabase(
C, MJ->getValue(), TripleStr, Output, Input, Args);
4924 Args.ClaimAllArgs(options::OPT_MJ);
4925 }
else if (
const Arg *GenCDBFragment =
4926 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
4927 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),
C,
4928 TripleStr, Output, Input, Args);
4929 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
4932 if (IsCuda || IsHIP) {
4935 std::string NormalizedTriple;
4953 assert(CTC &&
"Expected valid CUDA Toolchain.");
4955 CmdArgs.push_back(Args.MakeArgString(
4956 Twine(
"-target-sdk-version=") +
4964 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
4967 CmdArgs.push_back(
"-aux-triple");
4968 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
4973 getToolChain().getTriple().getVendor() == llvm::Triple::AMD))) {
4975 if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) {
4976 CmdArgs.push_back(Args.MakeArgString(
4978 Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));
4981 Args.MakeArgString(
"-Werror=format-invalid-specifier"));
4987 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4988 if (A->getOption().matches(options::OPT_O4)) {
4989 CmdArgs.push_back(
"-O3");
4990 D.
Diag(diag::warn_O4_is_O3);
4992 A->render(Args, CmdArgs);
4997 if (
const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
5003 llvm::Triple AuxT =
C.getDefaultToolChain().getTriple();
5004 std::string NormalizedTriple = AuxT.normalize();
5005 CmdArgs.push_back(
"-aux-triple");
5006 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5009 CmdArgs.push_back(
"-fsycl-is-device");
5012 if (!Args.getLastArg(options::OPT_O_Group))
5013 CmdArgs.push_back(
"-O2");
5020 CmdArgs.push_back(
"-fsycl-is-host");
5024 Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
5026 SYCLStdArg->render(Args, CmdArgs);
5029 CmdArgs.push_back(
"-sycl-std=2020");
5033 if (Args.hasArg(options::OPT_fclangir))
5034 CmdArgs.push_back(
"-fclangir");
5036 if (IsOpenMPDevice) {
5038 std::string NormalizedTriple =
5042 CmdArgs.push_back(
"-aux-triple");
5043 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
5046 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
5047 Triple.getArch() == llvm::Triple::thumb)) {
5048 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5049 unsigned Version = 0;
5051 Triple.getArchName().substr(Offset).consumeInteger(10, Version);
5052 if (Failure || Version < 7)
5053 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
5063 if (Triple.isSPIR() || Triple.isSPIRV())
5064 CmdArgs.push_back(
"-Wspir-compat");
5067 RewriteKind rewriteKind = RK_None;
5069 bool UnifiedLTO =
false;
5071 UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,
5072 options::OPT_fno_unified_lto, Triple.isPS());
5074 CmdArgs.push_back(
"-funified-lto");
5088 Args.ClaimAllArgs(options::OPT_mrelax_all);
5089 Args.ClaimAllArgs(options::OPT_mno_relax_all);
5090 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
5091 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
5092 switch (
C.getDefaultToolChain().getArch()) {
5093 case llvm::Triple::arm:
5094 case llvm::Triple::armeb:
5095 case llvm::Triple::thumb:
5096 case llvm::Triple::thumbeb:
5097 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
5103 Args.ClaimAllArgs(options::OPT_Wa_COMMA);
5104 Args.ClaimAllArgs(options::OPT_Xassembler);
5105 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);
5109 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
5110 CmdArgs.push_back(
"-analyze");
5112 if (Output.
getType() == types::TY_Dependencies)
5113 CmdArgs.push_back(
"-Eonly");
5115 CmdArgs.push_back(
"-E");
5116 if (Args.hasArg(options::OPT_rewrite_objc) &&
5117 !Args.hasArg(options::OPT_g_Group))
5118 CmdArgs.push_back(
"-P");
5119 else if (JA.
getType() == types::TY_PP_CXXHeaderUnit)
5120 CmdArgs.push_back(
"-fdirectives-only");
5123 CmdArgs.push_back(
"-emit-obj");
5128 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5130 if (JA.
getType() == types::TY_Nothing)
5131 CmdArgs.push_back(
"-fsyntax-only");
5132 else if (JA.
getType() == types::TY_ModuleFile)
5133 CmdArgs.push_back(
"-emit-module-interface");
5134 else if (JA.
getType() == types::TY_HeaderUnit)
5135 CmdArgs.push_back(
"-emit-header-unit");
5136 else if (!Args.hasArg(options::OPT_ignore_pch))
5137 CmdArgs.push_back(
"-emit-pch");
5139 CmdArgs.push_back(
"-verify-pch");
5141 assert(JA.
getType() == types::TY_API_INFO &&
5142 "Extract API actions must generate a API information.");
5143 CmdArgs.push_back(
"-extract-api");
5145 if (Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))
5146 PrettySGFArg->render(Args, CmdArgs);
5148 Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);
5150 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))
5151 ProductNameArg->render(Args, CmdArgs);
5152 if (Arg *ExtractAPIIgnoresFileArg =
5153 Args.getLastArg(options::OPT_extract_api_ignores_EQ))
5154 ExtractAPIIgnoresFileArg->render(Args, CmdArgs);
5155 if (Arg *EmitExtensionSymbolGraphs =
5156 Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {
5157 if (!SymbolGraphDirArg)
5158 D.
Diag(diag::err_drv_missing_symbol_graph_dir);
5160 EmitExtensionSymbolGraphs->render(Args, CmdArgs);
5162 if (SymbolGraphDirArg)
5163 SymbolGraphDirArg->render(Args, CmdArgs);
5166 "Invalid action for clang tool.");
5167 if (JA.
getType() == types::TY_Nothing) {
5168 CmdArgs.push_back(
"-fsyntax-only");
5169 }
else if (JA.
getType() == types::TY_LLVM_IR ||
5170 JA.
getType() == types::TY_LTO_IR) {
5171 CmdArgs.push_back(
"-emit-llvm");
5172 }
else if (JA.
getType() == types::TY_LLVM_BC ||
5173 JA.
getType() == types::TY_LTO_BC) {
5175 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&
5176 Args.hasArg(options::OPT_emit_llvm)) {
5177 CmdArgs.push_back(
"-emit-llvm");
5179 CmdArgs.push_back(
"-emit-llvm-bc");
5181 }
else if (JA.
getType() == types::TY_IFS ||
5182 JA.
getType() == types::TY_IFS_CPP) {
5184 Args.hasArg(options::OPT_interface_stub_version_EQ)
5185 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
5187 CmdArgs.push_back(
"-emit-interface-stubs");
5189 Args.MakeArgString(Twine(
"-interface-stub-version=") + ArgStr.str()));
5190 }
else if (JA.
getType() == types::TY_PP_Asm) {
5191 CmdArgs.push_back(
"-S");
5192 }
else if (JA.
getType() == types::TY_AST) {
5193 if (!Args.hasArg(options::OPT_ignore_pch))
5194 CmdArgs.push_back(
"-emit-pch");
5195 }
else if (JA.
getType() == types::TY_ModuleFile) {
5196 CmdArgs.push_back(
"-module-file-info");
5197 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
5198 CmdArgs.push_back(
"-rewrite-objc");
5199 rewriteKind = RK_NonFragile;
5200 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
5201 CmdArgs.push_back(
"-rewrite-objc");
5202 rewriteKind = RK_Fragile;
5203 }
else if (JA.
getType() == types::TY_CIR) {
5204 CmdArgs.push_back(
"-emit-cir");
5206 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
5213 if (JA.
getType() == types::TY_LLVM_BC)
5214 CmdArgs.push_back(
"-emit-llvm-uselists");
5218 !Args.hasFlag(options::OPT_offload_new_driver,
5219 options::OPT_no_offload_new_driver,
5221 !Triple.isAMDGPU()) {
5222 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5223 << Args.getLastArg(options::OPT_foffload_lto,
5224 options::OPT_foffload_lto_EQ)
5226 << Triple.getTriple();
5227 }
else if (Triple.isNVPTX() && !IsRDCMode &&
5229 D.
Diag(diag::err_drv_unsupported_opt_for_language_mode)
5230 << Args.getLastArg(options::OPT_foffload_lto,
5231 options::OPT_foffload_lto_EQ)
5236 CmdArgs.push_back(Args.MakeArgString(
5237 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
5240 if (!RawTriple.isPS4() ||
5242 CmdArgs.push_back(
"-flto-unit");
5247 Args.AddLastArg(CmdArgs, options::OPT_dumpdir);
5249 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
5251 D.
Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
5252 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
5256 Args.addOptInFlag(CmdArgs, options::OPT_mregnames,
5257 options::OPT_mno_regnames);
5259 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
5260 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
5262 if (Args.getLastArg(options::OPT_save_temps_EQ))
5263 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
5265 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,
5266 options::OPT_fmemory_profile_EQ,
5267 options::OPT_fno_memory_profile);
5269 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile))
5270 MemProfArg->render(Args, CmdArgs);
5272 if (
auto *MemProfUseArg =
5273 Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {
5275 D.
Diag(diag::err_drv_argument_not_allowed_with)
5276 << MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);
5277 if (
auto *PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,
5278 options::OPT_fprofile_generate_EQ))
5279 D.
Diag(diag::err_drv_argument_not_allowed_with)
5280 << MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);
5281 MemProfUseArg->render(Args, CmdArgs);
5286 if (
C.getDriver().embedBitcodeInObject() && !IsUsingLTO &&
5289 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
5291 CmdArgs.push_back(
"-disable-llvm-passes");
5298 static const constexpr unsigned kBitcodeOptionIgnorelist[] = {
5299 options::OPT_mkernel,
5300 options::OPT_fapple_kext,
5301 options::OPT_ffunction_sections,
5302 options::OPT_fno_function_sections,
5303 options::OPT_fdata_sections,
5304 options::OPT_fno_data_sections,
5305 options::OPT_fbasic_block_sections_EQ,
5306 options::OPT_funique_internal_linkage_names,
5307 options::OPT_fno_unique_internal_linkage_names,
5308 options::OPT_funique_section_names,
5309 options::OPT_fno_unique_section_names,
5310 options::OPT_funique_basic_block_section_names,
5311 options::OPT_fno_unique_basic_block_section_names,
5312 options::OPT_mrestrict_it,
5313 options::OPT_mno_restrict_it,
5314 options::OPT_mstackrealign,
5315 options::OPT_mno_stackrealign,
5316 options::OPT_mstack_alignment,
5317 options::OPT_mcmodel_EQ,
5318 options::OPT_mlong_calls,
5319 options::OPT_mno_long_calls,
5320 options::OPT_ggnu_pubnames,
5321 options::OPT_gdwarf_aranges,
5322 options::OPT_fdebug_types_section,
5323 options::OPT_fno_debug_types_section,
5324 options::OPT_fdwarf_directory_asm,
5325 options::OPT_fno_dwarf_directory_asm,
5326 options::OPT_mrelax_all,
5327 options::OPT_mno_relax_all,
5328 options::OPT_ftrap_function_EQ,
5329 options::OPT_ffixed_r9,
5330 options::OPT_mfix_cortex_a53_835769,
5331 options::OPT_mno_fix_cortex_a53_835769,
5332 options::OPT_ffixed_x18,
5333 options::OPT_mglobal_merge,
5334 options::OPT_mno_global_merge,
5335 options::OPT_mred_zone,
5336 options::OPT_mno_red_zone,
5337 options::OPT_Wa_COMMA,
5338 options::OPT_Xassembler,
5342 for (
const auto &A : Args)
5343 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))
5344 D.
Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
5347 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5348 options::OPT_fno_optimize_sibling_calls);
5356 case llvm::Triple::arm:
5357 case llvm::Triple::armeb:
5358 case llvm::Triple::thumbeb:
5359 RenderARMABI(D, Triple, Args, CmdArgs);
5361 case llvm::Triple::aarch64:
5362 case llvm::Triple::aarch64_32:
5363 case llvm::Triple::aarch64_be:
5364 RenderAArch64ABI(Triple, Args, CmdArgs);
5369 if (Output.
getType() == types::TY_Dependencies) {
5372 CmdArgs.push_back(
"-o");
5375 assert(Output.
isNothing() &&
"Input output.");
5378 for (
const auto &II : Inputs) {
5380 if (II.isFilename())
5381 CmdArgs.push_back(II.getFilename());
5383 II.getInputArg().renderAsInput(Args, CmdArgs);
5386 C.addCommand(std::make_unique<Command>(
5392 if (
C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
5393 CmdArgs.push_back(
"-fembed-bitcode=marker");
5398 if (!
C.isForDiagnostics())
5399 CmdArgs.push_back(
"-disable-free");
5400 CmdArgs.push_back(
"-clear-ast-before-backend");
5403 const bool IsAssertBuild =
false;
5405 const bool IsAssertBuild =
true;
5410 if (Args.hasFlag(options::OPT_fno_verify_intermediate_code,
5411 options::OPT_fverify_intermediate_code, !IsAssertBuild)) {
5412 CmdArgs.push_back(
"-disable-llvm-verifier");
5416 if (Args.hasFlag(options::OPT_fdiscard_value_names,
5417 options::OPT_fno_discard_value_names, !IsAssertBuild)) {
5418 if (Args.hasArg(options::OPT_fdiscard_value_names) &&
5420 return types::isLLVMIR(II.getType());
5422 D.
Diag(diag::warn_ignoring_fdiscard_for_bitcode);
5424 CmdArgs.push_back(
"-discard-value-names");
5429 CmdArgs.push_back(
"-main-file-name");
5434 if (Args.hasArg(options::OPT_static))
5435 CmdArgs.push_back(
"-static-define");
5437 Args.AddLastArg(CmdArgs, options::OPT_static_libclosure);
5439 if (Args.hasArg(options::OPT_municode))
5440 CmdArgs.push_back(
"-DUNICODE");
5447 CmdArgs.push_back(
"-setup-static-analyzer");
5452 bool FoundAnalyzerConfig =
false;
5453 for (
auto *Arg : Args.filtered(options::OPT_Xclang))
5454 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5455 FoundAnalyzerConfig =
true;
5458 if (!FoundAnalyzerConfig)
5459 for (
auto *Arg : Args.filtered(options::OPT_Xanalyzer))
5460 if (StringRef(Arg->getValue()) ==
"-analyzer-config") {
5461 FoundAnalyzerConfig =
true;
5464 if (FoundAnalyzerConfig)
5465 CmdArgs.push_back(
"-analyzer-config-compatibility-mode=true");
5470 assert(FunctionAlignment <= 31 &&
"function alignment will be truncated!");
5471 if (FunctionAlignment) {
5472 CmdArgs.push_back(
"-function-alignment");
5473 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
5478 if (
const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) {
5480 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
5482 << A->getAsString(Args) << A->getValue();
5484 TC.
getDriver().
Diag(diag::err_drv_alignment_not_power_of_two)
5485 << A->getAsString(Args) << A->getValue();
5488 CmdArgs.push_back(Args.MakeArgString(
"-falign-loops=" +
5489 Twine(std::min(
Value, 65536u))));
5492 if (Triple.isOSzOS()) {
5501 auto findMacroDefinition = [&](
const std::string &
Macro) {
5502 auto MacroDefs = Args.getAllArgValues(options::OPT_D);
5503 return llvm::any_of(MacroDefs, [&](
const std::string &M) {
5504 return M ==
Macro || M.find(
Macro +
'=') != std::string::npos;
5509 if (!findMacroDefinition(
"_UNIX03_WITHDRAWN"))
5510 CmdArgs.push_back(
"-D_UNIX03_WITHDRAWN");
5512 if (!findMacroDefinition(
"_OPEN_DEFAULT"))
5513 CmdArgs.push_back(
"-D_OPEN_DEFAULT");
5516 if (!findMacroDefinition(
"_XOPEN_SOURCE"))
5517 CmdArgs.push_back(
"-D_XOPEN_SOURCE=600");
5521 llvm::Reloc::Model RelocationModel;
5524 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(TC, Args);
5525 Arg *LastPICDataRelArg =
5526 Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,
5527 options::OPT_mpic_data_is_text_relative);
5528 bool NoPICDataIsTextRelative =
false;
5529 if (LastPICDataRelArg) {
5530 if (LastPICDataRelArg->getOption().matches(
5531 options::OPT_mno_pic_data_is_text_relative)) {
5532 NoPICDataIsTextRelative =
true;
5534 D.
Diag(diag::err_drv_argument_only_allowed_with)
5535 <<
"-mno-pic-data-is-text-relative"
5538 if (!Triple.isSystemZ())
5539 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5540 << (NoPICDataIsTextRelative ?
"-mno-pic-data-is-text-relative"
5541 :
"-mpic-data-is-text-relative")
5545 bool IsROPI = RelocationModel == llvm::Reloc::ROPI ||
5546 RelocationModel == llvm::Reloc::ROPI_RWPI;
5547 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI ||
5548 RelocationModel == llvm::Reloc::ROPI_RWPI;
5550 if (Args.hasArg(options::OPT_mcmse) &&
5551 !Args.hasArg(options::OPT_fallow_unsupported)) {
5553 D.
Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;
5555 D.
Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;
5559 !Args.hasArg(options::OPT_fallow_unsupported))
5560 D.
Diag(diag::err_drv_ropi_incompatible_with_cxx);
5564 CmdArgs.push_back(
"-mrelocation-model");
5565 CmdArgs.push_back(RMName);
5568 CmdArgs.push_back(
"-pic-level");
5569 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
5571 CmdArgs.push_back(
"-pic-is-pie");
5572 if (NoPICDataIsTextRelative)
5573 CmdArgs.push_back(
"-mcmodel=medium");
5576 if (RelocationModel == llvm::Reloc::ROPI ||
5577 RelocationModel == llvm::Reloc::ROPI_RWPI)
5578 CmdArgs.push_back(
"-fropi");
5579 if (RelocationModel == llvm::Reloc::RWPI ||
5580 RelocationModel == llvm::Reloc::ROPI_RWPI)
5581 CmdArgs.push_back(
"-frwpi");
5583 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
5584 CmdArgs.push_back(
"-meabi");
5585 CmdArgs.push_back(A->getValue());
5599 if (Triple.isOSBinFormatELF()) {
5600 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition,
5601 options::OPT_fno_semantic_interposition);
5602 if (RelocationModel != llvm::Reloc::Static && !IsPIE) {
5604 bool SupportsLocalAlias =
5605 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();
5607 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5608 else if (A->getOption().matches(options::OPT_fsemantic_interposition))
5609 A->render(Args, CmdArgs);
5610 else if (!SupportsLocalAlias)
5611 CmdArgs.push_back(
"-fhalf-no-semantic-interposition");
5617 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
5619 D.
Diag(diag::err_drv_invalid_thread_model_for_target)
5620 << A->getValue() << A->getAsString(Args);
5621 Model = A->getValue();
5624 if (Model !=
"posix") {
5625 CmdArgs.push_back(
"-mthread-model");
5626 CmdArgs.push_back(Args.MakeArgString(Model));
5630 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
5631 StringRef Name = A->getValue();
5632 if (Name ==
"SVML") {
5633 if (Triple.getArch() != llvm::Triple::x86 &&
5634 Triple.getArch() != llvm::Triple::x86_64)
5635 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5636 << Name << Triple.getArchName();
5637 }
else if (Name ==
"AMDLIBM") {
5638 if (Triple.getArch() != llvm::Triple::x86 &&
5639 Triple.getArch() != llvm::Triple::x86_64)
5640 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5641 << Name << Triple.getArchName();
5642 }
else if (Name ==
"libmvec") {
5643 if (Triple.getArch() != llvm::Triple::x86 &&
5644 Triple.getArch() != llvm::Triple::x86_64 &&
5645 Triple.getArch() != llvm::Triple::aarch64 &&
5646 Triple.getArch() != llvm::Triple::aarch64_be)
5647 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5648 << Name << Triple.getArchName();
5649 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
5650 if (Triple.getArch() != llvm::Triple::aarch64 &&
5651 Triple.getArch() != llvm::Triple::aarch64_be &&
5652 Triple.getArch() != llvm::Triple::riscv64)
5653 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5654 << Name << Triple.getArchName();
5656 A->render(Args, CmdArgs);
5659 if (Args.hasFlag(options::OPT_fmerge_all_constants,
5660 options::OPT_fno_merge_all_constants,
false))
5661 CmdArgs.push_back(
"-fmerge-all-constants");
5663 Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,
5664 options::OPT_fno_delete_null_pointer_checks);
5668 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) {
5669 if (!Triple.isOSAIX() || Triple.isPPC32())
5670 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5671 << A->getSpelling() << RawTriple.str();
5672 CmdArgs.push_back(
"-mabi=quadword-atomics");
5675 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) {
5678 if (Triple.isOSAIX())
5679 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5680 << A->getSpelling() << RawTriple.str();
5683 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
5684 StringRef
V = A->getValue(), V1 =
V;
5686 if (V1.consumeInteger(10, Size) || !V1.empty())
5687 D.
Diag(diag::err_drv_invalid_argument_to_option)
5688 <<
V << A->getOption().getName();
5690 CmdArgs.push_back(Args.MakeArgString(
"-fwarn-stack-size=" +
V));
5693 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,
5694 options::OPT_fno_jump_tables);
5695 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,
5696 options::OPT_fno_profile_sample_accurate);
5697 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,
5698 options::OPT_fno_preserve_as_comments);
5700 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
5701 CmdArgs.push_back(
"-mregparm");
5702 CmdArgs.push_back(A->getValue());
5705 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return,
5706 options::OPT_msvr4_struct_return)) {
5708 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5709 << A->getSpelling() << RawTriple.str();
5710 }
else if (A->getOption().matches(options::OPT_maix_struct_return)) {
5711 CmdArgs.push_back(
"-maix-struct-return");
5713 assert(A->getOption().matches(options::OPT_msvr4_struct_return));
5714 CmdArgs.push_back(
"-msvr4-struct-return");
5718 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
5719 options::OPT_freg_struct_return)) {
5720 if (TC.
getArch() != llvm::Triple::x86) {
5721 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5722 << A->getSpelling() << RawTriple.str();
5723 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
5724 CmdArgs.push_back(
"-fpcc-struct-return");
5726 assert(A->getOption().matches(options::OPT_freg_struct_return));
5727 CmdArgs.push_back(
"-freg-struct-return");
5731 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false)) {
5732 if (Triple.getArch() == llvm::Triple::m68k)
5733 CmdArgs.push_back(
"-fdefault-calling-conv=rtdcall");
5735 CmdArgs.push_back(
"-fdefault-calling-conv=stdcall");
5738 if (Args.hasArg(options::OPT_fenable_matrix)) {
5740 CmdArgs.push_back(
"-fenable-matrix");
5741 CmdArgs.push_back(
"-mllvm");
5742 CmdArgs.push_back(
"-enable-matrix");
5747 const char *FPKeepKindStr =
nullptr;
5748 switch (FPKeepKind) {
5750 FPKeepKindStr =
"-mframe-pointer=none";
5753 FPKeepKindStr =
"-mframe-pointer=reserved";
5756 FPKeepKindStr =
"-mframe-pointer=non-leaf";
5759 FPKeepKindStr =
"-mframe-pointer=all";
5762 assert(FPKeepKindStr &&
"unknown FramePointerKind");
5763 CmdArgs.push_back(FPKeepKindStr);
5765 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
5766 options::OPT_fno_zero_initialized_in_bss);
5770 D.
Diag(diag::warn_drv_deprecated_arg_ofast);
5773 OptSpecifier StrictAliasingAliasOption =
5774 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
5777 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
5778 options::OPT_fno_strict_aliasing,
5779 !IsWindowsMSVC && !IsUEFI))
5780 CmdArgs.push_back(
"-relaxed-aliasing");
5781 if (Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,
5783 CmdArgs.push_back(
"-no-pointer-tbaa");
5784 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
5785 options::OPT_fno_struct_path_tbaa,
true))
5786 CmdArgs.push_back(
"-no-struct-path-tbaa");
5787 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,
5788 options::OPT_fno_strict_enums);
5789 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,
5790 options::OPT_fno_strict_return);
5791 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,
5792 options::OPT_fno_allow_editor_placeholders);
5793 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,
5794 options::OPT_fno_strict_vtable_pointers);
5795 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,
5796 options::OPT_fno_force_emit_vtables);
5797 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,
5798 options::OPT_fno_optimize_sibling_calls);
5799 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
5800 options::OPT_fno_escaping_block_tail_calls);
5802 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
5803 options::OPT_fno_fine_grained_bitfield_accesses);
5805 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
5806 options::OPT_fno_experimental_relative_cxx_abi_vtables);
5808 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
5809 options::OPT_fno_experimental_omit_vtable_rtti);
5811 Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,
5812 options::OPT_fno_disable_block_signature_string);
5815 Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
5816 options::OPT_fno_split_stack);
5819 if (Args.hasFlag(options::OPT_fprotect_parens,
5820 options::OPT_fno_protect_parens,
false))
5821 CmdArgs.push_back(
"-fprotect-parens");
5825 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_remote_memory,
5826 options::OPT_fno_atomic_remote_memory);
5827 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_fine_grained_memory,
5828 options::OPT_fno_atomic_fine_grained_memory);
5829 Args.addOptInFlag(CmdArgs, options::OPT_fatomic_ignore_denormal_mode,
5830 options::OPT_fno_atomic_ignore_denormal_mode);
5832 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) {
5834 if (
Arch == llvm::Triple::x86 ||
Arch == llvm::Triple::x86_64) {
5835 StringRef
V = A->getValue();
5837 CmdArgs.push_back(
"-fextend-arguments=64");
5839 D.
Diag(diag::err_drv_invalid_argument_to_option)
5840 << A->getValue() << A->getOption().getName();
5842 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5843 << A->getOption().getName() << TripleStr;
5846 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) {
5847 if (TC.
getArch() == llvm::Triple::avr)
5848 A->render(Args, CmdArgs);
5850 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5851 << A->getAsString(Args) << TripleStr;
5854 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
5856 A->render(Args, CmdArgs);
5858 (A->getOption().getID() != options::OPT_mlong_double_80))
5859 A->render(Args, CmdArgs);
5861 D.
Diag(diag::err_drv_unsupported_opt_for_target)
5862 << A->getAsString(Args) << TripleStr;
5868 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
5869 IsIntegratedAssemblerDefault))
5870 CmdArgs.push_back(
"-fno-verbose-asm");
5874 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) {
5875 StringRef
V = A->getValue();
5878 A->render(Args, CmdArgs);
5879 else if (!
V.consumeInteger(10,
Num) &&
Num > 0 &&
5880 (
V.empty() || (
V.consume_front(
".") &&
5881 !
V.consumeInteger(10,
Num) &&
V.empty())))
5882 A->render(Args, CmdArgs);
5884 D.
Diag(diag::err_drv_invalid_argument_to_option)
5885 << A->getValue() << A->getOption().getName();
5891 CmdArgs.push_back(
"-no-integrated-as");
5893 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
5894 CmdArgs.push_back(
"-mdebug-pass");
5895 CmdArgs.push_back(
"Structure");
5897 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
5898 CmdArgs.push_back(
"-mdebug-pass");
5899 CmdArgs.push_back(
"Arguments");
5905 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
5906 CmdArgs.push_back(
"-mconstructor-aliases");
5910 if (KernelOrKext && RawTriple.isOSDarwin())
5911 CmdArgs.push_back(
"-fforbid-guard-variables");
5913 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
5914 Triple.isWindowsGNUEnvironment())) {
5915 CmdArgs.push_back(
"-mms-bitfields");
5918 if (Triple.isOSCygMing()) {
5919 Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,
5920 options::OPT_fno_auto_import);
5923 if (Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,
5924 Triple.isX86() && IsWindowsMSVC))
5925 CmdArgs.push_back(
"-fms-volatile");
5930 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data,
5931 options::OPT_fno_direct_access_external_data)) {
5932 if (A->getOption().matches(options::OPT_fdirect_access_external_data) !=
5934 A->render(Args, CmdArgs);
5935 }
else if (PICLevel == 0 && Triple.isLoongArch()) {
5938 CmdArgs.push_back(
"-fno-direct-access-external-data");
5941 if (Triple.isOSBinFormatELF() && (Triple.isAArch64() || Triple.isX86()))
5942 Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);
5948 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
5951 CmdArgs.push_back(
"-ffreestanding");
5953 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions);
5956 Args.AddLastArg(CmdArgs,
5957 options::OPT_fallow_runtime_check_skip_hot_cutoff_EQ);
5962 bool IsAsyncUnwindTablesDefault =
5964 bool IsSyncUnwindTablesDefault =
5967 bool AsyncUnwindTables = Args.hasFlag(
5968 options::OPT_fasynchronous_unwind_tables,
5969 options::OPT_fno_asynchronous_unwind_tables,
5970 (IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&
5973 Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
5974 IsSyncUnwindTablesDefault && !Freestanding);
5975 if (AsyncUnwindTables)
5976 CmdArgs.push_back(
"-funwind-tables=2");
5977 else if (UnwindTables)
5978 CmdArgs.push_back(
"-funwind-tables=1");
5982 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
5983 (IsCudaDevice || IsHIPDevice || IsSYCLDevice)) {
5984 const ArgList &HostArgs =
5986 std::string HostCPU =
5988 if (!HostCPU.empty()) {
5989 CmdArgs.push_back(
"-aux-target-cpu");
5990 CmdArgs.push_back(Args.MakeArgString(HostCPU));
5998 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
6000 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
6001 StringRef
Value = A->getValue();
6002 unsigned TLSSize = 0;
6003 Value.getAsInteger(10, TLSSize);
6004 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
6005 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6006 << A->getOption().getName() << TripleStr;
6007 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
6008 D.
Diag(diag::err_drv_invalid_int_value)
6009 << A->getOption().getName() <<
Value;
6010 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
6014 CmdArgs.push_back(
"-enable-tlsdesc");
6017 std::string CPU =
getCPUName(D, Args, Triple,
false);
6019 CmdArgs.push_back(
"-target-cpu");
6020 CmdArgs.push_back(Args.MakeArgString(CPU));
6023 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
6028 AddClangCLArgs(Args, InputType, CmdArgs);
6030 llvm::codegenoptions::DebugInfoKind DebugInfoKind =
6031 llvm::codegenoptions::NoDebugInfo;
6034 DebugInfoKind, DwarfFission);
6045 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
6046 CmdArgs.push_back(
"-split-dwarf-file");
6047 CmdArgs.push_back(SplitDWARFOut);
6049 CmdArgs.push_back(
"-split-dwarf-output");
6050 CmdArgs.push_back(SplitDWARFOut);
6055 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6056 CmdArgs.push_back(
"-target-linker-version");
6057 CmdArgs.push_back(A->getValue());
6062 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
6064 if (
types::isCXX(InputType) && RawTriple.isOSDarwin() &&
6065 TC.
getArch() == llvm::Triple::x86) {
6066 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
6067 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
6068 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
6069 << Unsupported->getOption().getName();
6072 if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
6073 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6074 << Unsupported->getOption().getName()
6075 <<
"please use -maltivec and include altivec.h explicitly";
6076 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
6077 D.
Diag(diag::err_drv_clang_unsupported_opt_faltivec)
6078 << Unsupported->getOption().getName() <<
"please use -mno-altivec";
6081 Args.AddAllArgs(CmdArgs, options::OPT_v);
6083 if (Args.getLastArg(options::OPT_H)) {
6084 CmdArgs.push_back(
"-H");
6085 CmdArgs.push_back(
"-sys-header-deps");
6087 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes);
6090 CmdArgs.push_back(
"-header-include-file");
6094 CmdArgs.push_back(
"-sys-header-deps");
6095 CmdArgs.push_back(Args.MakeArgString(
6096 "-header-include-format=" +
6099 Args.MakeArgString(
"-header-include-filtering=" +
6103 Args.AddLastArg(CmdArgs, options::OPT_P);
6104 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
6107 CmdArgs.push_back(
"-diagnostic-log-file");
6116 CmdArgs.push_back(
"-disable-pragma-debug-crash");
6120 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) {
6121 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);
6122 CmdArgs.push_back(
"-mllvm");
6123 CmdArgs.push_back(Args.MakeArgString(
"-crash-diagnostics-dir=" + Dir));
6128 if (Args.hasFlag(options::OPT_ffunction_sections,
6129 options::OPT_fno_function_sections, UseSeparateSections)) {
6130 CmdArgs.push_back(
"-ffunction-sections");
6133 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
6134 options::OPT_fno_basic_block_address_map)) {
6135 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {
6136 if (A->getOption().matches(options::OPT_fbasic_block_address_map))
6137 A->render(Args, CmdArgs);
6139 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6140 << A->getAsString(Args) << TripleStr;
6144 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
6145 StringRef Val = A->getValue();
6146 if (Val ==
"labels") {
6147 D.
Diag(diag::warn_drv_deprecated_arg)
6148 << A->getAsString(Args) <<
true
6149 <<
"-fbasic-block-address-map";
6150 CmdArgs.push_back(
"-fbasic-block-address-map");
6151 }
else if (Triple.isX86() && Triple.isOSBinFormatELF()) {
6152 if (Val !=
"all" && Val !=
"none" && !Val.starts_with(
"list="))
6153 D.
Diag(diag::err_drv_invalid_value)
6154 << A->getAsString(Args) << A->getValue();
6156 A->render(Args, CmdArgs);
6157 }
else if (Triple.isAArch64() && Triple.isOSBinFormatELF()) {
6160 if (Val !=
"labels" && Val !=
"none" && !Val.starts_with(
"list="))
6161 D.
Diag(diag::err_drv_invalid_value)
6162 << A->getAsString(Args) << A->getValue();
6164 A->render(Args, CmdArgs);
6165 }
else if (Triple.isNVPTX()) {
6168 }
else if (Val !=
"none") {
6171 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6172 << A->getAsString(Args) << TripleStr;
6176 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF();
6177 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
6178 UseSeparateSections || HasDefaultDataSections)) {
6179 CmdArgs.push_back(
"-fdata-sections");
6182 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,
6183 options::OPT_fno_unique_section_names);
6184 Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,
6185 options::OPT_fno_separate_named_sections);
6186 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,
6187 options::OPT_fno_unique_internal_linkage_names);
6188 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,
6189 options::OPT_fno_unique_basic_block_section_names);
6191 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
6192 options::OPT_fno_split_machine_functions)) {
6193 if (!A->getOption().matches(options::OPT_fno_split_machine_functions)) {
6195 if ((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())
6196 A->render(Args, CmdArgs);
6198 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6199 << A->getAsString(Args) << TripleStr;
6203 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
6204 options::OPT_finstrument_functions_after_inlining,
6205 options::OPT_finstrument_function_entry_bare);
6206 Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,
6207 options::OPT_fno_convergent_functions);
6210 if (!Triple.isNVPTX())
6213 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
6216 Args.hasFlag(options::OPT_fsample_profile_use_profi,
6217 options::OPT_fno_sample_profile_use_profi,
true)) {
6218 CmdArgs.push_back(
"-mllvm");
6219 CmdArgs.push_back(
"-sample-profile-use-profi");
6223 if (RawTriple.isPS() &&
6224 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6230 if (Args.hasArg(options::OPT_nostdinc)) {
6231 CmdArgs.push_back(
"-nostdsysteminc");
6232 CmdArgs.push_back(
"-nobuiltininc");
6234 if (Args.hasArg(options::OPT_nostdlibinc))
6235 CmdArgs.push_back(
"-nostdsysteminc");
6236 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
6237 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
6241 CmdArgs.push_back(
"-resource-dir");
6244 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
6251 AddPreprocessingOptions(
C, JA, D, Args, CmdArgs, Output, Inputs);
6257 Args.ClaimAllArgs(options::OPT_D);
6261 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
6262 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
6267 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
6268 D.
Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
6274 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
6277 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
6279 if (A->getOption().getID() == options::OPT__SLASH_wd) {
6280 unsigned WarningNumber;
6281 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
6282 D.
Diag(diag::err_drv_invalid_int_value)
6283 << A->getAsString(Args) << A->getValue();
6288 CmdArgs.push_back(Args.MakeArgString(
6293 A->render(Args, CmdArgs);
6296 Args.AddAllArgs(CmdArgs, options::OPT_Wsystem_headers_in_module_EQ);
6298 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
6299 CmdArgs.push_back(
"-pedantic");
6300 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
6301 Args.AddLastArg(CmdArgs, options::OPT_w);
6303 Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
6304 options::OPT_fno_fixed_point);
6306 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
6307 A->render(Args, CmdArgs);
6309 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
6310 options::OPT_fno_experimental_relative_cxx_abi_vtables);
6312 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
6313 options::OPT_fno_experimental_omit_vtable_rtti);
6315 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
6316 A->render(Args, CmdArgs);
6323 bool ImplyVCPPCVer =
false;
6324 bool ImplyVCPPCXXVer =
false;
6325 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
6327 if (Std->getOption().matches(options::OPT_ansi))
6329 CmdArgs.push_back(
"-std=c++98");
6331 CmdArgs.push_back(
"-std=c89");
6333 Std->render(Args, CmdArgs);
6336 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
6337 options::OPT_ftrigraphs,
6338 options::OPT_fno_trigraphs))
6340 A->render(Args, CmdArgs);
6349 if (!Args.hasArg(options::OPT__SLASH_std)) {
6350 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
6353 ImplyVCPPCVer =
true;
6355 else if (IsWindowsMSVC)
6356 ImplyVCPPCXXVer =
true;
6358 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
6359 options::OPT_fno_trigraphs);
6375 Args.getLastArg(options::OPT_Wwrite_strings,
6376 options::OPT_Wno_write_strings, options::OPT_w);
6378 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
6379 CmdArgs.push_back(
"-fconst-strings");
6386 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
6388 CmdArgs.push_back(
"-fdeprecated-macro");
6392 if (Arg *
Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
6393 if (
Asm->getOption().matches(options::OPT_fasm))
6394 CmdArgs.push_back(
"-fgnu-keywords");
6396 CmdArgs.push_back(
"-fno-gnu-keywords");
6400 CmdArgs.push_back(
"-fno-autolink");
6402 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_depth_EQ);
6403 Args.AddLastArg(CmdArgs, options::OPT_foperator_arrow_depth_EQ);
6404 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_depth_EQ);
6405 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_steps_EQ);
6407 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library);
6409 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
6410 CmdArgs.push_back(
"-fexperimental-new-constant-interpreter");
6412 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
6413 CmdArgs.push_back(
"-fbracket-depth");
6414 CmdArgs.push_back(A->getValue());
6417 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
6418 options::OPT_Wlarge_by_value_copy_def)) {
6419 if (A->getNumValues()) {
6420 StringRef
bytes = A->getValue();
6421 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" +
bytes));
6423 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
6426 if (Args.hasArg(options::OPT_relocatable_pch))
6427 CmdArgs.push_back(
"-relocatable-pch");
6429 if (
const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
6430 static const char *kCFABIs[] = {
6431 "standalone",
"objc",
"swift",
"swift-5.0",
"swift-4.2",
"swift-4.1",
6434 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue())))
6435 D.
Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
6437 A->render(Args, CmdArgs);
6440 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
6441 CmdArgs.push_back(
"-fconstant-string-class");
6442 CmdArgs.push_back(A->getValue());
6445 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
6446 CmdArgs.push_back(
"-ftabstop");
6447 CmdArgs.push_back(A->getValue());
6450 Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,
6451 options::OPT_fno_stack_size_section);
6453 if (Args.hasArg(options::OPT_fstack_usage)) {
6454 CmdArgs.push_back(
"-stack-usage-file");
6456 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6458 llvm::sys::path::replace_extension(OutputFilename,
"su");
6459 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6465 CmdArgs.push_back(
"-ferror-limit");
6466 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
6467 CmdArgs.push_back(A->getValue());
6469 CmdArgs.push_back(
"19");
6471 Args.AddLastArg(CmdArgs, options::OPT_fconstexpr_backtrace_limit_EQ);
6472 Args.AddLastArg(CmdArgs, options::OPT_fmacro_backtrace_limit_EQ);
6473 Args.AddLastArg(CmdArgs, options::OPT_ftemplate_backtrace_limit_EQ);
6474 Args.AddLastArg(CmdArgs, options::OPT_fspell_checking_limit_EQ);
6475 Args.AddLastArg(CmdArgs, options::OPT_fcaret_diagnostics_max_lines_EQ);
6478 unsigned MessageLength = 0;
6479 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
6480 StringRef
V(A->getValue());
6481 if (
V.getAsInteger(0, MessageLength))
6482 D.
Diag(diag::err_drv_invalid_argument_to_option)
6483 <<
V << A->getOption().getName();
6487 MessageLength = llvm::sys::Process::StandardErrColumns();
6489 if (MessageLength != 0)
6491 Args.MakeArgString(
"-fmessage-length=" + Twine(MessageLength)));
6493 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ))
6495 Args.MakeArgString(
"-frandomize-layout-seed=" + Twine(A->getValue(0))));
6497 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ))
6498 CmdArgs.push_back(Args.MakeArgString(
"-frandomize-layout-seed-file=" +
6499 Twine(A->getValue(0))));
6502 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
6503 options::OPT_fvisibility_ms_compat)) {
6504 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
6505 A->render(Args, CmdArgs);
6507 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
6508 CmdArgs.push_back(
"-fvisibility=hidden");
6509 CmdArgs.push_back(
"-ftype-visibility=default");
6511 }
else if (IsOpenMPDevice) {
6515 CmdArgs.push_back(
"-fvisibility=protected");
6519 if (!RawTriple.isPS()) {
6521 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
6522 options::OPT_fno_visibility_from_dllstorageclass)) {
6523 if (A->getOption().matches(
6524 options::OPT_fvisibility_from_dllstorageclass)) {
6525 CmdArgs.push_back(
"-fvisibility-from-dllstorageclass");
6526 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ);
6527 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ);
6528 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ);
6529 Args.AddLastArg(CmdArgs,
6530 options::OPT_fvisibility_externs_nodllstorageclass_EQ);
6535 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
6536 options::OPT_fno_visibility_inlines_hidden,
false))
6537 CmdArgs.push_back(
"-fvisibility-inlines-hidden");
6539 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
6540 options::OPT_fno_visibility_inlines_hidden_static_local_var);
6545 Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {
6546 D.
Diag(diag::warn_drv_deprecated_arg)
6547 << A->getAsString(Args) <<
true
6548 <<
"-fvisibility-global-new-delete=force-hidden";
6552 Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,
6553 options::OPT_fvisibility_global_new_delete_hidden)) {
6554 if (A->getOption().matches(options::OPT_fvisibility_global_new_delete_EQ)) {
6555 A->render(Args, CmdArgs);
6557 assert(A->getOption().matches(
6558 options::OPT_fvisibility_global_new_delete_hidden));
6559 CmdArgs.push_back(
"-fvisibility-global-new-delete=force-hidden");
6563 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
6565 if (Args.hasFlag(options::OPT_fnew_infallible,
6566 options::OPT_fno_new_infallible,
false))
6567 CmdArgs.push_back(
"-fnew-infallible");
6569 if (Args.hasFlag(options::OPT_fno_operator_names,
6570 options::OPT_foperator_names,
false))
6571 CmdArgs.push_back(
"-fno-operator-names");
6574 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
6575 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
6576 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
6577 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ);
6578 Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,
6579 options::OPT_fno_raw_string_literals);
6581 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
6582 Triple.hasDefaultEmulatedTLS()))
6583 CmdArgs.push_back(
"-femulated-tls");
6585 Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,
6586 options::OPT_fno_check_new);
6588 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) {
6592 if (!Triple.isX86() && !Triple.isAArch64())
6593 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6594 << A->getAsString(Args) << TripleStr;
6599 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
6601 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
6602 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
6606 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6607 options::OPT_fno_openmp,
false) &&
6608 !Args.hasFlag(options::OPT_foffload_via_llvm,
6609 options::OPT_fno_offload_via_llvm,
false) &&
6616 CmdArgs.push_back(
"-fopenmp");
6621 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
6622 options::OPT_fnoopenmp_use_tls,
true))
6623 CmdArgs.push_back(
"-fnoopenmp-use-tls");
6624 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6625 options::OPT_fno_openmp_simd);
6626 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
6627 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6628 if (!Args.hasFlag(options::OPT_fopenmp_extensions,
6629 options::OPT_fno_openmp_extensions,
true))
6630 CmdArgs.push_back(
"-fno-openmp-extensions");
6631 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
6632 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
6633 Args.AddAllArgs(CmdArgs,
6634 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
6635 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
6636 options::OPT_fno_openmp_optimistic_collapse,
6638 CmdArgs.push_back(
"-fopenmp-optimistic-collapse");
6642 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
6643 options::OPT_fno_openmp_cuda_mode,
false))
6644 CmdArgs.push_back(
"-fopenmp-cuda-mode");
6647 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
6648 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
6649 options::OPT_fno_openmp_target_debug,
false))
6650 CmdArgs.push_back(
"-fopenmp-target-debug");
6654 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
6655 options::OPT_fno_openmp_assume_teams_oversubscription,
6657 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
6658 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
6659 options::OPT_fno_openmp_assume_threads_oversubscription,
6661 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
6662 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
6663 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
6664 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
6665 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
6666 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory))
6667 CmdArgs.push_back(
"-fopenmp-offload-mandatory");
6668 if (Args.hasArg(options::OPT_fopenmp_force_usm))
6669 CmdArgs.push_back(
"-fopenmp-force-usm");
6681 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
6682 options::OPT_fno_openmp_simd);
6683 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
6684 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,
6685 options::OPT_fno_openmp_extensions);
6690 if (Args.hasFlag(options::OPT_foffload_via_llvm,
6691 options::OPT_fno_offload_via_llvm,
false)) {
6692 CmdArgs.append({
"--offload-new-driver",
"-foffload-via-llvm"});
6693 }
else if (Args.hasFlag(options::OPT_offload_new_driver,
6694 options::OPT_no_offload_new_driver,
6696 CmdArgs.push_back(
"--offload-new-driver");
6700 XRay.
addArgs(TC, Args, CmdArgs, InputType);
6702 for (
const auto &Filename :
6703 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {
6704 if (D.
getVFS().exists(Filename))
6705 CmdArgs.push_back(Args.MakeArgString(
"-fprofile-list=" + Filename));
6707 D.
Diag(clang::diag::err_drv_no_such_file) << Filename;
6710 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
6711 StringRef S0 = A->getValue(), S = S0;
6712 unsigned Size, Offset = 0;
6713 if (!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&
6715 !(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||
6716 Triple.getArch() == llvm::Triple::ppc64 ||
6717 Triple.getArch() == llvm::Triple::ppc64le)))
6718 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6719 << A->getAsString(Args) << TripleStr;
6720 else if (S.consumeInteger(10, Size) ||
6722 (!S.consume_front(
",") || S.consumeInteger(10, Offset))) ||
6723 (!S.empty() && (!S.consume_front(
",") || S.empty())))
6724 D.
Diag(diag::err_drv_invalid_argument_to_option)
6725 << S0 << A->getOption().getName();
6726 else if (Size < Offset)
6727 D.
Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
6729 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
6730 CmdArgs.push_back(Args.MakeArgString(
6731 "-fpatchable-function-entry-offset=" + Twine(Offset)));
6734 Args.MakeArgString(
"-fpatchable-function-entry-section=" + S));
6738 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
6740 if (Args.hasArg(options::OPT_fms_secure_hotpatch_functions_file))
6741 Args.AddLastArg(CmdArgs, options::OPT_fms_secure_hotpatch_functions_file);
6743 for (
const auto &A :
6744 Args.getAllArgValues(options::OPT_fms_secure_hotpatch_functions_list))
6746 Args.MakeArgString(
"-fms-secure-hotpatch-functions-list=" + Twine(A)));
6749 Args.AddLastArg(CmdArgs, options::OPT_pg);
6752 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
6753 if (
Arch == llvm::Triple::systemz || TC.
getTriple().isX86())
6754 A->render(Args, CmdArgs);
6756 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6757 << A->getAsString(Args) << TripleStr;
6759 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
6760 if (
Arch == llvm::Triple::systemz)
6761 A->render(Args, CmdArgs);
6763 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6764 << A->getAsString(Args) << TripleStr;
6766 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
6767 if (
Arch == llvm::Triple::systemz)
6768 A->render(Args, CmdArgs);
6770 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6771 << A->getAsString(Args) << TripleStr;
6775 if (Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {
6777 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6778 << A->getAsString(Args) << TripleStr;
6781 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {
6783 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6784 << A->getAsString(Args) << TripleStr;
6787 if (Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {
6788 if (A->getOption().matches(options::OPT_p)) {
6790 if (TC.
getTriple().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))
6791 CmdArgs.push_back(
"-pg");
6797 for (
const Arg *A : Args.filtered(options::OPT_b, options::OPT_K,
6798 options::OPT_mxcoff_build_id_EQ)) {
6799 D.
Diag(diag::err_drv_unsupported_opt_for_target)
6800 << A->getSpelling() << TripleStr;
6804 if (Args.getLastArg(options::OPT_fapple_kext) ||
6805 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
6806 CmdArgs.push_back(
"-fapple-kext");
6808 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
6809 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
6810 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
6811 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
6812 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
6813 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
6814 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ);
6815 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_json);
6816 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
6817 Args.AddLastArg(CmdArgs, options::OPT_malign_double);
6818 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
6820 if (
const char *Name =
C.getTimeTraceFile(&JA)) {
6821 CmdArgs.push_back(Args.MakeArgString(
"-ftime-trace=" + Twine(Name)));
6822 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
6823 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose);
6826 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
6827 CmdArgs.push_back(
"-ftrapv-handler");
6828 CmdArgs.push_back(A->getValue());
6831 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
6837 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
6838 options::OPT_fno_finite_loops);
6840 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
6841 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
6842 options::OPT_fno_unroll_loops);
6843 Args.AddLastArg(CmdArgs, options::OPT_floop_interchange,
6844 options::OPT_fno_loop_interchange);
6845 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_loop_fusion,
6846 options::OPT_fno_experimental_loop_fusion);
6848 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
6850 Args.AddLastArg(CmdArgs, options::OPT_pthread);
6852 Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,
6853 options::OPT_mno_speculative_load_hardening);
6859 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ);
6861 Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,
6862 options::OPT_mno_stackrealign);
6864 if (
const Arg *A = Args.getLastArg(options::OPT_mstack_alignment)) {
6865 StringRef
Value = A->getValue();
6866 int64_t Alignment = 0;
6867 if (
Value.getAsInteger(10, Alignment) || Alignment < 0)
6868 D.
Diag(diag::err_drv_invalid_argument_to_option)
6869 <<
Value << A->getOption().getName();
6870 else if (Alignment & (Alignment - 1))
6871 D.
Diag(diag::err_drv_alignment_not_power_of_two)
6872 << A->getAsString(Args) <<
Value;
6874 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" +
Value));
6877 if (Args.hasArg(options::OPT_mstack_probe_size)) {
6878 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
6881 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
6883 CmdArgs.push_back(
"-mstack-probe-size=0");
6886 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
6887 options::OPT_mno_stack_arg_probe);
6889 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
6890 options::OPT_mno_restrict_it)) {
6891 if (A->getOption().matches(options::OPT_mrestrict_it)) {
6892 CmdArgs.push_back(
"-mllvm");
6893 CmdArgs.push_back(
"-arm-restrict-it");
6895 CmdArgs.push_back(
"-mllvm");
6896 CmdArgs.push_back(
"-arm-default-it");
6910 if (Args.hasFlag(options::OPT_fhip_new_launch_api,
6911 options::OPT_fno_hip_new_launch_api,
true))
6912 CmdArgs.push_back(
"-fhip-new-launch-api");
6913 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,
6914 options::OPT_fno_gpu_allow_device_init);
6915 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar);
6916 Args.AddLastArg(CmdArgs, options::OPT_hipstdpar_interpose_alloc);
6917 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
6918 options::OPT_fno_hip_kernel_arg_name);
6921 if (IsCuda || IsHIP) {
6923 CmdArgs.push_back(
"-fgpu-rdc");
6924 Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,
6925 options::OPT_fno_gpu_defer_diag);
6926 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,
6927 options::OPT_fno_gpu_exclude_wrong_side_overloads,
6929 CmdArgs.push_back(
"-fgpu-exclude-wrong-side-overloads");
6930 CmdArgs.push_back(
"-fgpu-defer-diag");
6935 if (!Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
true))
6936 CmdArgs.push_back(
"--no-offloadlib");
6938 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
6940 Args.MakeArgString(Twine(
"-fcf-protection=") + A->getValue()));
6942 if (Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))
6943 CmdArgs.push_back(Args.MakeArgString(Twine(
"-mcf-branch-label-scheme=") +
6945 }
else if (Triple.isOSOpenBSD() && Triple.getArch() == llvm::Triple::x86_64) {
6947 CmdArgs.push_back(
"-fcf-protection=branch");
6949 CmdArgs.push_back(
"-fno-jump-tables");
6952 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ))
6954 Args.MakeArgString(Twine(
"-mfunction-return=") + A->getValue()));
6956 Args.AddLastArg(CmdArgs, options::OPT_mindirect_branch_cs_prefix);
6961 if (!(IsCudaDevice || IsHIPDevice)) {
6963 auto *PGOArg = Args.getLastArg(
6964 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
6965 options::OPT_fcs_profile_generate,
6966 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,
6967 options::OPT_fprofile_use_EQ);
6969 D.
Diag(diag::err_drv_argument_not_allowed_with)
6970 <<
"SampleUse with PGO options";
6972 StringRef fname = A->getValue();
6973 if (!llvm::sys::fs::exists(fname))
6974 D.
Diag(diag::err_drv_no_such_file) << fname;
6976 A->render(Args, CmdArgs);
6978 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
6980 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,
6981 options::OPT_fno_pseudo_probe_for_profiling,
false)) {
6982 CmdArgs.push_back(
"-fpseudo-probe-for-profiling");
6985 if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
6986 options::OPT_fno_unique_internal_linkage_names,
true))
6987 CmdArgs.push_back(
"-funique-internal-linkage-names");
6992 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
6993 options::OPT_fno_assume_sane_operator_new);
6995 if (Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,
false))
6996 CmdArgs.push_back(
"-fapinotes");
6997 if (Args.hasFlag(options::OPT_fapinotes_modules,
6998 options::OPT_fno_apinotes_modules,
false))
6999 CmdArgs.push_back(
"-fapinotes-modules");
7000 Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
7002 if (Args.hasFlag(options::OPT_fswift_version_independent_apinotes,
7003 options::OPT_fno_swift_version_independent_apinotes,
false))
7004 CmdArgs.push_back(
"-fswift-version-independent-apinotes");
7007 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
7009 (Args.hasArg(options::OPT_fgnu_runtime) &&
7010 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
7011 !Args.hasArg(options::OPT_fno_blocks))) {
7012 CmdArgs.push_back(
"-fblocks");
7015 CmdArgs.push_back(
"-fblocks-runtime-optional");
7020 CmdArgs.push_back(
"-fencode-extended-block-signature");
7022 if (Args.hasFlag(options::OPT_fcoro_aligned_allocation,
7023 options::OPT_fno_coro_aligned_allocation,
false) &&
7025 CmdArgs.push_back(
"-fcoro-aligned-allocation");
7027 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
7028 options::OPT_fno_double_square_bracket_attributes);
7030 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,
7031 options::OPT_fno_access_control);
7032 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,
7033 options::OPT_fno_elide_constructors);
7039 CmdArgs.push_back(
"-fno-rtti");
7042 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
7043 TC.
getArch() == llvm::Triple::hexagon || Triple.isOSzOS()))
7044 CmdArgs.push_back(
"-fshort-enums");
7050 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
7051 !RawTriple.isOSAIX() &&
7052 (!RawTriple.isOSWindows() ||
7053 RawTriple.isWindowsCygwinEnvironment()) &&
7054 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
7055 RawTriple.hasEnvironment())) ||
7057 CmdArgs.push_back(
"-fno-use-cxa-atexit");
7059 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
7060 options::OPT_fno_register_global_dtors_with_atexit,
7061 RawTriple.isOSDarwin() && !KernelOrKext))
7062 CmdArgs.push_back(
"-fregister-global-dtors-with-atexit");
7064 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,
7065 options::OPT_fno_use_line_directives);
7068 if (Args.hasFlag(options::OPT_fminimize_whitespace,
7069 options::OPT_fno_minimize_whitespace,
false)) {
7070 types::ID InputType = Inputs[0].getType();
7071 if (!isDerivedFromC(InputType))
7072 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7074 CmdArgs.push_back(
"-fminimize-whitespace");
7078 if (Args.hasFlag(options::OPT_fkeep_system_includes,
7079 options::OPT_fno_keep_system_includes,
false)) {
7080 types::ID InputType = Inputs[0].getType();
7081 if (!isDerivedFromC(InputType))
7082 D.
Diag(diag::err_drv_opt_unsupported_input_type)
7084 CmdArgs.push_back(
"-fkeep-system-includes");
7088 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
7089 IsWindowsMSVC || IsUEFI))
7090 CmdArgs.push_back(
"-fms-extensions");
7093 bool IsMSVCCompat = Args.hasFlag(
7094 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
7095 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
7096 options::OPT_fno_ms_extensions,
true)));
7098 CmdArgs.push_back(
"-fms-compatibility");
7100 Args.hasArg(options::OPT_fms_define_stdc))
7101 CmdArgs.push_back(
"-fms-define-stdc");
7104 if (Triple.isWindowsMSVCEnvironment() && !D.
IsCLMode() &&
7105 Args.hasArg(options::OPT_fms_runtime_lib_EQ))
7109 VersionTuple GNUCVer;
7110 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
7113 StringRef Val = A->getValue();
7114 Val = Val.empty() ?
"0" : Val;
7115 bool Invalid = GNUCVer.tryParse(Val);
7116 unsigned Minor = GNUCVer.getMinor().value_or(0);
7117 unsigned Patch = GNUCVer.getSubminor().value_or(0);
7118 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
7119 D.
Diag(diag::err_drv_invalid_value)
7120 << A->getAsString(Args) << A->getValue();
7122 }
else if (!IsMSVCCompat) {
7124 GNUCVer = VersionTuple(4, 2, 1);
7126 if (!GNUCVer.empty()) {
7128 Args.MakeArgString(
"-fgnuc-version=" + GNUCVer.getAsString()));
7134 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.getAsString()));
7136 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
7137 if (ImplyVCPPCVer) {
7139 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7142 .Case(
"c11",
"-std=c11")
7143 .Case(
"c17",
"-std=c17")
7145 .Case(
"clatest",
"-std=c23")
7148 D.
Diag(clang::diag::warn_drv_unused_argument)
7149 << StdArg->getAsString(Args);
7153 if (ImplyVCPPCXXVer) {
7155 if (
const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
7158 .Case(
"c++14",
"-std=c++14")
7159 .Case(
"c++17",
"-std=c++17")
7160 .Case(
"c++20",
"-std=c++20")
7162 .Case(
"c++23preview",
"-std=c++23")
7163 .Case(
"c++latest",
"-std=c++26")
7166 D.
Diag(clang::diag::warn_drv_unused_argument)
7167 << StdArg->getAsString(Args);
7171 if (IsMSVC2015Compatible)
7180 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
7181 options::OPT_fno_borland_extensions);
7184 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
7186 CmdArgs.push_back(
"-fdeclspec");
7187 else if (Args.hasArg(options::OPT_fno_declspec))
7188 CmdArgs.push_back(
"-fno-declspec");
7192 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
7193 options::OPT_fno_threadsafe_statics,
7195 (!IsWindowsMSVC || IsMSVC2015Compatible)))
7196 CmdArgs.push_back(
"-fno-threadsafe-statics");
7198 if (!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,
7200 CmdArgs.push_back(
"-fno-ms-tls-guards");
7203 if (!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,
7205 CmdArgs.push_back(
"-fno-assumptions");
7209 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
7210 options::OPT_fno_gnu_keywords);
7212 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,
7213 options::OPT_fno_gnu89_inline);
7215 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,
7216 options::OPT_finline_hint_functions,
7217 options::OPT_fno_inline_functions);
7218 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {
7219 if (A->getOption().matches(options::OPT_fno_inline))
7220 A->render(Args, CmdArgs);
7221 }
else if (InlineArg) {
7222 InlineArg->render(Args, CmdArgs);
7225 Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
7230 (Std->containsValue(
"c++2a") || Std->containsValue(
"gnu++2a") ||
7231 Std->containsValue(
"c++20") || Std->containsValue(
"gnu++20") ||
7232 Std->containsValue(
"c++2b") || Std->containsValue(
"gnu++2b") ||
7233 Std->containsValue(
"c++23") || Std->containsValue(
"gnu++23") ||
7234 Std->containsValue(
"c++2c") || Std->containsValue(
"gnu++2c") ||
7235 Std->containsValue(
"c++26") || Std->containsValue(
"gnu++26") ||
7236 Std->containsValue(
"c++latest") || Std->containsValue(
"gnu++latest"));
7251 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
7252 options::OPT_fno_delayed_template_parsing,
7253 IsWindowsMSVC && !HaveCxx20)) {
7255 D.
Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);
7257 CmdArgs.push_back(
"-fdelayed-template-parsing");
7260 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
7261 options::OPT_fno_pch_validate_input_files_content,
false))
7262 CmdArgs.push_back(
"-fvalidate-ast-input-files-content");
7263 if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
7264 options::OPT_fno_pch_instantiate_templates,
false))
7265 CmdArgs.push_back(
"-fpch-instantiate-templates");
7266 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,
7268 CmdArgs.push_back(
"-fmodules-codegen");
7269 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,
7271 CmdArgs.push_back(
"-fmodules-debuginfo");
7273 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
7278 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
7279 options::OPT_fno_objc_encode_cxx_class_template_spec,
7281 CmdArgs.push_back(
"-fobjc-encode-cxx-class-template-spec");
7283 if (Args.hasFlag(options::OPT_fapplication_extension,
7284 options::OPT_fno_application_extension,
false))
7285 CmdArgs.push_back(
"-fapplication-extension");
7289 if (!
C.getDriver().IsCLMode())
7290 EH =
addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
7293 Arg *A = Args.getLastArg(
7294 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
7295 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
7297 const Option &Opt = A->getOption();
7298 if (Opt.matches(options::OPT_fsjlj_exceptions))
7299 CmdArgs.push_back(
"-exception-model=sjlj");
7300 if (Opt.matches(options::OPT_fseh_exceptions))
7301 CmdArgs.push_back(
"-exception-model=seh");
7302 if (Opt.matches(options::OPT_fdwarf_exceptions))
7303 CmdArgs.push_back(
"-exception-model=dwarf");
7304 if (Opt.matches(options::OPT_fwasm_exceptions))
7305 CmdArgs.push_back(
"-exception-model=wasm");
7310 case llvm::ExceptionHandling::DwarfCFI:
7311 CmdArgs.push_back(
"-exception-model=dwarf");
7313 case llvm::ExceptionHandling::SjLj:
7314 CmdArgs.push_back(
"-exception-model=sjlj");
7316 case llvm::ExceptionHandling::WinEH:
7317 CmdArgs.push_back(
"-exception-model=seh");
7323 Args.AddLastArg(CmdArgs, options::OPT_winx64_eh_unwindv2);
7326 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,
7327 options::OPT_fno_assume_sane_operator_new);
7330 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,
7331 options::OPT_fno_assume_unique_vtables);
7335 Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,
7336 options::OPT_fno_sized_deallocation);
7340 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
7341 options::OPT_fno_aligned_allocation,
7342 options::OPT_faligned_new_EQ)) {
7343 if (A->getOption().matches(options::OPT_fno_aligned_allocation))
7344 CmdArgs.push_back(
"-fno-aligned-allocation");
7346 CmdArgs.push_back(
"-faligned-allocation");
7351 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
7352 options::OPT_faligned_new_EQ))
7354 Args.MakeArgString(Twine(
"-fnew-alignment=") + A->getValue()));
7358 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
7359 options::OPT_fno_constant_cfstrings,
true) ||
7360 !Args.hasFlag(options::OPT_mconstant_cfstrings,
7361 options::OPT_mno_constant_cfstrings,
true))
7362 CmdArgs.push_back(
"-fno-constant-cfstrings");
7364 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,
7365 options::OPT_fno_pascal_strings);
7369 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
7370 std::string PackStructStr =
"-fpack-struct=";
7371 PackStructStr += A->getValue();
7372 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
7373 }
else if (Args.hasFlag(options::OPT_fpack_struct,
7374 options::OPT_fno_pack_struct,
false)) {
7375 CmdArgs.push_back(
"-fpack-struct=1");
7379 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
7380 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
7381 if (!SkipMaxTypeAlign) {
7382 std::string MaxTypeAlignStr =
"-fmax-type-align=";
7383 MaxTypeAlignStr += A->getValue();
7384 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7386 }
else if (RawTriple.isOSDarwin()) {
7387 if (!SkipMaxTypeAlign) {
7388 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
7389 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
7393 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,
true))
7394 CmdArgs.push_back(
"-Qn");
7397 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
7401 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
7402 options::OPT_funsigned_bitfields,
true))
7403 D.
Diag(diag::warn_drv_clang_unsupported)
7404 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
7407 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,
true))
7408 D.
Diag(diag::err_drv_clang_unsupported)
7409 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
7412 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
7413 StringRef value = inputCharset->getValue();
7414 if (!value.equals_insensitive(
"utf-8"))
7415 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
7420 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
7421 StringRef value = execCharset->getValue();
7422 if (!value.equals_insensitive(
"utf-8"))
7423 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
7429 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,
7430 options::OPT_fno_asm_blocks);
7432 Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,
7433 options::OPT_fno_gnu_inline_asm);
7439 if (!VecWidth.empty())
7440 CmdArgs.push_back(Args.MakeArgString(
"-mprefer-vector-width=" + VecWidth));
7442 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
7443 Args.AddLastArg(CmdArgs,
7444 options::OPT_fsanitize_undefined_strip_path_components_EQ);
7448 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
7449 options::OPT_fno_dollars_in_identifiers)) {
7450 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
7451 CmdArgs.push_back(
"-fdollars-in-identifiers");
7453 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
7456 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,
7457 options::OPT_fno_apple_pragma_pack);
7463 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
7464 options::OPT_fno_rewrite_imports,
false);
7466 CmdArgs.push_back(
"-frewrite-imports");
7468 Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,
7469 options::OPT_fno_directives_only);
7475 if (Args.hasFlag(options::OPT_frewrite_includes,
7476 options::OPT_fno_rewrite_includes,
false) ||
7477 (
C.isForDiagnostics() && !HaveModules))
7478 CmdArgs.push_back(
"-frewrite-includes");
7480 if (Args.hasFlag(options::OPT_fzos_extensions,
7481 options::OPT_fno_zos_extensions,
false))
7482 CmdArgs.push_back(
"-fzos-extensions");
7483 else if (Args.hasArg(options::OPT_fno_zos_extensions))
7484 CmdArgs.push_back(
"-fno-zos-extensions");
7487 if (Arg *A = Args.getLastArg(options::OPT_traditional,
7488 options::OPT_traditional_cpp)) {
7490 CmdArgs.push_back(
"-traditional-cpp");
7492 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
7495 Args.AddLastArg(CmdArgs, options::OPT_dM);
7496 Args.AddLastArg(CmdArgs, options::OPT_dD);
7497 Args.AddLastArg(CmdArgs, options::OPT_dI);
7499 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ);
7502 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
7503 CmdArgs.push_back(
"-serialize-diagnostic-file");
7504 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
7507 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
7508 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
7510 if (Arg *A = Args.getLastArg(options::OPT_fextend_variable_liveness_EQ)) {
7511 A->render(Args, CmdArgs);
7512 }
else if (Arg *A = Args.getLastArg(options::OPT_O_Group);
7513 A && A->containsValue(
"g")) {
7515 CmdArgs.push_back(
"-fextend-variable-liveness=all");
7519 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
7521 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
7524 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
7525 CmdArgs.push_back(
"-load");
7526 CmdArgs.push_back(A->getValue());
7538 for (
const Arg *A : Args.filtered(options::OPT_fplugin_arg)) {
7539 auto ArgValue = StringRef(A->getValue());
7540 auto FirstDashIndex = ArgValue.find(
'-');
7541 StringRef PluginName = ArgValue.substr(0, FirstDashIndex);
7542 StringRef Arg = ArgValue.substr(FirstDashIndex + 1);
7545 if (FirstDashIndex == StringRef::npos || Arg.empty()) {
7546 if (PluginName.empty()) {
7547 D.
Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);
7549 D.
Diag(diag::warn_drv_missing_plugin_arg)
7550 << PluginName << A->getAsString(Args);
7555 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-arg-") + PluginName));
7556 CmdArgs.push_back(Args.MakeArgString(Arg));
7560 for (
const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
7562 Args.MakeArgString(Twine(
"-fpass-plugin=") + A->getValue()));
7567 for (
const Arg *A : Args.filtered(options::OPT_vfsoverlay)) {
7568 CmdArgs.push_back(
"--vfsoverlay");
7569 CmdArgs.push_back(A->getValue());
7573 Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,
7574 options::OPT_fno_safe_buffer_usage_suggestions);
7576 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,
7577 options::OPT_fno_experimental_late_parse_attributes);
7579 if (Args.hasFlag(options::OPT_funique_source_file_names,
7580 options::OPT_fno_unique_source_file_names,
false)) {
7581 if (Arg *A = Args.getLastArg(options::OPT_unique_source_file_identifier_EQ))
7582 A->render(Args, CmdArgs);
7584 CmdArgs.push_back(Args.MakeArgString(
7585 Twine(
"-funique-source-file-identifier=") + Input.
getBaseInput()));
7590 if (!StatsFile.empty()) {
7591 CmdArgs.push_back(Args.MakeArgString(Twine(
"-stats-file=") + StatsFile));
7593 CmdArgs.push_back(
"-stats-file-append");
7598 for (
auto Arg : Args.filtered(options::OPT_Xclang)) {
7602 if (
C.getDriver().isSaveTempsEnabled() &&
7604 if (StringRef(Arg->getValue()) ==
"-finclude-default-header")
7607 CmdArgs.push_back(Arg->getValue());
7609 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
7615 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
7616 CmdArgs.push_back(
"-disable-llvm-optzns");
7618 A->render(Args, CmdArgs);
7624 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);
7628 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
7630 A->render(Args, CmdArgs);
7642 if ((
C.getDriver().isSaveTempsEnabled() ||
7644 !(
C.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&
7646 CmdArgs.push_back(
"-disable-llvm-passes");
7648 Args.AddAllArgs(CmdArgs, options::OPT_undef);
7657 auto GRecordSwitches =
false;
7658 auto FRecordSwitches =
false;
7662 CmdArgs.push_back(
"-dwarf-debug-flags");
7663 CmdArgs.push_back(FlagsArgString);
7665 if (FRecordSwitches) {
7666 CmdArgs.push_back(
"-record-command-line");
7667 CmdArgs.push_back(FlagsArgString);
7674 if ((IsCuda || IsHIP) && CudaDeviceInput) {
7675 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7676 CmdArgs.push_back(CudaDeviceInput->
getFilename());
7677 }
else if (!HostOffloadingInputs.empty()) {
7678 if (IsCuda && !IsRDCMode) {
7679 assert(HostOffloadingInputs.size() == 1 &&
"Only one input expected");
7680 CmdArgs.push_back(
"-fcuda-include-gpubinary");
7681 CmdArgs.push_back(HostOffloadingInputs.front().getFilename());
7683 for (
const InputInfo Input : HostOffloadingInputs)
7684 CmdArgs.push_back(Args.MakeArgString(
"-fembed-offload-object=" +
7690 if (Args.hasFlag(options::OPT_fcuda_short_ptr,
7691 options::OPT_fno_cuda_short_ptr,
false))
7692 CmdArgs.push_back(
"-fcuda-short-ptr");
7695 if (IsCuda || IsHIP) {
7697 const Action *SourceAction = &JA;
7699 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
7700 SourceAction = SourceAction->
getInputs()[0];
7704 CmdArgs.push_back(Args.MakeArgString(Twine(
"-cuid=") + Twine(CUID)));
7708 bool UseApproxTranscendentals = Args.hasFlag(
7709 options::OPT_ffast_math, options::OPT_fno_fast_math,
false);
7710 if (Args.hasFlag(options::OPT_fgpu_approx_transcendentals,
7711 options::OPT_fno_gpu_approx_transcendentals,
7712 UseApproxTranscendentals))
7713 CmdArgs.push_back(
"-fgpu-approx-transcendentals");
7715 Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,
7716 options::OPT_fno_gpu_approx_transcendentals);
7720 CmdArgs.push_back(
"-fcuda-allow-variadic-functions");
7721 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ);
7724 Args.AddAllArgs(CmdArgs,
7725 options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);
7727 Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,
7728 options::OPT_fno_offload_uniform_block);
7730 Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,
7731 options::OPT_fno_offload_implicit_host_device_templates);
7733 if (IsCudaDevice || IsHIPDevice) {
7734 StringRef InlineThresh =
7735 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);
7736 if (!InlineThresh.empty()) {
7737 std::string ArgStr =
7738 std::string(
"-inline-threshold=") + InlineThresh.str();
7739 CmdArgs.append({
"-mllvm", Args.MakeArgStringRef(ArgStr)});
7744 Args.addOptOutFlag(CmdArgs,
7745 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
7746 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
7753 if (IsOpenMPDevice) {
7754 CmdArgs.push_back(
"-fopenmp-is-target-device");
7756 if (Args.hasArg(options::OPT_foffload_via_llvm))
7757 CmdArgs.push_back(
"-fcuda-is-device");
7759 if (OpenMPDeviceInput) {
7760 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
7761 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->
getFilename()));
7765 if (Triple.isAMDGPU()) {
7768 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,
7769 options::OPT_mno_unsafe_fp_atomics);
7770 Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,
7771 options::OPT_mno_amdgpu_ieee);
7776 bool VirtualFunctionElimination =
7777 Args.hasFlag(options::OPT_fvirtual_function_elimination,
7778 options::OPT_fno_virtual_function_elimination,
false);
7779 if (VirtualFunctionElimination) {
7783 D.
Diag(diag::err_drv_argument_only_allowed_with)
7784 <<
"-fvirtual-function-elimination"
7787 CmdArgs.push_back(
"-fvirtual-function-elimination");
7791 bool WholeProgramVTables = Args.hasFlag(
7792 options::OPT_fwhole_program_vtables,
7793 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
7794 if (VirtualFunctionElimination && !WholeProgramVTables) {
7795 D.
Diag(diag::err_drv_argument_not_allowed_with)
7796 <<
"-fno-whole-program-vtables"
7797 <<
"-fvirtual-function-elimination";
7800 if (WholeProgramVTables) {
7813 auto OtherIsUsingLTO = OtherLTOMode !=
LTOK_None;
7815 if ((!IsUsingLTO && !OtherIsUsingLTO) ||
7817 D.
Diag(diag::err_drv_argument_only_allowed_with)
7818 <<
"-fwhole-program-vtables"
7819 << ((IsPS4 && !UnifiedLTO) ?
"-flto=full" :
"-flto");
7823 CmdArgs.push_back(
"-fwhole-program-vtables");
7826 bool DefaultsSplitLTOUnit =
7827 ((WholeProgramVTables || SanitizeArgs.needsLTO()) &&
7829 (!Triple.isPS4() && UnifiedLTO);
7831 Args.hasFlag(options::OPT_fsplit_lto_unit,
7832 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
7833 if (SanitizeArgs.needsLTO() && !SplitLTOUnit)
7834 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fno-split-lto-unit"
7835 <<
"-fsanitize=cfi";
7837 CmdArgs.push_back(
"-fsplit-lto-unit");
7839 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
7840 options::OPT_fno_fat_lto_objects)) {
7841 if (IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {
7843 if (!Triple.isOSBinFormatELF()) {
7844 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7847 CmdArgs.push_back(Args.MakeArgString(
7848 Twine(
"-flto=") + (LTOMode ==
LTOK_Thin ?
"thin" :
"full")));
7849 CmdArgs.push_back(
"-flto-unit");
7850 CmdArgs.push_back(
"-ffat-lto-objects");
7851 A->render(Args, CmdArgs);
7855 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
7856 options::OPT_fno_global_isel)) {
7857 CmdArgs.push_back(
"-mllvm");
7858 if (A->getOption().matches(options::OPT_fglobal_isel)) {
7859 CmdArgs.push_back(
"-global-isel=1");
7864 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
7865 bool IsOptLevelSupported =
false;
7867 Arg *A = Args.getLastArg(options::OPT_O_Group);
7868 if (Triple.getArch() == llvm::Triple::aarch64) {
7869 if (!A || A->getOption().matches(options::OPT_O0))
7870 IsOptLevelSupported =
true;
7872 if (!IsArchSupported || !IsOptLevelSupported) {
7873 CmdArgs.push_back(
"-mllvm");
7874 CmdArgs.push_back(
"-global-isel-abort=2");
7876 if (!IsArchSupported)
7877 D.
Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();
7879 D.
Diag(diag::warn_drv_global_isel_incomplete_opt);
7882 CmdArgs.push_back(
"-global-isel=0");
7886 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
7887 options::OPT_fno_force_enable_int128)) {
7888 if (A->getOption().matches(options::OPT_fforce_enable_int128))
7889 CmdArgs.push_back(
"-fforce-enable-int128");
7892 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,
7893 options::OPT_fno_keep_static_consts);
7894 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,
7895 options::OPT_fno_keep_persistent_storage_variables);
7896 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,
7897 options::OPT_fno_complete_member_pointers);
7898 if (Arg *A = Args.getLastArg(options::OPT_cxx_static_destructors_EQ))
7899 A->render(Args, CmdArgs);
7905 if (Triple.isAArch64() &&
7906 (Args.hasArg(options::OPT_mno_fmv) ||
7907 (Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||
7910 CmdArgs.push_back(
"-target-feature");
7911 CmdArgs.push_back(
"-fmv");
7914 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
7921 CmdArgs.push_back(
"-faddrsig");
7923 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
7924 (EH || UnwindTables || AsyncUnwindTables ||
7925 DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
7926 CmdArgs.push_back(
"-D__GCC_HAVE_DWARF2_CFI_ASM=1");
7928 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
7929 std::string Str = A->getAsString(Args);
7931 D.
Diag(diag::err_drv_unsupported_opt_for_target)
7933 CmdArgs.push_back(Args.MakeArgString(Str));
7938 if (Output.
getType() == types::TY_Dependencies) {
7941 if (Output.
getType() == clang::driver::types::TY_IFS_CPP ||
7942 Output.
getType() == clang::driver::types::TY_IFS) {
7944 llvm::sys::path::replace_extension(OutputFilename,
"ifs");
7945 CmdArgs.push_back(
"-o");
7946 CmdArgs.push_back(Args.MakeArgString(OutputFilename));
7948 CmdArgs.push_back(
"-o");
7952 assert(Output.
isNothing() &&
"Invalid output.");
7959 FrontendInputs = ExtractAPIInputs;
7961 FrontendInputs = {};
7963 for (
const InputInfo &Input : FrontendInputs) {
7972 C.addCommand(std::make_unique<CC1Command>(
7976 C.addCommand(std::make_unique<Command>(
7982 if (Output.
getType() == types::TY_Object &&
7983 Args.hasFlag(options::OPT__SLASH_showFilenames,
7984 options::OPT__SLASH_showFilenames_,
false)) {
7985 C.getJobs().getJobs().back()->PrintInputFilenames =
true;
7988 if (Arg *A = Args.getLastArg(options::OPT_pg))
7990 !Args.hasArg(options::OPT_mfentry))
7991 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
7992 << A->getAsString(Args);
7998 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
8002 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
8003 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
8006 Args.ClaimAllArgs(options::OPT_emit_llvm);