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});
64void Flang::addPreprocessingOptions(
const ArgList &Args,
65 ArgStringList &CmdArgs)
const {
66 Args.addAllArgs(CmdArgs,
67 {options::OPT_P, options::OPT_D, options::OPT_U,
68 options::OPT_I, options::OPT_cpp, options::OPT_nocpp});
89 const Arg *LoopVersioningArg = Args.getLastArg(
90 options::OPT_Ofast, options::OPT_O, options::OPT_O4,
91 options::OPT_floop_versioning, options::OPT_fno_loop_versioning);
92 if (!LoopVersioningArg)
95 if (LoopVersioningArg->getOption().matches(options::OPT_fno_loop_versioning))
98 if (LoopVersioningArg->getOption().matches(options::OPT_floop_versioning))
101 if (LoopVersioningArg->getOption().matches(options::OPT_Ofast) ||
102 LoopVersioningArg->getOption().matches(options::OPT_O4))
105 if (LoopVersioningArg->getOption().matches(options::OPT_O)) {
106 StringRef S(LoopVersioningArg->getValue());
107 unsigned OptLevel = 0;
110 if (S.getAsInteger(10, OptLevel))
116 llvm_unreachable(
"We should not end up here");
120void Flang::addOtherOptions(
const ArgList &Args, ArgStringList &CmdArgs)
const {
121 Args.addAllArgs(CmdArgs,
122 {options::OPT_module_dir, options::OPT_fdebug_module_writer,
123 options::OPT_fintrinsic_modules_path, options::OPT_pedantic,
124 options::OPT_std_EQ, options::OPT_W_Joined,
125 options::OPT_fconvert_EQ, options::OPT_fpass_plugin_EQ,
126 options::OPT_funderscoring, options::OPT_fno_underscoring,
127 options::OPT_funsigned, options::OPT_fno_unsigned});
129 llvm::codegenoptions::DebugInfoKind DebugInfoKind;
130 if (Args.hasArg(options::OPT_gN_Group)) {
131 Arg *gNArg = Args.getLastArg(options::OPT_gN_Group);
133 }
else if (Args.hasArg(options::OPT_g_Flag)) {
134 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
136 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
141void Flang::addCodegenOptions(
const ArgList &Args,
142 ArgStringList &CmdArgs)
const {
144 Args.getLastArg(options::OPT_Ofast, options::OPT_fstack_arrays,
145 options::OPT_fno_stack_arrays);
147 !stackArrays->getOption().matches(options::OPT_fno_stack_arrays))
148 CmdArgs.push_back(
"-fstack-arrays");
151 CmdArgs.push_back(
"-fversion-loops-for-stride");
153 Args.addAllArgs(CmdArgs,
154 {options::OPT_flang_experimental_hlfir,
155 options::OPT_flang_deprecated_no_hlfir,
156 options::OPT_fno_ppc_native_vec_elem_order,
157 options::OPT_fppc_native_vec_elem_order,
158 options::OPT_ftime_report, options::OPT_ftime_report_EQ,
159 options::OPT_funroll_loops, options::OPT_fno_unroll_loops});
162void Flang::addPicOptions(
const ArgList &Args, ArgStringList &CmdArgs)
const {
165 llvm::Reloc::Model RelocationModel;
168 std::tie(RelocationModel, PICLevel, IsPIE) =
172 CmdArgs.push_back(
"-mrelocation-model");
173 CmdArgs.push_back(RMName);
176 CmdArgs.push_back(
"-pic-level");
177 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
179 CmdArgs.push_back(
"-pic-is-pie");
183void Flang::AddAArch64TargetArgs(
const ArgList &Args,
184 ArgStringList &CmdArgs)
const {
186 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
187 StringRef Val = A->getValue();
189 if (Val ==
"128" || Val ==
"256" || Val ==
"512" || Val ==
"1024" ||
190 Val ==
"2048" || Val ==
"128+" || Val ==
"256+" || Val ==
"512+" ||
191 Val ==
"1024+" || Val ==
"2048+") {
193 if (!Val.consume_back(
"+")) {
194 [[maybe_unused]]
bool Invalid = Val.getAsInteger(10, Bits);
195 assert(!
Invalid &&
"Failed to parse value");
197 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(Bits / 128)));
200 [[maybe_unused]]
bool Invalid = Val.getAsInteger(10, Bits);
201 assert(!
Invalid &&
"Failed to parse value");
203 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(Bits / 128)));
205 }
else if (Val !=
"scalable")
207 D.Diag(diag::err_drv_unsupported_option_argument)
208 << A->getSpelling() << Val;
212void Flang::AddLoongArch64TargetArgs(
const ArgList &Args,
213 ArgStringList &CmdArgs)
const {
216 if (
const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
217 StringRef
V = A->getValue();
219 D.Diag(diag::err_drv_argument_not_allowed_with) <<
"-mabi" <<
V;
223 if (
const Arg *A = Args.getLastArg(options::OPT_mannotate_tablejump,
224 options::OPT_mno_annotate_tablejump)) {
225 if (A->getOption().matches(options::OPT_mannotate_tablejump)) {
226 CmdArgs.push_back(
"-mllvm");
227 CmdArgs.push_back(
"-loongarch-annotate-tablejump");
232void Flang::AddPPCTargetArgs(
const ArgList &Args,
233 ArgStringList &CmdArgs)
const {
235 bool VecExtabi =
false;
237 if (
const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
238 StringRef
V = A->getValue();
239 if (
V ==
"vec-extabi")
241 else if (
V ==
"vec-default")
244 D.Diag(diag::err_drv_unsupported_option_argument)
245 << A->getSpelling() <<
V;
251 D.Diag(diag::err_drv_unsupported_opt_for_target)
252 <<
"-mabi=vec-extabi" <<
T.str();
254 CmdArgs.push_back(
"-mabi=vec-extabi");
258void Flang::AddRISCVTargetArgs(
const ArgList &Args,
259 ArgStringList &CmdArgs)
const {
262 if (Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {
263 StringRef Val = A->getValue();
267 unsigned MinVLen = 0;
269 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
272 if (!errorToBool(ISAInfo.takeError()))
273 MinVLen = (*ISAInfo)->getMinVLen();
278 if (Val ==
"zvl" && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
280 }
else if (!Val.getAsInteger(10, Bits)) {
283 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
284 Bits > 65536 || !llvm::isPowerOf2_32(Bits))
290 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
292 Args.MakeArgString(
"-mvscale-max=" + llvm::Twine(VScaleMin)));
294 Args.MakeArgString(
"-mvscale-min=" + llvm::Twine(VScaleMin)));
295 }
else if (Val !=
"scalable") {
297 D.Diag(diag::err_drv_unsupported_option_argument)
298 << A->getSpelling() << Val;
303void Flang::AddX86_64TargetArgs(
const ArgList &Args,
304 ArgStringList &CmdArgs)
const {
305 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
306 StringRef
Value = A->getValue();
308 CmdArgs.push_back(Args.MakeArgString(
"-mllvm"));
309 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" +
Value));
312 << A->getSpelling() <<
Value;
318 ArgStringList &CmdArgs) {
322 ver = vt.getMajor() * 10000000 + vt.getMinor().value_or(0) * 100000 +
323 vt.getSubminor().value_or(0);
324 CmdArgs.push_back(Args.MakeArgString(
"-D_MSC_VER=" + Twine(ver / 100000)));
325 CmdArgs.push_back(Args.MakeArgString(
"-D_MSC_FULL_VER=" + Twine(ver)));
326 CmdArgs.push_back(Args.MakeArgString(
"-D_WIN32"));
328 const llvm::Triple &triple = TC.
getTriple();
329 if (triple.isAArch64()) {
330 CmdArgs.push_back(
"-D_M_ARM64=1");
331 }
else if (triple.isX86() && triple.isArch32Bit()) {
332 CmdArgs.push_back(
"-D_M_IX86=600");
333 }
else if (triple.isX86() && triple.isArch64Bit()) {
334 CmdArgs.push_back(
"-D_M_X64=100");
337 "Flang on Windows only supports X86_32, X86_64 and AArch64");
342 ArgStringList &CmdArgs) {
343 assert(TC.
getTriple().isKnownWindowsMSVCEnvironment() &&
344 "can only add VS runtime library on Windows!");
346 if (TC.
getTriple().isKnownWindowsMSVCEnvironment()) {
347 CmdArgs.push_back(Args.MakeArgString(
350 unsigned RTOptionID = options::OPT__SLASH_MT;
351 if (
auto *rtl = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {
352 RTOptionID = llvm::StringSwitch<unsigned>(rtl->getValue())
353 .Case(
"static", options::OPT__SLASH_MT)
354 .Case(
"static_dbg", options::OPT__SLASH_MTd)
355 .Case(
"dll", options::OPT__SLASH_MD)
356 .Case(
"dll_dbg", options::OPT__SLASH_MDd)
357 .Default(options::OPT__SLASH_MT);
359 switch (RTOptionID) {
360 case options::OPT__SLASH_MT:
361 CmdArgs.push_back(
"-D_MT");
362 CmdArgs.push_back(
"--dependent-lib=libcmt");
363 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.static.lib");
364 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.static.lib");
366 case options::OPT__SLASH_MTd:
367 CmdArgs.push_back(
"-D_MT");
368 CmdArgs.push_back(
"-D_DEBUG");
369 CmdArgs.push_back(
"--dependent-lib=libcmtd");
370 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.static_dbg.lib");
371 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.static_dbg.lib");
373 case options::OPT__SLASH_MD:
374 CmdArgs.push_back(
"-D_MT");
375 CmdArgs.push_back(
"-D_DLL");
376 CmdArgs.push_back(
"--dependent-lib=msvcrt");
377 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.dynamic.lib");
378 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.dynamic.lib");
380 case options::OPT__SLASH_MDd:
381 CmdArgs.push_back(
"-D_MT");
382 CmdArgs.push_back(
"-D_DEBUG");
383 CmdArgs.push_back(
"-D_DLL");
384 CmdArgs.push_back(
"--dependent-lib=msvcrtd");
385 CmdArgs.push_back(
"--dependent-lib=FortranRuntime.dynamic_dbg.lib");
386 CmdArgs.push_back(
"--dependent-lib=FortranDecimal.dynamic_dbg.lib");
391void Flang::AddAMDGPUTargetArgs(
const ArgList &Args,
392 ArgStringList &CmdArgs)
const {
393 if (Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {
394 StringRef Val = A->getValue();
395 CmdArgs.push_back(Args.MakeArgString(
"-mcode-object-version=" + Val));
402void Flang::addTargetOptions(
const ArgList &Args,
403 ArgStringList &CmdArgs)
const {
410 CmdArgs.push_back(
"-target-cpu");
411 CmdArgs.push_back(Args.MakeArgString(CPU));
420 case llvm::Triple::aarch64:
422 AddAArch64TargetArgs(Args, CmdArgs);
425 case llvm::Triple::r600:
426 case llvm::Triple::amdgcn:
428 AddAMDGPUTargetArgs(Args, CmdArgs);
430 case llvm::Triple::riscv64:
432 AddRISCVTargetArgs(Args, CmdArgs);
434 case llvm::Triple::x86_64:
436 AddX86_64TargetArgs(Args, CmdArgs);
438 case llvm::Triple::ppc:
439 case llvm::Triple::ppc64:
440 case llvm::Triple::ppc64le:
441 AddPPCTargetArgs(Args, CmdArgs);
443 case llvm::Triple::loongarch64:
445 AddLoongArch64TargetArgs(Args, CmdArgs);
449 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
450 StringRef Name = A->getValue();
451 if (Name ==
"SVML") {
452 if (Triple.getArch() != llvm::Triple::x86 &&
453 Triple.getArch() != llvm::Triple::x86_64)
454 D.Diag(diag::err_drv_unsupported_opt_for_target)
455 << Name << Triple.getArchName();
456 }
else if (Name ==
"LIBMVEC-X86") {
457 if (Triple.getArch() != llvm::Triple::x86 &&
458 Triple.getArch() != llvm::Triple::x86_64)
459 D.Diag(diag::err_drv_unsupported_opt_for_target)
460 << Name << Triple.getArchName();
461 }
else if (Name ==
"SLEEF" || Name ==
"ArmPL") {
462 if (Triple.getArch() != llvm::Triple::aarch64 &&
463 Triple.getArch() != llvm::Triple::aarch64_be)
464 D.Diag(diag::err_drv_unsupported_opt_for_target)
465 << Name << Triple.getArchName();
468 if (Triple.isOSDarwin()) {
471 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
472 if (A->getValue() == StringRef{
"Accelerate"}) {
473 CmdArgs.push_back(
"-framework");
474 CmdArgs.push_back(
"Accelerate");
478 A->render(Args, CmdArgs);
481 if (Triple.isKnownWindowsMSVCEnvironment()) {
487 if (
const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
488 CmdArgs.push_back(
"-tune-cpu");
489 if (A->getValue() == StringRef{
"native"})
490 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
492 CmdArgs.push_back(A->getValue());
497 const JobAction &JA,
const ArgList &Args,
498 ArgStringList &CmdArgs)
const {
511 for (
size_t i = 1; i < Inputs.size(); ++i) {
512 if (Inputs[i].getType() == types::TY_Nothing) {
514 }
else if (IsHostOffloadingAction) {
516 Args.MakeArgString(
"-fembed-offload-object=" +
518 }
else if (IsOpenMPDevice) {
519 if (Inputs[i].getFilename()) {
520 CmdArgs.push_back(
"-fopenmp-host-ir-file-path");
521 CmdArgs.push_back(Args.MakeArgString(Inputs[i].getFilename()));
523 llvm_unreachable(
"missing openmp host-ir file for device offloading");
527 "unexpectedly given multiple inputs or given unknown input");
531 if (IsOpenMPDevice) {
534 CmdArgs.push_back(
"-fopenmp-is-target-device");
537 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);
538 if (Args.hasFlag(options::OPT_fopenmp_target_debug,
539 options::OPT_fno_openmp_target_debug,
false))
540 CmdArgs.push_back(
"-fopenmp-target-debug");
544 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,
545 options::OPT_fno_openmp_assume_teams_oversubscription,
547 CmdArgs.push_back(
"-fopenmp-assume-teams-oversubscription");
548 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,
549 options::OPT_fno_openmp_assume_threads_oversubscription,
551 CmdArgs.push_back(
"-fopenmp-assume-threads-oversubscription");
552 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))
553 CmdArgs.push_back(
"-fopenmp-assume-no-thread-state");
554 if (Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))
555 CmdArgs.push_back(
"-fopenmp-assume-no-nested-parallelism");
556 if (Args.hasArg(options::OPT_nogpulib))
557 CmdArgs.push_back(
"-nogpulib");
564 ArgStringList &CmdArgs) {
565 StringRef FPContract;
566 bool HonorINFs =
true;
567 bool HonorNaNs =
true;
568 bool ApproxFunc =
false;
569 bool SignedZeros =
true;
570 bool AssociativeMath =
false;
571 bool ReciprocalMath =
false;
573 if (
const Arg *A = Args.getLastArg(options::OPT_ffp_contract)) {
574 const StringRef Val = A->getValue();
575 if (Val ==
"fast" || Val ==
"off") {
577 }
else if (Val ==
"on") {
580 D.Diag(diag::warn_drv_unsupported_option_for_flang)
581 << Val << A->getOption().getName() <<
"off";
586 D.Diag(diag::err_drv_unsupported_option_argument)
587 << A->getSpelling() << Val;
590 for (
const Arg *A : Args) {
591 auto optId = A->getOption().
getID();
597 case options::OPT_fhonor_infinities:
600 case options::OPT_fno_honor_infinities:
603 case options::OPT_fhonor_nans:
606 case options::OPT_fno_honor_nans:
609 case options::OPT_fapprox_func:
612 case options::OPT_fno_approx_func:
615 case options::OPT_fsigned_zeros:
618 case options::OPT_fno_signed_zeros:
621 case options::OPT_fassociative_math:
622 AssociativeMath =
true;
624 case options::OPT_fno_associative_math:
625 AssociativeMath =
false;
627 case options::OPT_freciprocal_math:
628 ReciprocalMath =
true;
630 case options::OPT_fno_reciprocal_math:
631 ReciprocalMath =
false;
633 case options::OPT_Ofast:
635 case options::OPT_ffast_math:
638 AssociativeMath =
true;
639 ReciprocalMath =
true;
644 case options::OPT_fno_fast_math:
647 AssociativeMath =
false;
648 ReciprocalMath =
false;
654 if (FPContract ==
"fast")
663 if (!HonorINFs && !HonorNaNs && AssociativeMath && ReciprocalMath &&
664 ApproxFunc && !SignedZeros &&
665 (FPContract ==
"fast" || FPContract.empty())) {
666 CmdArgs.push_back(
"-ffast-math");
670 if (!FPContract.empty())
671 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + FPContract));
674 CmdArgs.push_back(
"-menable-no-infs");
677 CmdArgs.push_back(
"-menable-no-nans");
680 CmdArgs.push_back(
"-fapprox-func");
683 CmdArgs.push_back(
"-fno-signed-zeros");
685 if (AssociativeMath && !SignedZeros)
686 CmdArgs.push_back(
"-mreassociate");
689 CmdArgs.push_back(
"-freciprocal-math");
694 StringRef Format =
"yaml";
695 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
696 Format = A->getValue();
698 CmdArgs.push_back(
"-opt-record-file");
700 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
702 CmdArgs.push_back(A->getValue());
706 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
707 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
708 F = FinalOutput->getValue();
720 llvm::sys::path::replace_extension(F, Extension);
721 CmdArgs.push_back(Args.MakeArgString(F));
725 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
726 CmdArgs.push_back(
"-opt-record-passes");
727 CmdArgs.push_back(A->getValue());
730 if (!Format.empty()) {
731 CmdArgs.push_back(
"-opt-record-format");
732 CmdArgs.push_back(Format.data());
738 const ArgList &Args,
const char *LinkingOutput)
const {
741 const std::string &TripleStr = Triple.getTriple();
744 ArgStringList CmdArgs;
748 CmdArgs.push_back(
"-fc1");
751 CmdArgs.push_back(
"-triple");
752 CmdArgs.push_back(Args.MakeArgString(TripleStr));
754 if (isa<PreprocessJobAction>(JA)) {
755 CmdArgs.push_back(
"-E");
756 if (Args.getLastArg(options::OPT_dM)) {
757 CmdArgs.push_back(
"-dM");
759 }
else if (isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) {
760 if (JA.
getType() == types::TY_Nothing) {
761 CmdArgs.push_back(
"-fsyntax-only");
762 }
else if (JA.
getType() == types::TY_AST) {
763 CmdArgs.push_back(
"-emit-ast");
764 }
else if (JA.
getType() == types::TY_LLVM_IR ||
765 JA.
getType() == types::TY_LTO_IR) {
766 CmdArgs.push_back(
"-emit-llvm");
767 }
else if (JA.
getType() == types::TY_LLVM_BC ||
768 JA.
getType() == types::TY_LTO_BC) {
769 CmdArgs.push_back(
"-emit-llvm-bc");
770 }
else if (JA.
getType() == types::TY_PP_Asm) {
771 CmdArgs.push_back(
"-S");
773 assert(
false &&
"Unexpected output type!");
775 }
else if (isa<AssembleJobAction>(JA)) {
776 CmdArgs.push_back(
"-emit-obj");
777 }
else if (isa<PrecompileJobAction>(JA)) {
781 assert(
false &&
"Unexpected action class for Flang tool.");
790 addPreprocessingOptions(Args, CmdArgs);
792 addFortranDialectOptions(Args, CmdArgs);
797 if (InputType == types::TY_PP_Fortran &&
798 !Args.getLastArg(options::OPT_ffixed_form, options::OPT_ffree_form))
799 CmdArgs.push_back(
"-ffixed-form");
807 CmdArgs.push_back(
"-flto=full");
811 "the option '-flto=thin' is a work in progress"));
812 CmdArgs.push_back(
"-flto=thin");
816 addPicOptions(Args, CmdArgs);
822 addTargetOptions(Args, CmdArgs);
824 llvm::Reloc::Model RelocationModel =
827 addMCModel(
D, Args, Triple, RelocationModel, CmdArgs);
830 addCodegenOptions(Args, CmdArgs);
833 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
840 addOtherOptions(Args, CmdArgs);
844 Args.AddLastArg(CmdArgs, options::OPT_w);
848 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
849 options::OPT_fno_openmp,
false) &&
852 switch (
D.getOpenMPRuntime(Args)) {
856 CmdArgs.push_back(
"-fopenmp");
857 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
859 if (Args.hasArg(options::OPT_fopenmp_force_usm))
860 CmdArgs.push_back(
"-fopenmp-force-usm");
863 D.Diag(diag::warn_openmp_experimental);
874 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
875 D.Diag(diag::warn_drv_unsupported_openmp_library)
876 << A->getSpelling() << A->getValue();
882 CmdArgs.push_back(
"-resource-dir");
883 CmdArgs.push_back(
D.ResourceDir.c_str());
886 addOffloadOptions(
C, Inputs, JA, Args, CmdArgs);
889 Args.AddAllArgValues(CmdArgs, options::OPT_Xflang);
894 const char *FPKeepKindStr =
nullptr;
895 switch (FPKeepKind) {
897 FPKeepKindStr =
"-mframe-pointer=none";
900 FPKeepKindStr =
"-mframe-pointer=reserved";
903 FPKeepKindStr =
"-mframe-pointer=non-leaf";
906 FPKeepKindStr =
"-mframe-pointer=all";
909 assert(FPKeepKindStr &&
"unknown FramePointerKind");
910 CmdArgs.push_back(FPKeepKindStr);
914 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
916 A->render(Args, CmdArgs);
919 for (
const Arg *A : Args.filtered(options::OPT_mmlir)) {
921 A->render(Args, CmdArgs);
925 for (
const Arg *A : Args.filtered(options::OPT_flang_ignored_w_Group)) {
927 D.Diag(diag::warn_drv_unsupported_diag_option_for_flang)
928 << A->getOption().getName();
932 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
933 if (A->getOption().matches(options::OPT_O4)) {
934 CmdArgs.push_back(
"-O3");
935 D.Diag(diag::warn_O4_is_O3);
936 }
else if (A->getOption().matches(options::OPT_Ofast)) {
937 CmdArgs.push_back(
"-O3");
939 A->render(Args, CmdArgs);
947 CmdArgs.push_back(
"-o");
951 if (Args.getLastArg(options::OPT_save_temps_EQ))
952 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
956 bool FRecordCmdLine =
false;
957 bool GRecordCmdLine =
false;
960 if (FRecordCmdLine) {
961 CmdArgs.push_back(
"-record-command-line");
962 CmdArgs.push_back(CmdLine);
965 CmdArgs.push_back(
"-dwarf-debug-flags");
966 CmdArgs.push_back(CmdLine);
976 for (
const InputInfo &Input : FrontendInputs) {
983 const char *Exec = Args.MakeArgString(
D.GetProgramPath(
"flang", TC));
984 C.addCommand(std::make_unique<Command>(JA, *
this,
986 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()