15#include "llvm/Frontend/Debug/Options.h"
16#include "llvm/Support/FileSystem.h"
17#include "llvm/Support/Path.h"
18#include "llvm/TargetParser/Host.h"
19#include "llvm/TargetParser/RISCVISAInfo.h"
20#include "llvm/TargetParser/RISCVTargetParser.h"
31 ArgStringList &CmdArgs) {
32 CmdArgs.push_back(
"-x");
37void Flang::addFortranDialectOptions(
const ArgList &Args,
38 ArgStringList &CmdArgs)
const {
39 Args.addAllArgs(CmdArgs, {options::OPT_ffixed_form,
40 options::OPT_ffree_form,
41 options::OPT_ffixed_line_length_EQ,
42 options::OPT_fopenacc,
43 options::OPT_finput_charset_EQ,
44 options::OPT_fimplicit_none,
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_fno_save_main_program});
65void Flang::addPreprocessingOptions(
const ArgList &Args,
66 ArgStringList &CmdArgs)
const {
67 Args.addAllArgs(CmdArgs,
68 {options::OPT_P, options::OPT_D, options::OPT_U,
69 options::OPT_I, options::OPT_cpp, options::OPT_nocpp});
90 const Arg *LoopVersioningArg = Args.getLastArg(
91 options::OPT_Ofast, options::OPT_O, options::OPT_O4,
92 options::OPT_floop_versioning, options::OPT_fno_loop_versioning);
93 if (!LoopVersioningArg)
96 if (LoopVersioningArg->getOption().matches(options::OPT_fno_loop_versioning))
99 if (LoopVersioningArg->getOption().matches(options::OPT_floop_versioning))
102 if (LoopVersioningArg->getOption().matches(options::OPT_Ofast) ||
103 LoopVersioningArg->getOption().matches(options::OPT_O4))
106 if (LoopVersioningArg->getOption().matches(options::OPT_O)) {
107 StringRef S(LoopVersioningArg->getValue());
108 unsigned OptLevel = 0;
111 if (S.getAsInteger(10, OptLevel))
117 llvm_unreachable(
"We should not end up here");
121void Flang::addOtherOptions(
const ArgList &Args, ArgStringList &CmdArgs)
const {
122 Args.addAllArgs(CmdArgs,
123 {options::OPT_module_dir, options::OPT_fdebug_module_writer,
124 options::OPT_fintrinsic_modules_path, options::OPT_pedantic,
125 options::OPT_std_EQ, options::OPT_W_Joined,
126 options::OPT_fconvert_EQ, options::OPT_fpass_plugin_EQ,
127 options::OPT_funderscoring, options::OPT_fno_underscoring,
128 options::OPT_funsigned, options::OPT_fno_unsigned});
130 llvm::codegenoptions::DebugInfoKind DebugInfoKind;
131 if (Args.hasArg(options::OPT_gN_Group)) {
132 Arg *gNArg = Args.getLastArg(options::OPT_gN_Group);
134 }
else if (Args.hasArg(options::OPT_g_Flag)) {
135 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
137 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
142void Flang::addCodegenOptions(
const ArgList &Args,
143 ArgStringList &CmdArgs)
const {
145 Args.getLastArg(options::OPT_Ofast, options::OPT_fstack_arrays,
146 options::OPT_fno_stack_arrays);
148 !stackArrays->getOption().matches(options::OPT_fno_stack_arrays))
149 CmdArgs.push_back(
"-fstack-arrays");
152 CmdArgs.push_back(
"-fversion-loops-for-stride");
154 Args.addAllArgs(CmdArgs,
155 {options::OPT_flang_experimental_hlfir,
156 options::OPT_flang_deprecated_no_hlfir,
157 options::OPT_fno_ppc_native_vec_elem_order,
158 options::OPT_fppc_native_vec_elem_order,
159 options::OPT_finit_global_zero,
160 options::OPT_fno_init_global_zero, options::OPT_ftime_report,
161 options::OPT_ftime_report_EQ, options::OPT_funroll_loops,
162 options::OPT_fno_unroll_loops});
165void Flang::addPicOptions(
const ArgList &Args, ArgStringList &CmdArgs)
const {
168 llvm::Reloc::Model RelocationModel;
171 std::tie(RelocationModel, PICLevel, IsPIE) =
175 CmdArgs.push_back(
"-mrelocation-model");
176 CmdArgs.push_back(RMName);
179 CmdArgs.push_back(
"-pic-level");
180 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
182 CmdArgs.push_back(
"-pic-is-pie");
186void Flang::AddAArch64TargetArgs(
const ArgList &Args,
187 ArgStringList &CmdArgs)
const {
189 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
190 StringRef Val = A->getValue();
192 if (Val ==
"128" || Val ==
"256" || Val ==
"512" || Val ==
"1024" ||
193 Val ==
"2048" || Val ==
"128+" || Val ==
"256+" || Val ==
"512+" ||
194 Val ==
"1024+" || Val ==
"2048+") {
196 if (!Val.consume_back(
"+")) {
197 [[maybe_unused]]
bool Invalid = Val.getAsInteger(10, Bits);
198 assert(!
Invalid &&
"Failed to parse value");
200 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
203 [[maybe_unused]]
bool Invalid = Val.getAsInteger(10, Bits);
204 assert(!
Invalid &&
"Failed to parse value");
206 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
208 }
else if (Val !=
"scalable")
210 D.Diag(diag::err_drv_unsupported_option_argument)
211 << A->getSpelling() << Val;
215void Flang::AddLoongArch64TargetArgs(
const ArgList &Args,
216 ArgStringList &CmdArgs)
const {
219 if (
const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
220 StringRef
V = A->getValue();
222 D.Diag(diag::err_drv_argument_not_allowed_with) <<
"-mabi" <<
V;
226 if (
const Arg *A = Args.getLastArg(options::OPT_mannotate_tablejump,
227 options::OPT_mno_annotate_tablejump)) {
228 if (A->getOption().matches(options::OPT_mannotate_tablejump)) {
229 CmdArgs.push_back(
"-mllvm");
230 CmdArgs.push_back(
"-loongarch-annotate-tablejump");
235void Flang::AddPPCTargetArgs(
const ArgList &Args,
236 ArgStringList &CmdArgs)
const {
238 bool VecExtabi =
false;
240 if (
const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
241 StringRef
V = A->getValue();
242 if (
V ==
"vec-extabi")
244 else if (
V ==
"vec-default")
247 D.Diag(diag::err_drv_unsupported_option_argument)
248 << A->getSpelling() <<
V;
254 D.Diag(diag::err_drv_unsupported_opt_for_target)
255 <<
"-mabi=vec-extabi" <<
T.str();
257 CmdArgs.push_back(
"-mabi=vec-extabi");
261void Flang::AddRISCVTargetArgs(
const ArgList &Args,
262 ArgStringList &CmdArgs)
const {
265 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
266 StringRef Val = A->getValue();
270 unsigned MinVLen = 0;
272 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
275 if (!errorToBool(ISAInfo.takeError()))
276 MinVLen = (*ISAInfo)->getMinVLen();
281 if (Val ==
"zvl" && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
283 }
else if (!Val.getAsInteger(10, Bits)) {
286 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
287 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
293 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
295 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
297 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
298 }
else if (Val !=
"scalable") {
300 D.Diag(diag::err_drv_unsupported_option_argument)
301 << A->getSpelling() << Val;
306void Flang::AddX86_64TargetArgs(
const ArgList &Args,
307 ArgStringList &CmdArgs)
const {
308 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
309 StringRef
Value = A->getValue();
311 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
312 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
315 << A->getSpelling() <<
Value;
321 ArgStringList &CmdArgs) {
325 ver = vt.getMajor() * 10000000 + vt.getMinor().value_or(0) * 100000 +
326 vt.getSubminor().value_or(0);
327 CmdArgs.push_back(Args.MakeArgString(
"-D_MSC_VER=" + Twine(ver / 100000)));
328 CmdArgs.push_back(Args.MakeArgString(
"-D_MSC_FULL_VER=" + Twine(ver)));
329 CmdArgs.push_back(Args.MakeArgString(
"-D_WIN32"));
331 const llvm::Triple &triple = TC.
getTriple();
332 if (triple.isAArch64()) {
333 CmdArgs.push_back(
"-D_M_ARM64=1");
334 }
else if (triple.isX86() && triple.isArch32Bit()) {
335 CmdArgs.push_back(
"-D_M_IX86=600");
336 }
else if (triple.isX86() && triple.isArch64Bit()) {
337 CmdArgs.push_back(
"-D_M_X64=100");
340 "Flang on Windows only supports X86_32, X86_64 and AArch64");
345 ArgStringList &CmdArgs) {
346 assert(TC.
getTriple().isKnownWindowsMSVCEnvironment() &&
347 "can only add VS runtime library on Windows!");
349 if (TC.
getTriple().isKnownWindowsMSVCEnvironment()) {
350 CmdArgs.push_back(Args.MakeArgString(
353 unsigned RTOptionID = options::OPT__SLASH_MT;
354 if (
auto *rtl = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
355 RTOptionID = llvm::StringSwitch<unsigned>(rtl->getValue())
356 .Case(
"static", options::OPT__SLASH_MT)
357 .Case(
"static_dbg", options::OPT__SLASH_MTd)
358 .Case(
"dll", options::OPT__SLASH_MD)
359 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
360 .Default(options::OPT__SLASH_MT);
362 switch (RTOptionID) {
363 case options::OPT__SLASH_MT:
364 CmdArgs.push_back(
"-D_MT");
365 CmdArgs.push_back(
"--dependent-lib=libcmt");
366 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.static.lib");
367 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.static.lib");
369 case options::OPT__SLASH_MTd:
370 CmdArgs.push_back(
"-D_MT");
371 CmdArgs.push_back(
"-D_DEBUG");
372 CmdArgs.push_back(
"--dependent-lib=libcmtd");
373 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.static_dbg.lib");
374 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.static_dbg.lib");
376 case options::OPT__SLASH_MD:
377 CmdArgs.push_back(
"-D_MT");
378 CmdArgs.push_back(
"-D_DLL");
379 CmdArgs.push_back(
"--dependent-lib=msvcrt");
380 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.dynamic.lib");
381 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.dynamic.lib");
383 case options::OPT__SLASH_MDd:
384 CmdArgs.push_back(
"-D_MT");
385 CmdArgs.push_back(
"-D_DEBUG");
386 CmdArgs.push_back(
"-D_DLL");
387 CmdArgs.push_back(
"--dependent-lib=msvcrtd");
388 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.dynamic_dbg.lib");
389 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.dynamic_dbg.lib");
394void Flang::AddAMDGPUTargetArgs(
const ArgList &Args,
395 ArgStringList &CmdArgs)
const {
396 if (Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
397 StringRef Val = A->getValue();
398 CmdArgs.push_back(Args.MakeArgString(
"-mcode-object-version=" + Val));
405void Flang::addTargetOptions(
const ArgList &Args,
406 ArgStringList &CmdArgs)
const {
413 CmdArgs.push_back(
"-target-cpu");
414 CmdArgs.push_back(Args.MakeArgString(CPU));
423 case llvm::Triple::aarch64:
425 AddAArch64TargetArgs(Args, CmdArgs);
428 case llvm::Triple::r600:
429 case llvm::Triple::amdgcn:
431 AddAMDGPUTargetArgs(Args, CmdArgs);
433 case llvm::Triple::riscv64:
435 AddRISCVTargetArgs(Args, CmdArgs);
437 case llvm::Triple::x86_64:
439 AddX86_64TargetArgs(Args, CmdArgs);
441 case llvm::Triple::ppc:
442 case llvm::Triple::ppc64:
443 case llvm::Triple::ppc64le:
444 AddPPCTargetArgs(Args, CmdArgs);
446 case llvm::Triple::loongarch64:
448 AddLoongArch64TargetArgs(Args, CmdArgs);
452 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
453 StringRef Name = A->getValue();
454 if (Name ==
"SVML") {
455 if (Triple.getArch() != llvm::Triple::x86 &&
456 Triple.getArch() != llvm::Triple::x86_64)
457 D.Diag(diag::err_drv_unsupported_opt_for_target)
458 << Name << Triple.getArchName();
459 }
else if (Name ==
"LIBMVEC-X86") {
460 if (Triple.getArch() != llvm::Triple::x86 &&
461 Triple.getArch() != llvm::Triple::x86_64)
462 D.Diag(diag::err_drv_unsupported_opt_for_target)
463 << Name << Triple.getArchName();
464 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
465 if (Triple.getArch() != llvm::Triple::aarch64 &&
466 Triple.getArch() != llvm::Triple::aarch64_be)
467 D.Diag(diag::err_drv_unsupported_opt_for_target)
468 << Name << Triple.getArchName();
471 if (Triple.isOSDarwin()) {
474 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
475 if (A->getValue() == StringRef{
"Accelerate"}) {
476 CmdArgs.push_back(
"-framework");
477 CmdArgs.push_back(
"Accelerate");
481 A->render(Args, CmdArgs);
484 if (Triple.isKnownWindowsMSVCEnvironment()) {
490 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
491 CmdArgs.push_back(
"-tune-cpu");
492 if (A->getValue() == StringRef{
"native"})
493 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
495 CmdArgs.push_back(A->getValue());
500 const JobAction &JA,
const ArgList &Args,
501 ArgStringList &CmdArgs)
const {
514 for (
size_t i = 1; i < Inputs.size(); ++i) {
515 if (Inputs[i].getType() == types::TY_Nothing) {
517 }
else if (IsHostOffloadingAction) {
519 Args.MakeArgString(
"-fembed-offload-object=" +
521 }
else if (IsOpenMPDevice) {
522 if (Inputs[i].getFilename()) {
523 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
524 CmdArgs.push_back(Args.MakeArgString(Inputs[i].getFilename()));
526 llvm_unreachable(
"missing openmp host-ir file for device offloading");
530 "unexpectedly given multiple inputs or given unknown input");
534 if (IsOpenMPDevice) {
537 CmdArgs.push_back(
"-fopenmp-is-target-device");
540 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
541 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
542 options::OPT_fno_openmp_target_debug,
false))
543 CmdArgs.push_back(
"-fopenmp-target-debug");
547 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
548 options::OPT_fno_openmp_assume_teams_oversubscription,
550 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
551 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
552 options::OPT_fno_openmp_assume_threads_oversubscription,
554 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
555 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
556 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
557 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
558 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
559 if (Args.hasArg(options::OPT_nogpulib))
560 CmdArgs.push_back(
"-nogpulib");
567 ArgStringList &CmdArgs) {
568 StringRef FPContract;
569 bool HonorINFs =
true;
570 bool HonorNaNs =
true;
571 bool ApproxFunc =
false;
572 bool SignedZeros =
true;
573 bool AssociativeMath =
false;
574 bool ReciprocalMath =
false;
576 if (
const Arg *A = Args.getLastArg(options::OPT_ffp_contract)) {
577 const StringRef Val = A->getValue();
578 if (Val ==
"fast" || Val ==
"off") {
580 }
else if (Val ==
"on") {
583 D.Diag(diag::warn_drv_unsupported_option_for_flang)
584 << Val << A->getOption().getName() <<
"off";
589 D.Diag(diag::err_drv_unsupported_option_argument)
590 << A->getSpelling() << Val;
593 for (
const Arg *A : Args) {
594 auto optId = A->getOption().
getID();
600 case options::OPT_fhonor_infinities:
603 case options::OPT_fno_honor_infinities:
606 case options::OPT_fhonor_nans:
609 case options::OPT_fno_honor_nans:
612 case options::OPT_fapprox_func:
615 case options::OPT_fno_approx_func:
618 case options::OPT_fsigned_zeros:
621 case options::OPT_fno_signed_zeros:
624 case options::OPT_fassociative_math:
625 AssociativeMath =
true;
627 case options::OPT_fno_associative_math:
628 AssociativeMath =
false;
630 case options::OPT_freciprocal_math:
631 ReciprocalMath =
true;
633 case options::OPT_fno_reciprocal_math:
634 ReciprocalMath =
false;
636 case options::OPT_Ofast:
638 case options::OPT_ffast_math:
641 AssociativeMath =
true;
642 ReciprocalMath =
true;
647 case options::OPT_fno_fast_math:
650 AssociativeMath =
false;
651 ReciprocalMath =
false;
657 if (FPContract ==
"fast")
666 if (!HonorINFs && !HonorNaNs && AssociativeMath && ReciprocalMath &&
667 ApproxFunc && !SignedZeros &&
668 (FPContract ==
"fast" || FPContract.empty())) {
669 CmdArgs.push_back(
"-ffast-math");
673 if (!FPContract.empty())
674 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
677 CmdArgs.push_back(
"-menable-no-infs");
680 CmdArgs.push_back(
"-menable-no-nans");
683 CmdArgs.push_back(
"-fapprox-func");
686 CmdArgs.push_back(
"-fno-signed-zeros");
688 if (AssociativeMath && !SignedZeros)
689 CmdArgs.push_back(
"-mreassociate");
692 CmdArgs.push_back(
"-freciprocal-math");
697 StringRef Format =
"yaml";
698 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
699 Format = A->getValue();
701 CmdArgs.push_back(
"-opt-record-file");
703 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
705 CmdArgs.push_back(A->getValue());
709 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
710 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
711 F = FinalOutput->getValue();
723 llvm::sys::path::replace_extension(F, Extension);
724 CmdArgs.push_back(Args.MakeArgString(F));
728 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
729 CmdArgs.push_back(
"-opt-record-passes");
730 CmdArgs.push_back(A->getValue());
733 if (!Format.empty()) {
734 CmdArgs.push_back(
"-opt-record-format");
735 CmdArgs.push_back(Format.data());
741 const ArgList &Args,
const char *LinkingOutput)
const {
744 const std::string &TripleStr = Triple.getTriple();
747 ArgStringList CmdArgs;
751 CmdArgs.push_back(
"-fc1");
754 CmdArgs.push_back(
"-triple");
755 CmdArgs.push_back(Args.MakeArgString(TripleStr));
757 if (isa<PreprocessJobAction>(JA)) {
758 CmdArgs.push_back(
"-E");
759 if (Args.getLastArg(options::OPT_dM)) {
760 CmdArgs.push_back(
"-dM");
762 }
else if (isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) {
763 if (JA.
getType() == types::TY_Nothing) {
764 CmdArgs.push_back(
"-fsyntax-only");
765 }
else if (JA.
getType() == types::TY_AST) {
766 CmdArgs.push_back(
"-emit-ast");
767 }
else if (JA.
getType() == types::TY_LLVM_IR ||
768 JA.
getType() == types::TY_LTO_IR) {
769 CmdArgs.push_back(
"-emit-llvm");
770 }
else if (JA.
getType() == types::TY_LLVM_BC ||
771 JA.
getType() == types::TY_LTO_BC) {
772 CmdArgs.push_back(
"-emit-llvm-bc");
773 }
else if (JA.
getType() == types::TY_PP_Asm) {
774 CmdArgs.push_back(
"-S");
776 assert(
false &&
"Unexpected output type!");
778 }
else if (isa<AssembleJobAction>(JA)) {
779 CmdArgs.push_back(
"-emit-obj");
780 }
else if (isa<PrecompileJobAction>(JA)) {
784 assert(
false &&
"Unexpected action class for Flang tool.");
793 addPreprocessingOptions(Args, CmdArgs);
795 addFortranDialectOptions(Args, CmdArgs);
800 if (InputType == types::TY_PP_Fortran &&
801 !Args.getLastArg(options::OPT_ffixed_form, options::OPT_ffree_form))
802 CmdArgs.push_back(
"-ffixed-form");
810 CmdArgs.push_back(
"-flto=full");
814 "the option '-flto=thin' is a work in progress"));
815 CmdArgs.push_back(
"-flto=thin");
819 addPicOptions(Args, CmdArgs);
825 addTargetOptions(Args, CmdArgs);
827 llvm::Reloc::Model RelocationModel =
830 addMCModel(
D, Args, Triple, RelocationModel, CmdArgs);
833 addCodegenOptions(Args, CmdArgs);
836 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
843 addOtherOptions(Args, CmdArgs);
847 Args.AddLastArg(CmdArgs, options::OPT_w);
851 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
852 options::OPT_fno_openmp,
false) &&
855 switch (
D.getOpenMPRuntime(Args)) {
859 CmdArgs.push_back(
"-fopenmp");
860 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
862 if (Args.hasArg(options::OPT_fopenmp_force_usm))
863 CmdArgs.push_back(
"-fopenmp-force-usm");
866 D.Diag(diag::warn_openmp_experimental);
877 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
878 D.Diag(diag::warn_drv_unsupported_openmp_library)
879 << A->getSpelling() << A->getValue();
885 CmdArgs.push_back(
"-resource-dir");
886 CmdArgs.push_back(
D.ResourceDir.c_str());
889 addOffloadOptions(
C, Inputs, JA, Args, CmdArgs);
892 Args.AddAllArgValues(CmdArgs, options::OPT_Xflang);
897 const char *FPKeepKindStr =
nullptr;
898 switch (FPKeepKind) {
900 FPKeepKindStr =
"-mframe-pointer=none";
903 FPKeepKindStr =
"-mframe-pointer=reserved";
906 FPKeepKindStr =
"-mframe-pointer=non-leaf";
909 FPKeepKindStr =
"-mframe-pointer=all";
912 assert(FPKeepKindStr &&
"unknown FramePointerKind");
913 CmdArgs.push_back(FPKeepKindStr);
917 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
919 A->render(Args, CmdArgs);
922 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
924 A->render(Args, CmdArgs);
928 for (
const Arg *A : Args.filtered(options::OPT_flang_ignored_w_Group)) {
930 D.Diag(diag::warn_drv_unsupported_diag_option_for_flang)
931 << A->getOption().getName();
935 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
936 if (A->getOption().matches(options::OPT_O4)) {
937 CmdArgs.push_back(
"-O3");
938 D.Diag(diag::warn_O4_is_O3);
939 }
else if (A->getOption().matches(options::OPT_Ofast)) {
940 CmdArgs.push_back(
"-O3");
941 D.Diag(diag::warn_drv_deprecated_arg_ofast_for_flang);
943 A->render(Args, CmdArgs);
951 CmdArgs.push_back(
"-o");
955 if (Args.getLastArg(options::OPT_save_temps_EQ))
956 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
960 bool FRecordCmdLine =
false;
961 bool GRecordCmdLine =
false;
964 if (FRecordCmdLine) {
965 CmdArgs.push_back(
"-record-command-line");
966 CmdArgs.push_back(CmdLine);
969 CmdArgs.push_back(
"-dwarf-debug-flags");
970 CmdArgs.push_back(CmdLine);
980 for (
const InputInfo &Input : FrontendInputs) {
987 const char *Exec = Args.MakeArgString(
D.GetProgramPath(
"flang", TC));
988 C.addCommand(std::make_unique<Command>(JA, *
this,
990 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)
Concrete class used by the front-end to report problems and issues.
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.
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...
DiagnosticBuilder Diag(unsigned DiagID) const
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
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.
LTOKind
Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.
bool willEmitRemarks(const llvm::opt::ArgList &Args)
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T
static constexpr ResponseFileSupport AtFileUTF8()