15#include "llvm/Frontend/Debug/Options.h"
16#include "llvm/Support/Path.h"
17#include "llvm/TargetParser/Host.h"
18#include "llvm/TargetParser/RISCVISAInfo.h"
19#include "llvm/TargetParser/RISCVTargetParser.h"
30 ArgStringList &CmdArgs) {
31 CmdArgs.push_back(
"-x");
36void Flang::addFortranDialectOptions(
const ArgList &Args,
37 ArgStringList &CmdArgs)
const {
38 Args.addAllArgs(CmdArgs, {options::OPT_ffixed_form,
39 options::OPT_ffree_form,
40 options::OPT_ffixed_line_length_EQ,
41 options::OPT_fopenacc,
42 options::OPT_finput_charset_EQ,
43 options::OPT_fimplicit_none,
44 options::OPT_fimplicit_none_ext,
45 options::OPT_fno_implicit_none,
46 options::OPT_fbackslash,
47 options::OPT_fno_backslash,
48 options::OPT_flogical_abbreviations,
49 options::OPT_fno_logical_abbreviations,
50 options::OPT_fxor_operator,
51 options::OPT_fno_xor_operator,
52 options::OPT_falternative_parameter_statement,
53 options::OPT_fdefault_real_8,
54 options::OPT_fdefault_integer_8,
55 options::OPT_fdefault_double_8,
56 options::OPT_flarge_sizes,
57 options::OPT_fno_automatic,
58 options::OPT_fhermetic_module_files,
59 options::OPT_frealloc_lhs,
60 options::OPT_fno_realloc_lhs,
61 options::OPT_fsave_main_program,
62 options::OPT_fd_lines_as_code,
63 options::OPT_fd_lines_as_comments,
64 options::OPT_fno_save_main_program});
67void Flang::addPreprocessingOptions(
const ArgList &Args,
68 ArgStringList &CmdArgs)
const {
69 Args.addAllArgs(CmdArgs,
70 {options::OPT_P, options::OPT_D, options::OPT_U,
71 options::OPT_I, options::OPT_cpp, options::OPT_nocpp});
92 const Arg *LoopVersioningArg = Args.getLastArg(
93 options::OPT_Ofast, options::OPT_O, options::OPT_O4,
94 options::OPT_floop_versioning, options::OPT_fno_loop_versioning);
95 if (!LoopVersioningArg)
98 if (LoopVersioningArg->getOption().matches(options::OPT_fno_loop_versioning))
101 if (LoopVersioningArg->getOption().matches(options::OPT_floop_versioning))
104 if (LoopVersioningArg->getOption().matches(options::OPT_Ofast) ||
105 LoopVersioningArg->getOption().matches(options::OPT_O4))
108 if (LoopVersioningArg->getOption().matches(options::OPT_O)) {
109 StringRef S(LoopVersioningArg->getValue());
110 unsigned OptLevel = 0;
113 if (S.getAsInteger(10, OptLevel))
119 llvm_unreachable(
"We should not end up here");
123void Flang::addDebugOptions(
const llvm::opt::ArgList &Args,
const JobAction &JA,
124 const InputInfo &Output,
const InputInfo &Input,
125 llvm::opt::ArgStringList &CmdArgs)
const {
127 const Driver &D = TC.getDriver();
128 Args.addAllArgs(CmdArgs,
129 {options::OPT_module_dir, options::OPT_fdebug_module_writer,
130 options::OPT_fintrinsic_modules_path, options::OPT_pedantic,
131 options::OPT_std_EQ, options::OPT_W_Joined,
132 options::OPT_fconvert_EQ, options::OPT_fpass_plugin_EQ,
133 options::OPT_funderscoring, options::OPT_fno_underscoring,
134 options::OPT_funsigned, options::OPT_fno_unsigned,
135 options::OPT_finstrument_functions});
137 llvm::codegenoptions::DebugInfoKind DebugInfoKind;
139 if (Args.hasArg(options::OPT_gN_Group)) {
140 Arg *gNArg = Args.getLastArg(options::OPT_gN_Group);
142 }
else if (Args.hasArg(options::OPT_g_Flag) || hasDwarfNArg) {
143 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
145 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
151 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
153 if (Args.hasArg(options::OPT_gsplit_dwarf) ||
154 Args.hasArg(options::OPT_gsplit_dwarf_EQ)) {
156 if (TC.getTriple().isOSAIX()) {
157 D.
Diag(diag::err_drv_unsupported_opt_for_target)
158 << Args.getLastArg(options::OPT_gsplit_dwarf)->getSpelling()
159 << TC.getTriple().str();
162 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo)
172 if (!TC.getTriple().isOSBinFormatELF() &&
173 !TC.getTriple().isOSBinFormatWasm() &&
174 !TC.getTriple().isOSBinFormatCOFF()) {
175 D.
Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
176 << SplitDWARFArg->getSpelling() << TC.getTriple().str();
184 const char *SplitDWARFOut =
SplitDebugName(JA, Args, Input, Output);
185 CmdArgs.push_back(
"-split-dwarf-file");
186 CmdArgs.push_back(SplitDWARFOut);
188 CmdArgs.push_back(
"-split-dwarf-output");
189 CmdArgs.push_back(SplitDWARFOut);
194void Flang::addCodegenOptions(
const ArgList &Args,
195 ArgStringList &CmdArgs)
const {
197 Args.getLastArg(options::OPT_Ofast, options::OPT_fstack_arrays,
198 options::OPT_fno_stack_arrays);
200 !stackArrays->getOption().matches(options::OPT_fno_stack_arrays))
201 CmdArgs.push_back(
"-fstack-arrays");
203 Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_loop_fusion,
204 options::OPT_fno_experimental_loop_fusion);
211 CmdArgs.push_back(
"-fversion-loops-for-stride");
213 for (
const auto &arg :
214 Args.getAllArgValues(options::OPT_frepack_arrays_contiguity_EQ))
215 if (arg !=
"whole" && arg !=
"innermost") {
217 <<
"-frepack-arrays-contiguity=" <<
arg;
222 {options::OPT_fdo_concurrent_to_openmp_EQ,
223 options::OPT_flang_experimental_hlfir,
224 options::OPT_flang_deprecated_no_hlfir,
225 options::OPT_fno_ppc_native_vec_elem_order,
226 options::OPT_fppc_native_vec_elem_order, options::OPT_finit_global_zero,
227 options::OPT_fno_init_global_zero, options::OPT_frepack_arrays,
228 options::OPT_fno_repack_arrays,
229 options::OPT_frepack_arrays_contiguity_EQ,
230 options::OPT_fstack_repack_arrays, options::OPT_fno_stack_repack_arrays,
231 options::OPT_ftime_report, options::OPT_ftime_report_EQ,
232 options::OPT_funroll_loops, options::OPT_fno_unroll_loops});
233 if (Args.hasArg(clang::driver::options::OPT_fcoarray))
234 CmdArgs.push_back(
"-fcoarray");
237void Flang::addLTOOptions(
const ArgList &Args, ArgStringList &CmdArgs)
const {
240 DiagnosticsEngine &Diags = D.
getDiags();
245 CmdArgs.push_back(
"-flto=full");
249 "the option '-flto=thin' is a work in progress"));
250 CmdArgs.push_back(
"-flto=thin");
252 Args.addAllArgs(CmdArgs, {options::OPT_ffat_lto_objects,
253 options::OPT_fno_fat_lto_objects});
256void Flang::addPicOptions(
const ArgList &Args, ArgStringList &CmdArgs)
const {
259 llvm::Reloc::Model RelocationModel;
262 std::tie(RelocationModel, PICLevel, IsPIE) =
266 CmdArgs.push_back(
"-mrelocation-model");
267 CmdArgs.push_back(RMName);
270 CmdArgs.push_back(
"-pic-level");
271 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
273 CmdArgs.push_back(
"-pic-is-pie");
277void Flang::AddAArch64TargetArgs(
const ArgList &Args,
278 ArgStringList &CmdArgs)
const {
280 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
281 StringRef Val = A->getValue();
283 if (Val ==
"128" || Val ==
"256" || Val ==
"512" || Val ==
"1024" ||
284 Val ==
"2048" || Val ==
"128+" || Val ==
"256+" || Val ==
"512+" ||
285 Val ==
"1024+" || Val ==
"2048+") {
287 if (!Val.consume_back(
"+")) {
288 [[maybe_unused]]
bool Invalid = Val.getAsInteger(10, Bits);
289 assert(!
Invalid &&
"Failed to parse value");
291 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
294 [[maybe_unused]]
bool Invalid = Val.getAsInteger(10, Bits);
295 assert(!
Invalid &&
"Failed to parse value");
297 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
299 }
else if (Val !=
"scalable")
301 D.
Diag(diag::err_drv_unsupported_option_argument)
302 << A->getSpelling() << Val;
306void Flang::AddLoongArch64TargetArgs(
const ArgList &Args,
307 ArgStringList &CmdArgs)
const {
310 if (
const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
311 StringRef
V = A->getValue();
313 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-mabi" <<
V;
317 if (
const Arg *A = Args.getLastArg(options::OPT_mannotate_tablejump,
318 options::OPT_mno_annotate_tablejump)) {
319 if (A->getOption().matches(options::OPT_mannotate_tablejump)) {
320 CmdArgs.push_back(
"-mllvm");
321 CmdArgs.push_back(
"-loongarch-annotate-tablejump");
326void Flang::AddPPCTargetArgs(
const ArgList &Args,
327 ArgStringList &CmdArgs)
const {
329 bool VecExtabi =
false;
331 if (
const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
332 StringRef
V = A->getValue();
333 if (
V ==
"vec-extabi")
335 else if (
V ==
"vec-default")
338 D.
Diag(diag::err_drv_unsupported_option_argument)
339 << A->getSpelling() <<
V;
345 D.
Diag(diag::err_drv_unsupported_opt_for_target)
346 <<
"-mabi=vec-extabi" <<
T.str();
348 CmdArgs.push_back(
"-mabi=vec-extabi");
352void Flang::AddRISCVTargetArgs(
const ArgList &Args,
353 ArgStringList &CmdArgs)
const {
358 if (ABIName ==
"lp64" || ABIName ==
"lp64f" || ABIName ==
"lp64d")
359 CmdArgs.push_back(Args.MakeArgString(
"-mabi=" + ABIName));
361 D.
Diag(diag::err_drv_unsupported_option_argument) <<
"-mabi=" << ABIName;
364 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
365 StringRef Val = A->getValue();
368 unsigned MinVLen = 0;
370 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
373 if (!errorToBool(ISAInfo.takeError()))
374 MinVLen = (*ISAInfo)->getMinVLen();
379 if (Val ==
"zvl" && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
381 }
else if (!Val.getAsInteger(10, Bits)) {
384 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
385 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
391 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
393 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
395 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
396 }
else if (Val !=
"scalable") {
398 D.
Diag(diag::err_drv_unsupported_option_argument)
399 << A->getSpelling() << Val;
404void Flang::AddX86_64TargetArgs(
const ArgList &Args,
405 ArgStringList &CmdArgs)
const {
406 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
407 StringRef
Value = A->getValue();
409 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
410 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
413 << A->getSpelling() <<
Value;
419 ArgStringList &CmdArgs) {
423 ver = vt.getMajor() * 10000000 + vt.getMinor().value_or(0) * 100000 +
424 vt.getSubminor().value_or(0);
425 CmdArgs.push_back(Args.MakeArgString(
"-D_MSC_VER=" + Twine(ver / 100000)));
426 CmdArgs.push_back(Args.MakeArgString(
"-D_MSC_FULL_VER=" + Twine(ver)));
427 CmdArgs.push_back(Args.MakeArgString(
"-D_WIN32"));
429 const llvm::Triple &triple = TC.
getTriple();
430 if (triple.isAArch64()) {
431 CmdArgs.push_back(
"-D_M_ARM64=1");
432 }
else if (triple.isX86() && triple.isArch32Bit()) {
433 CmdArgs.push_back(
"-D_M_IX86=600");
434 }
else if (triple.isX86() && triple.isArch64Bit()) {
435 CmdArgs.push_back(
"-D_M_X64=100");
438 "Flang on Windows only supports X86_32, X86_64 and AArch64");
443 ArgStringList &CmdArgs) {
444 assert(TC.
getTriple().isKnownWindowsMSVCEnvironment() &&
445 "can only add VS runtime library on Windows!");
452 CmdArgs.push_back(Args.MakeArgString(
455 unsigned RTOptionID = options::OPT__SLASH_MT;
456 if (
auto *rtl = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
457 RTOptionID = llvm::StringSwitch<unsigned>(rtl->getValue())
458 .Case(
"static", options::OPT__SLASH_MT)
459 .Case(
"static_dbg", options::OPT__SLASH_MTd)
460 .Case(
"dll", options::OPT__SLASH_MD)
461 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
462 .Default(options::OPT__SLASH_MT);
464 switch (RTOptionID) {
465 case options::OPT__SLASH_MT:
466 CmdArgs.push_back(
"-D_MT");
467 CmdArgs.push_back(
"--dependent-lib=libcmt");
468 CmdArgs.push_back(
"--dependent-lib=flang_rt.runtime.static.lib");
470 case options::OPT__SLASH_MTd:
471 CmdArgs.push_back(
"-D_MT");
472 CmdArgs.push_back(
"-D_DEBUG");
473 CmdArgs.push_back(
"--dependent-lib=libcmtd");
474 CmdArgs.push_back(
"--dependent-lib=flang_rt.runtime.static_dbg.lib");
476 case options::OPT__SLASH_MD:
477 CmdArgs.push_back(
"-D_MT");
478 CmdArgs.push_back(
"-D_DLL");
479 CmdArgs.push_back(
"--dependent-lib=msvcrt");
480 CmdArgs.push_back(
"--dependent-lib=flang_rt.runtime.dynamic.lib");
482 case options::OPT__SLASH_MDd:
483 CmdArgs.push_back(
"-D_MT");
484 CmdArgs.push_back(
"-D_DEBUG");
485 CmdArgs.push_back(
"-D_DLL");
486 CmdArgs.push_back(
"--dependent-lib=msvcrtd");
487 CmdArgs.push_back(
"--dependent-lib=flang_rt.runtime.dynamic_dbg.lib");
492void Flang::AddAMDGPUTargetArgs(
const ArgList &Args,
493 ArgStringList &CmdArgs)
const {
494 if (Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
495 StringRef Val = A->getValue();
496 CmdArgs.push_back(Args.MakeArgString(
"-mcode-object-version=" + Val));
497 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
499 Args.MakeArgString(
"--amdhsa-code-object-version=" + Val));
506void Flang::addTargetOptions(
const ArgList &Args,
507 ArgStringList &CmdArgs)
const {
514 CmdArgs.push_back(
"-target-cpu");
515 CmdArgs.push_back(Args.MakeArgString(CPU));
525 case llvm::Triple::aarch64:
527 AddAArch64TargetArgs(Args, CmdArgs);
530 case llvm::Triple::r600:
531 case llvm::Triple::amdgcn:
533 AddAMDGPUTargetArgs(Args, CmdArgs);
535 case llvm::Triple::riscv64:
537 AddRISCVTargetArgs(Args, CmdArgs);
539 case llvm::Triple::x86_64:
541 AddX86_64TargetArgs(Args, CmdArgs);
543 case llvm::Triple::ppc:
544 case llvm::Triple::ppc64:
545 case llvm::Triple::ppc64le:
546 AddPPCTargetArgs(Args, CmdArgs);
548 case llvm::Triple::loongarch64:
550 AddLoongArch64TargetArgs(Args, CmdArgs);
554 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
555 StringRef Name = A->getValue();
556 if (Name ==
"SVML") {
557 if (Triple.getArch() != llvm::Triple::x86 &&
558 Triple.getArch() != llvm::Triple::x86_64)
559 D.
Diag(diag::err_drv_unsupported_opt_for_target)
560 << Name << Triple.getArchName();
561 }
else if (Name ==
"AMDLIBM") {
562 if (Triple.getArch() != llvm::Triple::x86 &&
563 Triple.getArch() != llvm::Triple::x86_64)
564 D.
Diag(diag::err_drv_unsupported_opt_for_target)
565 << Name << Triple.getArchName();
566 }
else if (Name ==
"libmvec") {
567 if (Triple.getArch() != llvm::Triple::x86 &&
568 Triple.getArch() != llvm::Triple::x86_64 &&
569 Triple.getArch() != llvm::Triple::aarch64 &&
570 Triple.getArch() != llvm::Triple::aarch64_be)
571 D.
Diag(diag::err_drv_unsupported_opt_for_target)
572 << Name << Triple.getArchName();
573 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
574 if (Triple.getArch() != llvm::Triple::aarch64 &&
575 Triple.getArch() != llvm::Triple::aarch64_be)
576 D.
Diag(diag::err_drv_unsupported_opt_for_target)
577 << Name << Triple.getArchName();
580 if (Triple.isOSDarwin()) {
583 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
584 if (A->getValue() == StringRef{
"Accelerate"}) {
585 CmdArgs.push_back(
"-framework");
586 CmdArgs.push_back(
"Accelerate");
590 A->render(Args, CmdArgs);
593 if (Triple.isKnownWindowsMSVCEnvironment()) {
599 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
600 CmdArgs.push_back(
"-tune-cpu");
601 if (A->getValue() == StringRef{
"native"})
602 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
604 CmdArgs.push_back(A->getValue());
607 Args.addAllArgs(CmdArgs,
608 {options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
609 options::OPT_fatomic_ignore_denormal_mode,
610 options::OPT_fno_atomic_ignore_denormal_mode,
611 options::OPT_fatomic_fine_grained_memory,
612 options::OPT_fno_atomic_fine_grained_memory,
613 options::OPT_fatomic_remote_memory,
614 options::OPT_fno_atomic_remote_memory,
615 options::OPT_munsafe_fp_atomics});
618void Flang::addOffloadOptions(Compilation &
C,
const InputInfoList &Inputs,
619 const JobAction &JA,
const ArgList &Args,
620 ArgStringList &CmdArgs)
const {
633 for (
size_t i = 1; i < Inputs.size(); ++i) {
634 if (Inputs[i].
getType() == types::TY_Nothing) {
636 }
else if (IsHostOffloadingAction) {
638 Args.MakeArgString(
"-fembed-offload-object=" +
640 }
else if (IsOpenMPDevice) {
641 if (Inputs[i].getFilename()) {
642 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
643 CmdArgs.push_back(Args.MakeArgString(Inputs[i].getFilename()));
645 llvm_unreachable(
"missing openmp host-ir file for device offloading");
649 "unexpectedly given multiple inputs or given unknown input");
653 if (IsOpenMPDevice) {
656 CmdArgs.push_back(
"-fopenmp-is-target-device");
659 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
660 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
661 options::OPT_fno_openmp_target_debug,
false))
662 CmdArgs.push_back(
"-fopenmp-target-debug");
666 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
667 options::OPT_fno_openmp_assume_teams_oversubscription,
669 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
670 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
671 options::OPT_fno_openmp_assume_threads_oversubscription,
673 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
674 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
675 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
676 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
677 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
678 if (!Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
680 CmdArgs.push_back(
"-nogpulib");
687 ArgStringList &CmdArgs) {
688 StringRef FPContract;
689 bool HonorINFs =
true;
690 bool HonorNaNs =
true;
691 bool ApproxFunc =
false;
692 bool SignedZeros =
true;
693 bool AssociativeMath =
false;
694 bool ReciprocalMath =
false;
696 StringRef LastComplexRangeOption;
699 if (
const Arg *A = Args.getLastArg(options::OPT_ffp_contract)) {
700 const StringRef Val = A->getValue();
701 if (Val ==
"fast" || Val ==
"off") {
703 }
else if (Val ==
"on") {
706 D.
Diag(diag::warn_drv_unsupported_option_for_flang)
707 << Val << A->getOption().getName() <<
"off";
712 D.
Diag(diag::err_drv_unsupported_option_argument)
713 << A->getSpelling() << Val;
716 for (
const Arg *A : Args) {
717 auto optId = A->getOption().getID();
723 case options::OPT_fcomplex_arithmetic_EQ: {
725 StringRef Val = A->getValue();
728 else if (Val ==
"improved")
730 else if (Val ==
"basic")
733 D.
Diag(diag::err_drv_unsupported_option_argument)
734 << A->getSpelling() << Val;
738 setComplexRange(D, Args.MakeArgString(A->getSpelling() + Val), NewRange,
739 LastComplexRangeOption, Range);
742 case options::OPT_fhonor_infinities:
745 case options::OPT_fno_honor_infinities:
748 case options::OPT_fhonor_nans:
751 case options::OPT_fno_honor_nans:
754 case options::OPT_fapprox_func:
757 case options::OPT_fno_approx_func:
760 case options::OPT_fsigned_zeros:
763 case options::OPT_fno_signed_zeros:
766 case options::OPT_fassociative_math:
767 AssociativeMath =
true;
769 case options::OPT_fno_associative_math:
770 AssociativeMath =
false;
772 case options::OPT_freciprocal_math:
773 ReciprocalMath =
true;
775 case options::OPT_fno_reciprocal_math:
776 ReciprocalMath =
false;
778 case options::OPT_Ofast:
780 case options::OPT_ffast_math:
783 AssociativeMath =
true;
784 ReciprocalMath =
true;
790 LastComplexRangeOption, Range);
792 case options::OPT_fno_fast_math:
795 AssociativeMath =
false;
796 ReciprocalMath =
false;
802 if (FPContract ==
"fast")
806 LastComplexRangeOption, Range);
816 CmdArgs.push_back(Args.MakeArgString(
"-mrecip=" + Recip));
820 CmdArgs.push_back(Args.MakeArgString(ComplexRangeStr));
821 CmdArgs.push_back(Args.MakeArgString(
"-fcomplex-arithmetic=" +
825 if (Args.hasArg(options::OPT_fno_fast_real_mod))
826 CmdArgs.push_back(
"-fno-fast-real-mod");
828 if (!HonorINFs && !HonorNaNs && AssociativeMath && ReciprocalMath &&
829 ApproxFunc && !SignedZeros &&
830 (FPContract ==
"fast" || FPContract.empty())) {
831 CmdArgs.push_back(
"-ffast-math");
835 if (!FPContract.empty())
836 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
839 CmdArgs.push_back(
"-menable-no-infs");
842 CmdArgs.push_back(
"-menable-no-nans");
845 CmdArgs.push_back(
"-fapprox-func");
848 CmdArgs.push_back(
"-fno-signed-zeros");
850 if (AssociativeMath && !SignedZeros)
851 CmdArgs.push_back(
"-mreassociate");
854 CmdArgs.push_back(
"-freciprocal-math");
859 StringRef Format =
"yaml";
860 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
861 Format = A->getValue();
863 CmdArgs.push_back(
"-opt-record-file");
865 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
867 CmdArgs.push_back(A->getValue());
871 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
872 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
873 F = FinalOutput->getValue();
885 llvm::sys::path::replace_extension(F, Extension);
886 CmdArgs.push_back(Args.MakeArgString(F));
890 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
891 CmdArgs.push_back(
"-opt-record-passes");
892 CmdArgs.push_back(A->getValue());
895 if (!Format.empty()) {
896 CmdArgs.push_back(
"-opt-record-format");
897 CmdArgs.push_back(Format.data());
903 const ArgList &Args,
const char *LinkingOutput)
const {
906 const std::string &TripleStr = Triple.getTriple();
909 ArgStringList CmdArgs;
912 CmdArgs.push_back(
"-fc1");
915 CmdArgs.push_back(
"-triple");
916 CmdArgs.push_back(Args.MakeArgString(TripleStr));
919 CmdArgs.push_back(
"-E");
920 if (Args.getLastArg(options::OPT_dM)) {
921 CmdArgs.push_back(
"-dM");
924 if (JA.
getType() == types::TY_Nothing) {
925 CmdArgs.push_back(
"-fsyntax-only");
926 }
else if (JA.
getType() == types::TY_AST) {
927 CmdArgs.push_back(
"-emit-ast");
928 }
else if (JA.
getType() == types::TY_LLVM_IR ||
929 JA.
getType() == types::TY_LTO_IR) {
930 CmdArgs.push_back(
"-emit-llvm");
931 }
else if (JA.
getType() == types::TY_LLVM_BC ||
932 JA.
getType() == types::TY_LTO_BC) {
933 CmdArgs.push_back(
"-emit-llvm-bc");
934 }
else if (JA.
getType() == types::TY_PP_Asm) {
935 CmdArgs.push_back(
"-S");
937 assert(
false &&
"Unexpected output type!");
940 CmdArgs.push_back(
"-emit-obj");
945 assert(
false &&
"Unexpected action class for Flang tool.");
954 addPreprocessingOptions(Args, CmdArgs);
956 addFortranDialectOptions(Args, CmdArgs);
962 bool isAtemporaryPreprocessedFile =
966 if (InputType == types::TY_PP_Fortran && isAtemporaryPreprocessedFile &&
967 !Args.getLastArg(options::OPT_ffixed_form, options::OPT_ffree_form))
968 CmdArgs.push_back(
"-ffixed-form");
972 addLTOOptions(Args, CmdArgs);
975 addPicOptions(Args, CmdArgs);
981 addTargetOptions(Args, CmdArgs);
983 llvm::Reloc::Model RelocationModel =
986 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
989 addCodegenOptions(Args, CmdArgs);
992 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
999 addDebugOptions(Args, JA, Output, Input, CmdArgs);
1003 Args.AddLastArg(CmdArgs, options::OPT_w);
1007 CmdArgs, {options::OPT_fprofile_generate, options::OPT_fprofile_use_EQ});
1011 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
1012 options::OPT_fno_openmp,
false) &&
1019 CmdArgs.push_back(
"-fopenmp");
1020 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
1022 if (Args.hasArg(options::OPT_fopenmp_force_usm))
1023 CmdArgs.push_back(
"-fopenmp-force-usm");
1024 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
1025 options::OPT_fno_openmp_simd);
1036 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
1037 D.
Diag(diag::warn_drv_unsupported_openmp_library)
1038 << A->getSpelling() << A->getValue();
1042 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
1043 options::OPT_fno_openmp_simd);
1047 CmdArgs.push_back(
"-resource-dir");
1051 addOffloadOptions(
C, Inputs, JA, Args, CmdArgs);
1054 Args.AddAllArgValues(CmdArgs, options::OPT_Xflang);
1059 const char *FPKeepKindStr =
nullptr;
1060 switch (FPKeepKind) {
1062 FPKeepKindStr =
"-mframe-pointer=none";
1065 FPKeepKindStr =
"-mframe-pointer=reserved";
1068 FPKeepKindStr =
"-mframe-pointer=non-leaf";
1071 FPKeepKindStr =
"-mframe-pointer=all";
1074 assert(FPKeepKindStr &&
"unknown FramePointerKind");
1075 CmdArgs.push_back(FPKeepKindStr);
1079 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
1081 A->render(Args, CmdArgs);
1084 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
1086 A->render(Args, CmdArgs);
1090 for (
const Arg *A : Args.filtered(options::OPT_flang_ignored_w_Group)) {
1092 D.
Diag(diag::warn_drv_unsupported_diag_option_for_flang)
1093 << A->getOption().getName();
1097 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1098 if (A->getOption().matches(options::OPT_O4)) {
1099 CmdArgs.push_back(
"-O3");
1100 D.
Diag(diag::warn_O4_is_O3);
1101 }
else if (A->getOption().matches(options::OPT_Ofast)) {
1102 CmdArgs.push_back(
"-O3");
1103 D.
Diag(diag::warn_drv_deprecated_arg_ofast_for_flang);
1105 A->render(Args, CmdArgs);
1113 CmdArgs.push_back(
"-o");
1117 if (Args.getLastArg(options::OPT_save_temps_EQ))
1118 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
1122 bool FRecordCmdLine =
false;
1123 bool GRecordCmdLine =
false;
1126 if (FRecordCmdLine) {
1127 CmdArgs.push_back(
"-record-command-line");
1128 CmdArgs.push_back(CmdLine);
1131 CmdArgs.push_back(
"-dwarf-debug-flags");
1132 CmdArgs.push_back(CmdLine);
1140 FrontendInputs = {};
1142 for (
const InputInfo &Input : FrontendInputs) {
1149 const char *Exec = Args.MakeArgString(D.
GetProgramPath(
"flang", TC));
1150 C.addCommand(std::make_unique<Command>(JA, *
this,
1152 Exec, CmdArgs, Inputs, Output));
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
clang::CodeGenOptions::FramePointerKind getFramePointerKind(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
static void processVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static void addVSDefines(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static bool shouldLoopVersion(const ArgList &Args)
@C shouldLoopVersion
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
static void addFloatingPointOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
ComplexRangeKind
Controls the various implementations for complex multiplication and.
@ CX_Full
Implementation of complex division and multiplication using a call to runtime library functions(gener...
@ CX_Basic
Implementation of complex division and multiplication using algebraic formulas at source precision.
@ CX_None
No range rule is enabled.
@ CX_Improved
Implementation of complex division offering an improved handling for overflow in intermediate calcula...
types::ID getType() const
bool isHostOffloading(unsigned int OKind) const
Check if this action have any offload kinds.
bool isDeviceOffloading(OffloadKind OKind) const
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
DiagnosticsEngine & getDiags() const
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
DiagnosticBuilder Diag(unsigned DiagID) const
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
std::string ResourceDir
The path to the compiler resource directory.
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed,...
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
const char * getTypeTempSuffix(ID Id, bool CLStyle=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type,...
LTOKind
Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.
SmallVector< InputInfo, 4 > InputInfoList
bool willEmitRemarks(const llvm::opt::ArgList &Args)
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
const FunctionProtoType * T
bool(*)(llvm::ArrayRef< const char * >, llvm::raw_ostream &, llvm::raw_ostream &, bool, bool) Driver
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
static constexpr ResponseFileSupport AtFileUTF8()