pgf77(1)

🌸 NAME 🌸

nvfortran — The NVIDIA Fortran compiler. Bestie, you're reading the pgf77(1) page from the General Commands Manual, and it's giving "important compiler lore" ✨

---

🦋 SYNOPSIS 🦋

nvfortran [ -flag ]...  sourcefile...

---

💖 DESCRIPTION 💖

Okay so pgf77 is literally an alias for nvfortran. And nvfortran is a Fortran compiler for NVIDIA GPUs and AMD and Intel CPUs. No cap. 💅

It supports ISO Fortran 2003 and many features of Fortran 2008, supports GPU parallel programming with OpenACC, and supports multicore CPU programming with OpenACC and OpenMP. It invokes the Fortran compiler, assembler, and linker with options derived from its command line arguments. Slay. 🫶

The suffixes of source file names tell you what type of processing is going to happen:

• .f, .for, .ftn — fixed-format Fortran source; compile.
• .f90, .f95, .f03 — free-format Fortran source; compile.
• .F, .FOR, .FTN, .fpp, .FPP — fixed-format Fortran source; preprocess, compile.
• .F90, .F95, .F03 — free-format Fortran source; preprocess, compile.
• .cuf — free-format CUDA Fortran source; compile.
• .CUF — free-format CUDA Fortran source; preprocess, compile.
• .s — assembler source; assemble.
• .S — assembler source; preprocess, assemble.
• .o — object file; passed to linker.
• .a — library archive file; passed to linker.

C file suffixes are also recognized and compiled with the NVC compiler; see NVC and NVIDIA User's Guide. Other files are passed to the linker (if linking is requested) with a warning message. Lowkey important. ⭐

Unless one overrides the default action using a command-line option, nvfortran deletes the intermediate preprocessor and assembler files (see the options -c, -E, -F, and -Mkeepasm); if a single Fortran program is compiled and linked with one nvfortran command, the intermediate object file is also deleted. Linking is the last stage of the compile process, unless you use one of the -c, -E, -F, or -S options, or unless compilation errors stop the whole process. Periodt. 💀

---

✨ OPTIONS ✨

Options must be separate; -cs is different from -c -s. Here is a list of all options, grouped by type. More detailed explanations are in following sections. It's a lot, bestie — hydrate first. 🍓

🎀 Overall Options 🎀

• -- — overall option.
• -# — overall option.
• -### — overall option.
• -c — overall option.
• -[no]defaultoptions — overall option.
• -dryrun — overall option.
• -drystdinc — overall option.
• -dumpversion — overall option.
• -echo — overall option.
• --flagcheck — overall option.
• -flags — overall option.
• -fmax-errors=<n> — overall option.
• --gcc-toolchain=path — overall option.
• -help[=option] — overall option.
• -Manno — overall option.
• -Minform=level — overall option.
• -Mdetail — overall option.
• -Mkeepasm — overall option.
• -M[no]list — overall option.
• -noswitcherror — overall option.
• -o file — overall option.
• -rc rcfile — overall option.
• -S — overall option.
• -show — overall option.
• -silent — overall option.
• -time — overall option.
• -V — overall option.
• -V<ver> — overall option.
• -v — overall option.
• --version — overall option.
• -w — overall option.
• -Werror — overall option.
• -x language — overall option.
• -x none — overall option.
• -Wpass,option — overall option.
• -Ypass,directory — overall option.

💜 Optimization Options 💜

• -fast — optimization option.
• -f[no-]cx-limited-range — optimization option.
• -fastsse — optimization option.
• -fPIC — optimization option.
• -fpic — optimization option.
• -KPIC — optimization option.
• -Kpic — optimization option.
• -Mcache_align — optimization option.
• -Mconcur=option — optimization option.
• -M[no]depchk — optimization option.
• -M[no]dse — optimization option.
• -Mextract=option — optimization option.
• -M[no]fma — optimization option.
• -M[no]frame — optimization option.
• -M[no]idiom — optimization option.
• -M[no]info=option — optimization option.
• -Minline=option — optimization option.
• -Minstrument=option — optimization option.
• -M[no]ipa=option — optimization option.
• -M[no]lre[=assoc|noassoc] — optimization option.
• -M[no]movnt — optimization option.
• -Mneginfo=option — optimization option.
• -Mnoopenmp — optimization option.
• -Mnosgimp — optimization option.
• -Mnovintr — optimization option.
• -Mpfi[=option] — optimization option.
• -Mpfo[=option] — optimization option.
• -M[no]pre — optimization option.
• -M[no]prefetch=option — optimization option.
• -Mprof=option — optimization option.
• -M[no]propcond — optimization option.
• -Mquad — optimization option.
• -Msafe_lastval — optimization option.
• -M[no-]signed-zeros — optimization option.
• -M[no]stride0 — optimization option.
• -M[no]unroll=option — optimization option.
• -M[no]unsafe_par_align — optimization option.
• -M[no]vect=option — optimization option.
• -M[no]zerotrip — optimization option.
• -mp[=option] — optimization option.
• -nomp — optimization option.
• -Olevel — optimization option.
• -pg — optimization option.

🦋 Debugging Options 🦋

• -C — debugging option.
• -g — debugging option.
• -gopt — debugging option.
• -M[no]bounds — debugging option.
• -Mchkptr — debugging option.
• -Mchkstk — debugging option.
• -Mcoff — debugging option.
• -Mdwarf2 — debugging option.
• -Mdwarf3 — debugging option.
• -Melf — debugging option.
• -Mnodwarf — debugging option.
• -[no]traceback — debugging option.

🌈 Preprocessor Options 🌈

• -Dmacro — preprocessor option.
• -E — preprocessor option.
• -F — preprocessor option.
• -Idirectory — preprocessor option.
• -isystem directory — preprocessor option.
• -Mcpp=[[no]comment|m|md|mm|mmd|mq:target|mt:target|suffix:suff] — preprocessor option.
• -Mnostddef — preprocessor option.
• -Mnostdinc — preprocessor option.
• -Mpreprocess — preprocessor option.
• -Umacro — preprocessor option.
• -YI,directory — preprocessor option.
• -Yp,directory — preprocessor option.

🧚 Assembler Options 🧚

• -Wa,argument[,argument]... — assembler option.
• -Ya,directory — assembler option.

🔥 Linker Options 🔥

• -acclibs — linker option.
• --[no-]as-needed — linker option.
• -Bdynamic — linker option.
• -Bstatic — linker option.
• -Bstatic-nvidia — linker option.
• -c++libs — linker option.
• -cudaforlibs — linker option.
• -cudalib=libname — linker option.
• -cudalibs — linker option.
• -fortranlibs — linker option.
• -g77libs — linker option.
• -Ldirectory — linker option.
• -llibrary — linker option.
• -m — linker option.
• -Mcudalib=libname — linker option.
• -M[no]eh_frame — linker option.
• -Mnostartup — linker option.
• -Mnostdlib — linker option.
• -M[no]rpath — linker option.
• -Mmkl — linker option.
• -nvmalloc — linker option.
• -pthread — linker option.
• -Rdirectory — linker option.
• -r — linker option.
• -rpath directory — linker option.
• -s — linker option.
• -shared — linker option.
• -soname name — linker option.
• -static — linker option.
• -static-nvidia — linker option.
• -uname — linker option.
• --[no-]whole-archive — linker option.
• -Wl,option[,option]... — linker option.
• -Xlinker option[,option]... — linker option.
• -YC,directory — linker option.
• -Yl,directory — linker option.
• -YL,directory — linker option.
• -YS,directory — linker option.
• -YU,directory — linker option.

🌸 Language Options 🌸

• -asmsuffix=suffix — language option.
• -byteswapio — language option.
• -csuffix=suffix — language option.
• -fsuffix=suffix — language option.
• -FSUFFIX=suffix — language option.
• -cuda=option — language option.
• -i2 — language option.
• -i4 — language option.
• -i8 — language option.
• -i8storage — language option.
• -Mallocatable[=95|03] — language option.
• -M[no]backslash — language option.
• -Mbyteswapio — language option.
• -Mcray=pointer — language option.
• -Mcuda=option — language option.
• -M[no]dalign — language option.
• -M[no]dclchk — language option.
• -M[no]defaultunit — language option.
• -M[no]dlines — language option.
• -Mdollar=char — language option.
• -Mextend — language option.
• -Mfixed — language option.
• -M[no]free[form] — language option.
• -M[no]i4 — language option.
• -M[no]iomutex — language option.
• -Mlibsuffix=suffix — language option.
• -M[no]llalign — language option.
• -Mnomain — language option.
• -Mobjsuffix=suffix — language option.
• -M[no]onetrip — language option.
• -M[no]r8 — language option.
• -M[no]r8intrinsics=float — language option.
• -M[no]recursive — language option.
• -M[no]ref_externals — language option.
• -M[no]save — language option.
• -M[no]signextend — language option.
• -M[no]stack_arrays — language option.
• -Mstandard — language option.
• -Msyntax-only — language option.
• -M[no]unixlogical — language option.
• -M[no]upcase — language option.
• -module directory — language option.
• -Munlink_module — language option.
• -r4 — language option.
• -r8 — language option.
• -Wh,argument[,argument]... — language option.

👑 Target-specific Options 👑

• -acc — target-specific option.
• -noacc — target-specific option.
• -gpu=option — target-specific option.
• -K[no]ieee — target-specific option.
• -Ktrap=option — target-specific option.
• -march=target — target-specific option.
• -m[no-]daz-ftz — target-specific option.
• -M[no]daz — target-specific option.
• -M[no]flushz — target-specific option.
• -M[no]fpmisalign — target-specific option.
• -M[no]fprelaxed=option — target-specific option.
• -M[no]func32 — target-specific option.
• -M[no]longbranch — target-specific option.
• -M[no]second_underscore — target-specific option.
• -M[no]varargs — target-specific option.
• -Mwritable-strings — target-specific option.
• -mcmodel=small|medium — target-specific option.
• -stdpar=option — target-specific option.
• -nostdpar — target-specific option.
• -ta=target — target-specific option.
• -target=option — target-specific option.
• -tp=target — target-specific option.

When source files are compiled using any of the following options, the same option(s) should be passed when using nvfortran to link the objects: -g -mp -Mconcur -Mipa -Mprof. 🫶

🌈 Overall Options (the general-vibes zone) 🌈

• -- — everything after this switch is treated as a filename, periodt. But real talk: most tools will not allow a filename that starts with a dash, so like… just avoid those 💀
• -# — shows you the invocations of the compiler, assembler, and linker. These invocations are the command lines created by nvfortran. It's giving backstage pass 🎟️
• -### — same energy as -#, it displays the invocations of the compiler, assembler and linker, but does not execute them. Look, don't touch ✨
• -c — skip the link step. Compile and assemble only, bestie.
• -defaultoptions (default) / -nodefaultoptions — use (or don't use 🫣) the default options set in site-specific or user-specific PREOPTIONS or POSTOPTIONS driver variables.
• -dryrun — use this one to display the invocations of the compiler, assembler, and linker but not execute them. Rehearsal only, no show 🌸
• -drystdinc — displays the standard include directories without invoking the compiler. No cap.
• -dumpversion — displays the shortened version of the compiler. For example, 21.11 or 22.3.
• -echo [=go|stop] — echoes the command line flags and (by default) stops. This is genuinely so useful when the compiler is invoked by a script 👑
  • go — don't stop after echoing the command line.
  • stop(default) — do stop after echoing the command line.
• --flagcheck — don't compile anything; just emit any messages for command-line switch errors. Returns a success error code if there are no command-line switch errors. Vibe check only 😌
• -flags — displays all valid nvfortran command-line options in alphabetical order.
• -fmax-errors=<n> — specify the maximum number of errors before terminating compilation. (Original page spells it "maximun" and honestly? iconic typo, but it means maximum 🎀)
• --gcc-toolchain=path — specify the gcc toolchain location using path to the gcc directory or gcc executable. The argument can be either the gcc root directory, <root directory>/bin, or the gcc executable itself.
• -help[=option] — displays command-line options recognized by nvfortran on the standard output. nvfortran -help -otherswitch will give help about -otherswitch. The default is to list nvfortran command line options by group, and the options are:
  • groups — print out the groups into which the switches are organized.
  • asm — print help for assembler command-line options.
  • debug — print help for debugging command-line options.
  • language — print help for language-specific command-line options.
  • linker — print help for linker options.
  • opt — print help for optimization command-line options.
  • other — print help for any other command-line options.
  • overall — print help for overall command-line options.
  • phase — print help for the known compiler phases.
  • prepro — print help for preprocessor command-line options.
  • suffix — describe the known file suffixes.
  • switch — print all switches in alphabetical order.
  • target — print help for target-specific command-line options.
  • variable — show the nvfortran configuration; this is the same as -show.
• -Manno — produces annotated assembly files, where source code is intermixed with assembly language; implies -Mkeepasm. It's giving annotated director's cut 🎬
• -Minform=level — specify the minimum level of error severity that the compiler displays during compilation. The levels are:
  • fatal — instructs the compiler to display fatal error messages.
  • file (default) / nofile — print out (don't print out) the names of files as they are compiled; this is only active when there is more than one file on the command line.
  • severe — instructs the compiler to display severe and fatal error messages.
  • warn — instructs the compiler to display warning, severe and fatal error messages.
  • inform — instructs the compiler to display all error messages (inform, warn, severe and fatal).

The default is -Minform=warn.

• -Mdetail — displays enhanced error messages that include source line and column pointer. This is currently available for syntax errors and some semantic errors. So helpful it hurts 😭
• -Mkeepasm — keeps the assembly file for each source file, but continues to assemble and link the program. This is mainly for use in compiler performance analysis and debugging.
• -Mlist / -Mnolist (default) — create (don't create) a listing file.
• -noswitcherror — ignore unknown command line switches after printing a warning message; the default behavior is to print an error message and halt. Forgiving queen 💅
• -o file — use file as the name of the executable program, rather than the default a.out. If used with -c or -S and a single input file, file is used as the name of the object or assembler output file.
• -rc rcfile — specifies the name of a nvfortran startup configuration file. If rcfile is a full pathname, then use the specified file. If rcfile is a relative pathname, use the file name as found in the $DRIVER directory.
• -S — skip the assembly and link steps. Leave the output from the compile step in a file named file.s for each file named, for instance, file.f. See also -o.
• -show — produce help information describing the current nvfortran configuration.
• -silent — do not print warning messages. Same as -Minform=severe. Shhh 🤫
• -time — print execution times for the various steps in the compiler itself. Timer on, bestie ⏱️
• -V — display version messages and other information.
• -V<ver> — if the specified version of the compiler is installed, that version of the compiler is invoked.
• -v — verbose mode; print out the command line for each tool before it is executed.
• --version — display version messages and other information.
• -w — do not print warning messages.
• -Werror — turn all warning messages into errors. No more "lol it's just a warning" energy, they're real now 🔥
• -x language — specify explicitly the language for the input files (instead of choosing based on the file name suffix). The possible values for language are:
  • c
  • cpp c++ cpp-output
  • f F
  • f95 f95-cpp-input
  • f90 F90
  • f77 f77-cpp-input
  • cuf CUF
  • asm ASM assembler assembler-with-cpp
• -x none — turn off language specification, so the input files are handled according to their suffixes.
• -Wpass,option[,option...] — pass option to the specified pass. Each comma-delimited option is passed as a separate argument. The passes are:
  • h — for the Fortran 90/95 front end,
  • 0 — for the compiler back end,
  • a — for the assembler,
  • i — for the interprocedural analyzer, and
  • l — for the linker.
• -Ypass,directory — look in directory for pass pass, rather than in the standard area. The passes are:
  • h — search for the Fortran 90/95 front end executable in directory.
  • 0 — search for the compiler back end executable in directory.
  • a — search for the assembler executable in directory.
  • C — search for the compiler library in directory.
  • i — search for the InterProcedural Analyzer (IPA) in directory.
  • l — search for the linker in directory.
  • I — set the compiler's standard include directory to directory. The standard include directory is set to a default value by the driver and can be overridden by this option.
  • L — if the linker supports the -YL option, then pass the option -YL,directory to the linker. Otherwise, use directory as the standard library location.
  • S — search for the startup object files in directory.
  • U — if the linker supports the -YU option, then pass the option -YU,directory to the linker. Otherwise this option is ignored.

---

⚡ Optimization Options ⚡

• -fast — chooses generally optimal flags for the target platform. Use nvfortran -fast -help to see the equivalent switches. Note this sets the optimization level to a minimum of 2; see -O. Speedy girly pop 🏃‍♀️💨
• -fcx-limited-range — specify that complex division does not need range reduction. -fno-cx-limited-range specifies that complex division does need range reduction. -fcx-limited-range is the default setting at optimization level -Ofast.
• -fastsse — chooses generally optimal flags for a processor that supports to vectorize for the SSE/AVX instructions. Use nvfortran -fastsse -help to see the equivalent switches.
• -fPIC — equivalent to -fpic; provided for compatibility with other compilers.
• -fpic — instructs the compiler to generate position-independent code which can be used to create shared object files (dynamically linked libraries).
• -KPIC — equivalent to -fpic; provided for compatibility with other compilers.
• -Kpic — equivalent to -fpic; provided for compatibility with other compilers.
• -Mcache_align — align unconstrained data objects of size greater than or equal to 16 bytes on cache-line boundaries. An unconstrained object is a variable or array that is not a member of an aggregate structure or common block, is not allocatable, and is not an automatic array. Organized and aligned, as she should be 🎀
• -Mconcur[=option[,option,...]] — > ⚠️ heads up bestie, this option has been deprecated and will be removed in a future release. Don't get attached 💀

It instructs the compiler to enable auto-concurrentization of loops. This also sets the optimization level to a minimum of 2; see -O. If -Mconcur is specified, multiple processors will be used to execute loops which the compiler determines to be parallelizable. When linking, the -Mconcur switch must be specified or unresolved references will occur. The OMP_NUM_THREADS or NCPUS environment variables control how many processors will be used to execute parallelized loops. The options can be one or more of the following:

• allcores — uses all available cores when the environment variables OMP_NUM_THREADS and NCPUS are not set. ⚠️ this one must be specified at link time, no exceptions bestie.
• altcode:n, noaltcode — generate (or don't generate, respectively) alternate scalar code for parallelized loops. Here's the tea ☕: the parallelizer whips up scalar code that gets executed whenever the loop count is less than or equal to n. But if you say noaltcode, the parallelized version of the loop is always executed, no matter what the loop count is. main character behavior fr.
• altreduction[:n] — generates alternate scalar code for parallelized loops that contain a reduction. If a parallelized loop has a reduction in it, the parallelizer generates scalar code that gets executed whenever the loop count is less than or equal to n. 💖
• assoc (default), noassoc — enable (or disable) parallelization of loops with reductions.
• cncall, nocncall (default) — assume (or don't assume) that loops containing calls are safe to parallelize. Also, with this, no minimum loop count threshold has to be satisfied before parallelization will happen, and last values of scalars are assumed to be safe. 👑
• dist:block — parallelize with block distribution. Contiguous blocks of iterations of a parallelizable loop get assigned to the available processors. clean, simple, slay.
• dist:cyclic — parallelize with cyclic distribution. The outermost parallelizable loop in any loop nest is the one that gets parallelized. If a parallelized loop is innermost, its iterations are allocated to processors cyclically. Example time 🍓: if there are 3 processors executing a loop, processor 0 performs iterations 0, 3, 6, etc; processor 1 performs iterations 1, 4, 7, etc; and processor 2 performs iterations 2, 5, 8, etc. iconic rotation honestly.
• innermost, noinnermost (default) — enable (or disable) parallelization of innermost loops.
• levels:n — parallelize loops nested at most n levels deep; the default is 3.

---

• -Mdepchk (default), -Mnodepchk — assume (or don't assume) that potential data dependencies exist. 🚨 bestie listen to me: -Mnodepchk may result in incorrect code. like, wrong-answers incorrect. don't play with it.
• -Mdse, -Mnodse (default) — enable (or disable) the dead store elimination optimization.
• -Mextract=[option[,option,...]] — runs the subprogram extraction phase to prep for inlining. The =lib:filename option must be used with this switch to name an extract library. Peep -Minline for more details on inlining. ✨
  • subprogram[,subprogram] — a non-numeric option that doesn't contain a period is assumed to be the name of a subprogram to be extracted.
  • name:subprogram[,subprogram] — specifies the name of a subprogram or subprograms to be extracted.
  • lib:directory — specifies the name of a directory to contain the extracted subprograms; this directory will be created if it does not exist. 🎀
  • [size:]number — a numeric option is assumed to be a size. Functions containing number or fewer statements are extracted. If both number and function are specified, then functions matching the given name(s) or meeting the size requirements are extracted.
• -Mfma, -Mnofma (default) — generate (or don't generate) fused multiply-add (FMA) instructions on the CPU and GPU for targets that support it. FMA instructions are generally faster than separate multiply-add instructions, and they can generate higher precision results since the multiply result isn't rounded before the addition. But plot twist 😭: delaying rounding until after the addition may cause results to differ from those you'd get with the unfused multiply-add instructions. FMA instructions are enabled at optimization levels higher than -O1.
• -Mframe, -Mnoframe (default) — set up (or don't set up) a true stack frame pointer for functions. -Mnoframe allows slightly more efficient operation when a stack frame isn't needed, but heads up: some options override -Mnoframe. 💅
• -Midiom, -Mnoidiom (default) — enable loop idiom recognition. Memory copy, memory set, and memory zero loops are recognized and replaced with calls to their respective optimized versions. glow-up via pattern matching, we love to see it.
• -Minfo[=option[,option,...]], -Mnoinfo (default) — emit useful information to stderr. The options are:
  • all — includes the options accel, inline, ipa, loop, lre, mp, opt, par, stdpar, vect.
  • accel — emit information about accelerator region targeting.
  • ftn — emit Fortran-specific information.
  • inline — emit information about functions extracted and inlined.
  • intensity — this option has been deprecated and will be removed in a future version. It emits compute intensity information about loops. 💀 (rest in peace, bestie.)
  • ipa — emit information about the optimizations enabled by interprocedural analysis (IPA).
  • loop | opt — emit information about loop optimizations. This includes information about vectorization and loop unrolling.
  • lre — emit information about loop-carried redundancy elimination.
  • mp — emit information about OpenMP parallel regions.
  • par — emit information about loop parallelization.
  • pfo — emit profile feedback information.
  • time | stat — emit compilation statistics.
  • stdpar — emit information about parallelization of C++ parallel algorithms and Fortran DO CONCURRENT loops.
  • vect — emit information about automatic loop vectorization.

With no options at all, -Minfo is the same as -Minfo=accel,ipa,loop,lre,mp,opt,par,stdpar,vect.

• -Minline[=option[,option,...]] — passes options to the function inliner. The options are:
  • lib:filename.ext — specify an inline library created by a previous -Mextract option. Functions from the specified library are inlined. If no library is specified, functions are extracted from a temporary library created during an extract prepass. 🧚
  • except:func — specifies which functions should not be inlined. (no thank you, not you.)
  • [name:]function — a non-numeric option is assumed to be a function name. If name: is specified, what follows is always the name of a function.
  • pragma — Fortran Only: inline only those procedures that have a !NVF$ INLINE pragma on the source line immediately before the procedure's SUBROUTINE or FUNCTION statement.
  • [maxsize:]number — a numeric option is assumed to be a size. Functions of size number or less are inlined. If both number and function are specified, then functions matching the given name(s) or meeting the size requirements are inlined.
  • reshape — for Fortran, the default is to not inline subprograms with array arguments if the array shape doesn't match the shape in the caller. This overrides the default. 🦋
  • smallsize:number — always inline functions of size smaller than number, regardless of other size limits.
  • totalsize:number — stop inlining in a function when that function's total inlined size reaches the number specified.
• -Minstrument [=option] — generate additional code to enable function-level instrumentation. This option implies -Mframe. The option is:
  • functions (default)
• -Mipa [=option[,option,...]], -Mnoipa (default) — enable and specify options for InterProcedural Analysis (IPA). 📌 Note: IPA is not compatible with parallel make environments (e.g., pmake). IPA also sets the optimization level to a minimum of 2; peep -O. If no option list is specified, then it's equivalent to -Mipa=const. The options are:
  • align, noalign (default) — enable (or disable) recognition when pointer targets are all cache-line aligned, which allows better SSE code generation. ✨
  • arg, noarg (default) — remove (or don't remove) arguments replaced by -Mipa=ptr,const. -Mipa=noarg implies -Mipa=nolocalarg.
  • const (default), noconst — enable (or disable) propagation of constants across procedure calls.
  • f90ptr, nof90ptr (default) — enable (or disable) Fortran 90 pointer disambiguation across procedure calls.
  • fast — chooses generally optimal -Mipa flags for the target platform; use nvfortran -Mipa -help to see the equivalent options. iykyk.
  • force — force all objects to recompile regardless of whether IPA information has changed.
  • globals, noglobals (default) — analyze (or don't analyze) which globals are modified by procedure calls.
  • inline:n — determine additional functions to inline, allowing up to n levels of inlining. Additional suboptions are:
    • except:proc — disables inlining of procedure proc.
    • nopfo — ignore any profile frequency information from -Mpfo when choosing which functions to inline.
    • reshape, noreshape (default) — enable (or disable) Fortran inlining with mismatched array shapes.
  • ipofile — save IPA information in a .ipo file instead of the default of appending the information to the object file. 🎀
  • jobs:n — use up to n jobs in parallel to reoptimize object files. multitasking queen behavior.
• keepobj (default), nokeepobj — keep (or don't keep) the optimized object files, using file name mangling, so your later application builds recompile less stuff. it's giving "future you says thank you" 💖
• libc, nolibc (default) — optimize (or don't optimize) calls to certain standard C library routines ✨
• libinline, nolibinline (default) — allow (or don't allow) inlining from routines in libraries. heads up: -Mipa=libinline implies -Mipa=inline 🫶
• libopt, nolibopt (default) — allow (or don't allow) recompiling and reoptimizing routines from libraries that have IPA information 🔁
• localarg, nolocalarg (default) — enable (or disable) the feature that externalizes local variables so arguments can be replaced by -Mipa=ptr. also, -Mipa=localarg implies -Mipa=arg, iykyk 💅
• main:func — name a function to serve as a global entry point. you can drop this multiple times if you want; it disables linking 👑
• ptr, noptr (default) — enable (or disable) pointer disambiguation across procedure calls 🔍
• pure, nopure (default) — detect (or don't detect) pure functions 🌸
• quiet — don't print out messages about which files get recompiled at link time. shh, main character silence 🤫
• reaggregation, noreaggregation (default) — enable (or disable) global struct reaggregation. ngl this one can change the order of struct members, or split structs into multiple structs, to improve memory locality and cache utilization — iconic behaviour, lowkey rearranging your furniture 🛋️✨
• required — return an error condition if IPA is inhibited for any reason, instead of the default behaviour of linking without IPA optimization. like, if it can't do the thing it's gonna tell you 🚨
• safe:[function|library] — declares that the named function, or every function in the named library, is safe. a safe procedure does not call back into the known procedures and does not change any known global variables. and bestie, without -Mipa=safe, any unknown procedures will cause IPA to fail 😭
• safeall, nosafeall (default) — declares that all unknown functions are safe (or not safe). see -Mipa=safe 🫡
• shape, noshape (default) — perform (or don't perform) Fortran 90 shape propagation 🧚
• summary — only collect IPA summary information when compiling. this prevents IPA optimization of this file, but it allows optimization for other files linked with this file. teamwork, but make it compiler 🫶
• vestigial, novestigial (default) — remove (or don't remove) functions that are not called. bye bye dead code 👋💀
• -Mlre[=assoc|noassoc], -Mnolre — enable (or disable, with -Mnolre) loop-carried redundancy elimination. the assoc option allows expression reassociation, and noassoc disallows expression reassociation 🎀
• -Mmovnt, -Mnomovnt — force (or disable) generation of nontemporal moves. -Mmovnt used with -fastsse can sometimes be faster than -fastsse alone, which is kind of a slay. by default, nontemporal moves are generated for loops with large loop counts 🔥
• -Mneginfo=option[,option...] — tells the compiler to produce info on why certain optimizations are not performed. but fr, use the -Minfo flag instead 💅
• -Mnoopenmp — when -mp is present, ignore the OpenMP pragmas 🙈
• -Mnosgimp — when -mp is present, ignore the SGI parallelization pragmas 🙈
• -Mnovintr — do not generate vector intrinsic calls 🚫
• -Mpfi[=option] — generate profile feedback instrumentation. this includes extra code to collect run-time statistics for use in a subsequent compile, and -Mpfi must also appear when the program is linked. when the program is run, a profile feedback file pgfi.out will be generated; see -Mpfo. the allowed options are:
  • indirect, noindirect (default) — enable (or disable) collection of indirect function call targets, which can be used for indirect function call inlining 🎯
• -Mpfo[=option[,option,...]] — enable profile feedback optimizations. there must be a profile feedback file pgfi.out in the current directory, and it contains the result of an execution of the program compiled with -Mpfi. the options are:
  • indirect, noindirect (default) — enable (or disable) indirect function call inlining. this requires a pgfi.out file generated from a binary built with -Mpfi=indirect 🔗
  • layout (default), nolayout — enable (or disable) basic block layout, which takes advantage of instruction cache locality by keeping hot paths close together 🔥
  • dir=directory — specify the directory containing the pgfi.out profile feedback information file. the default is the current directory 📁
• -Mpre, -Mnopre (default) — enable (or disable) the partial redundancy elimination optimization ✨
• -Mprefetch[=option:n], -Mnoprefetch — add (or don't add) prefetch instructions for those processors that support them (Pentium 4, Opteron). -Mprefetch is default on Opteron, and -Mnoprefetch is default on other processors. the options are:
  • distance:d — set the fetch-ahead distance for prefetch instructions to d cache lines 📏
  • n:n — set the maximum number of prefetch instructions to generate in a loop to n 🔢
  • nta — use the prefetchnta instruction 🧚
  • plain — use the prefetch instruction 💫
  • t0 — use the prefetcht0 instruction ⭐
  • w — allow the AMD-specific prefetchw instruction 💜
• -Mprof[=option[,option,...]] — set performance profiling options. using these options will cause the resulting executable to create a performance profile that can be viewed and analyzed with the PGPROF performance profiler. in the descriptions below, old-style profiling implies compiler-generated source instrumentation, and MPICH-style profiling implies the use of instrumented wrappers for MPI library routines. the -Mprof options are:
  • dwarf — generate limited DWARF symbol information, sufficient for most performance profilers 🧬
  • func — perform old-style function level profiling 🎯
  • hwcts — generate a profile using event-based sampling of hardware counters via the PAPI interface (PAPI must be installed) 🖥️
  • lines — perform old-style line level profiling 📝
  • time — generate a profile using time-based instruction-level statistical sampling. this is equivalent to -pg, except that the profile is saved in a file named pgprof.out instead of gmon.out ⏱️

on Linux systems that have OProfile installed, PGPROF supports collection of performance data without recompilation. use of -Mprof=dwarf is useful for this mode of profiling 🐧✨

• -Mpropcond (default), -Mnopropcond — enable (or disable) propagation of constant values derived from conditional branches with equality tests 🎀
• -Mquad — align large objects on quad-word boundaries 📐
• -Msafe_lastval — in the case where a scalar is used after a loop, but is not defined on every iteration of the loop, the compiler does not by default parallelize the loop. however, this option tells the compiler it is safe to parallelize the loop 🏃‍♀️💨
• -Msigned-zeroes (default), -Mno-signed-zeros — toggles whether to honor (-Msigned-zeros) or ignore (-Mno-signed-zeros) issues associated with a signed 0.0 during optimization 0️⃣
• -Mstride0, -Mnostride0 (default) — generate (or don't generate) alternate code for a loop that contains an induction variable whose increment may be zero 🔄
• -Munroll[=option[,option...]], -Mnounroll (default) — invoke (or don't invoke) the loop unroller. this also sets the optimization level to a minimum of 2; see -O. the option is one of the following:
  • c:m — tells the compiler to completely unroll loops with a constant loop count less than or equal to m, a supplied constant. if this value is not supplied, the m count is set to 1. if m is set to 1, a compiler heuristic determines the maximum loop count at which such loops will be completely unrolled 🌀
  • n:u — tells the compiler to unroll u times a single-block loop which is not completely unrolled, or has a non-constant loop count. if u is not supplied, the unroller computes the number of times a candidate loop is unrolled 🔁
  • m:u — tells the compiler to unroll u times a multi-block loop which is not completely unrolled, or has a non-constant loop count. if u is not supplied, the unroller computes the number of times a candidate loop is unrolled 🔁

and -Mnounroll tells the compiler not to unroll loops. periodt 🚫

• -Munsafe_par_align, -Mnounsafe_par_align — use (or don't use) aligned moves for array loads in parallelized loops, as long as the first element of the array is aligned. this is only effective with -Mvect=simd. and bestie, it is unsafe because there are situations where the array elements allocated to some processors are not aligned 😬⚠️
• -Mvect[=option[,option,...]], -Mnovect (default) — pass options to the internal vectorizer. this also sets the optimization level to a minimum of 2, the equivalent of -O; for more information see optimization levels under -O. if no option list is specified, then the following vector optimizations are used: assoc,cachesize:c,simd:256, where c is the actual cache size of the machine. the -Mvect options are:
  • altcode (default), noaltcode — enable (or disable) alternate code generation for vector loops, depending on such characteristics as array alignments and loop counts 🧚
  • fuse, nofuse (default) — enable (or disable) loop fusion, which combines adjacent loops into a single loop 🫶
  • prefetch — use prefetch instructions in loops where profitable 👀
• simd[:{128|256|512}] (default) / nosimd — use vector SIMD instructions, like AVX, AVX2, AVX512 💅 the argument is there so you can cap yourself at 128-bit SIMD instructions if you're feeling modest. And bestie, specifying 512-bit SIMD instructions is only possible for target processors that actually support AVX512, so check before you flex.
• uniform / nouniform (default) — do the same optimizations in the vectorized loops and the residual loops. Heads up: this may affect the performance of the residual loop 🫶

Okay so these next ones are also supported, but the manpage is literally like "not recommended for use in new development, except by experienced users, and may be phased out in future releases" — so, like, they're giving legacy era, not main character energy. Use at your own risk, iykyk 🙈

• assoc (default) / noassoc — enable (or disable) certain associativity conversions that can change the results of a computation due to floating-point roundoff error differences. The classic move here is changing the order of additions — mathematically correct, yes, but computationally different because, surprise, roundoff error exists 😭
• cachesize:number (default=automatic) — tells the vectorizer, when it's doing cache tiling optimizations, to assume a cache size of number.
• gather (default) / nogather — enable (or disable) vectorization of loops with indirect array references.
• idiom (default) / noidiom — enable idiom recognition; it's the alternate form of -Midiom ✨
• levels:n — set the maximum nest level of loops to optimize.
• partial — enable partial loop vectorization via innermost loop distribution.
• short / noshort (default) — enable (or disable) recognition of short vector operations that arise from scalar code outside of loops or within the body of loops.
• sizelimit[:number] / nosizelimit (default) — limit the size of loops that get vectorized; the default is, uh, attempting to vectorize all loops. go big or go home I guess 💀
• tile / notile (default) — enable (or disable) loop tiling to optimize for cache locality.
• -Mnovect — disables the vectorizer entirely, and it's the default at -O0 and -O1.
• -Mzerotrip (default) / -Mnozerotrip — include (or don't include) a zero-trip test for loops. Only reach for -Mnozerotrip when all loops are known to execute at least once, no cap 🫡
• -mp[=option] — enables OpenMP pragmas and directives so you can explicitly parallelize regions of code for execution by accelerator devices or multi-processor systems. The options allowed are:
  • gpu — compile OpenMP directives for parallel execution on the GPU 🔥
  • multicore (default) — compile OpenMP directives for parallel execution on the CPU.
  • align / noalign (default) — modify (or don't modify) default loop iteration scheduling to align iterations with array references. The default is to use simple static scheduling.
  • autopar (default) / noautopar — enable loop autoparallelization of omp loop constructs.
  • ompt — link against an OMPT-enabled OpenMP library.
• -nomp — ignore OpenMP directives and do not link against OpenMP runtime libraries.
• -O[level] — set the optimization level. If -O is not specified, then the default level is 1 if -g is not specified, and 0 if -g is specified. If a number is not supplied with -O then the optimization level gets set to 2. The optimization levels and their meanings are, and I quote, as follows:
  • -O0 — sets the optimization level to 0. A basic block is generated for each statement. No scheduling is done between statements. No global optimizations are performed. it's giving baby steps 🎀
  • -O1 — sets the optimization level to 1. Scheduling within extended basic blocks is performed. No global optimizations are performed.
  • -O — sets the optimization level to 2, with no SIMD vectorization enabled. All level 1 optimizations are performed. In addition, traditional scalar optimizations such as induction recognition and loop invariant motion are performed by the global optimizer.
  • -O2 — all -O optimizations are performed. In addition, more advanced optimizations such as SIMD code generation, cache alignment and partial redundancy elimination are enabled. this is the sweet spot bestie 💖
  • -O3 — all -O1 and -O2 optimizations are performed. In addition, this level enables more aggressive code hoisting and scalar replacement optimizations that may or may not be profitable. (the "may or may not be profitable" is doing so much heavy lifting 😭)
  • -Ofast — enables -O3, -Mfprelaxed, -Mstack_arrays, -Mno-nan, Mno-inf, and -fcx-limited-range. Note -Mstack_array is disabled when both command line options -Ofast and -stdpar are enabled.
  • -O4 — all -O1, -O2, and -O3 optimizations are performed. In addition, hoisting of guarded invariant floating-point expressions is enabled.
• -pg — enable gprof-style sample-based profiling; implies -Mframe.

---

🐛 Debugging Options 🐛

• -C — add array bounds checking; it's the same as -Mbounds.
• -g — generate symbolic debug information. This also sets the optimization level to zero, unless a -O switch is present on the command line. > Symbolic debugging may give confusing results if an optimization level other than zero is selected. And using -O0, the generated code will be slower than code generated at other optimization levels — like, noticeably slower, bestie, that's the tradeoff 😭
• -gopt — generate symbolic debug information, without affecting optimizations. > This may give confusing results when debugging with optimizations; it's intended for use with other tools that use the debug information.
• -Mbounds / -Mnobounds (default) — add (or don't add) array bound checking.
• -Mchkptr — check for unintended de-referencing of NULL pointers. honestly iconic of it 🫶
• -Mchkstk — check the stack for available space upon entry to and before the start of a parallel region. Useful when many private variables are declared.
• -Mcoff — generate a COFF formatted object.
• -Mdwarf2 — generate DWARF2 debug information with -g.
• -Mdwarf3 — generate DWARF3 debug information with -g.
• -Melf — generate an ELF formatted object.
• -Mnodwarf — don't add the default dwarf information.
• -traceback (default) / -notraceback — add debug information for runtime traceback.

---

🌸 Preprocessor Options 🌸

• -Dname[=def] — define name to be def in the preprocessor. If def is missing, it's assumed to be empty. If the = sign is missing, then name is defined to be the string 1.
• -E — preprocess each .c file and send the result to standard output. No compilation, assembly, or linking is performed. just vibes and preprocessing ✨
• -F — stop after preprocessing.
• -Idirectory — add directory to the compiler's search path for include files. For include files surrounded by < >, each -I directory is searched followed by the standard area. For include files surrounded by " ", the directory containing the file containing the #include directive is searched, followed by the -I directories, followed by the standard area. order matters, bestie 👑
• -isystem directory — same as -I, but mark the directory as a system directory.
• -Mcpp=[[no]comment|m|md|mm|mmd|mq:target|mt:target|suffix:suff] — only runs the preprocessor on the input file(s); by default, the output is written to file.i, unless renamed with the -o switch. The options are:
  • comment / nocomment — keep (or don't keep) C-style comments in the preprocessed output.
  • include:file — include this file before processing the source file.
  • m — print makefile dependencies to stdout, a la -M.
  • md — print makefile dependencies to file.d, a la -MD.
  • mm — print makefile dependencies to stdout, ignoring system includes (includes with angle braces), a la -MM.
  • mmd — print makefile dependencies to file.d, ignoring system includes (includes with angle braces), a la -MMD.
  • mq:'target' — print makefile dependencies to stdout, a la -MQ.
  • mt:target — print makefile dependencies to stdout, a la -MT.
  • line — include line numbers into the preprocessed output.
  • suffix:suff — when generating makefile dependencies, name the dependent file file.suff; the default is to name the dependent file file.o.
• -Mnostddef — do not predefine any macros to the preprocessor.
• -Mnostdinc — do not search in the standard location for include files when those files are not found elsewhere.
• -Mpreprocess — run the preprocessor on Fortran or assembler source files. By default, the preprocessor is run when the source's suffix is .fpp, .F, .F90, .F95, or .HPF.
• -Uname — remove the definition of the name macro in the preprocessor.
• -YI,directory — change the standard include directory to directory.
• -Yp,directory — look in directory for the preprocessor executable.

---

🧚 Assembler Options 🧚

• -Wa,option[,option...] — pass each comma-delimited option to the assembler.
• -Ya,directory — look in directory for the assembler executable.

💖 LINKER OPTIONS 💖

Okay bestie, this whole section is the link-step era — the driver is handing stuff off to the linker and we are keeping every single detail, no cap. 🔗✨

• -acclibs — link-time option that adds the accelerator libraries to the link line. 💅
• --as-needed, --no-as-needed — passed to the linker. --as-needed tells the linker to only set the DT_NEEDED flag for subsequent shared libraries — requiring those libraries at run time — if they are used to satisfy references. --no-as-needed restores the default behavior. 🫶
• -Bdynamic — passed to the linker to specify dynamic binding. ✨
• -Bstatic — this option is the same as -static. Please refer to -static for details. 💫
• -Bstatic-nvidia — this option is the same as -static-nvidia. Please refer to -static-nvidia for details. 🌟
• -c++libs — link-time option to add the C++ runtime libraries, allowing mixed-language programming. 🔥
• -cudaforlibs — link-time option to add the CUDA Fortran runtime libraries, allowing mixed-language programming. Implies -fortranlibs. 💜
• -cudalib[=libname[,libname...]] — add CUDA-optimized libraries to the link line. When no option is specified the compiler will link all necessary CUDA-optimized libraries. -cudalib will use the version of the library appropriate to the CUDA version being used. The libraries recognized are:
  • cublas
  • cublasmp
  • cufft
  • cufftmp
  • cufftw
  • curand
  • cusolver
  • cusolvermp
  • cusparse
  • cutensor
  • nccl
  • nvblas
  • nvshmem
  • nvtx3
• -cudalibs — this option has been deprecated please refer to -cudalib. Link-time option to add the CUDA runtime API library. 😭
• -fortranlibs — link-time option to add the Fortran runtime libraries, allowing mixed-language programming. 🎀
• -g77libs — link-time option which allows object files generated by GNU g77 (or gcc) to be linked in to nvfortran main programs. 🦋
• -Ldirectory — passed to the linker; add directory to the list of directories in which the linker searches for libraries. 🌸
• -llibrary — passed to the linker; load the library liblibrary.a from the standard library directory. See also the -L option. 💖
• -m — cause the linker to display a link map. 👑
• -Mcudalib[=libname[,libname...]] — this option has been deprecated please refer to -cudalib. Add CUDA-optimized libraries to the link line. When no option is specified the compiler will link all necessary CUDA-optimized libraries. ⭐
• -Meh_frame, -Mnoeh_frame — add (don't add) arguments to the link line to preserve the stack frame information for zero-cost exception handling frames. The default is -Mnoeh_frame unless changed in a site or user rcfile. 🌈
• -Mnostartup — do not link in the usual startup routine. This routine contains the entry point for the program. 💀
• -Mnostdlib — do not link in the standard libraries when linking a program. 🙈
• -Mrpath (default), -Mnorpath — the default is to add -rpath to the link line giving the directories containing the required runtime shared objects. Use -Mnorpath to instruct the driver not to add any -rpath switches to the link line. 🍓
• -Mmkl — add Intel's Math Kernel libraries to the link line. Requires that the environment variable MKLROOT be set to the path to the local MKL installation (the part of the path that precedes lib/<arch>). 🧚
• -nvmalloc — use a custom host memory allocator. ✨
• -pthread — adds support for multithreading with the pthreads library. This option sets flags for both the preprocessor and linker. 💅
• -Rdirectory — passed to the linker; instructs the linker to hard-code the pathname directory into the search path for generated shared object files. Note that there cannot be a space between R and directory. 🫶
• -r — passed to the linker; generate a re-linkable object file. 🔥
• -rpath directory — passed to the linker to add the directory to the runtime shared library search path. 🌟
• -s — passed to the linker; strip symbol table information. 💜
• -shared — passed to the linker. Instructs the linker to generate a shared object file (dynamically linked library). Implies -fpic. 🎀
• -soname name — passed to the linker. When creating a shared object, instructs the linker to set the internal DT_SONAME field to the specified name. 🦋
• -static — passed to the linker to specify static binding. 🌸
• -static-nvidia — statically link in the NVIDIA runtime libraries, while using dynamic linking for the system libraries; implies -Mnorpath. 💖
• -uname — passed to the linker; generate undefined reference. 👑
• --whole-archive, --no-whole-archive — passed to the linker. --whole-archive instructs the linker to include all objects in subsequent archive files. --no-whole-archive restores the default behavior. ⭐
• -Wl,option[,option]..., -Xlinker option[,option]... — pass each comma-delimited option to the linker. 🌈
• -YC,directory — look in directory for the standard compiler library files. 💀
• -Yl,directory — look in directory for the linker. 🙈
• -YL,directory — change the standard library directory to directory. 🍓
• -YS,directory — look in directory for the standard system startup object files. 🧚
• -YU,directory — passed to the linker; change library search path. ✨

🗣️ Language Options 🗣️

Okay bestie, this is the big one — all the flags that tell the compiler what flavour of Fortran you're speaking. Buckle up 💅

• -asmsuffix=suffix — says "hey, a file with this suffix? that's an assembly language file." Custom extensions, slay.
• -byteswapio — swaps bytes from big-endian to little-endian, or vice versa, on input/output of unformatted Fortran data. Turning this on means you can read/write Fortran unformatted data files that are compatible with the ones produced on Sun or SGI systems. 🌈
• -csuffix=suffix — declares that a file with this suffix is a C source file.
• -fsuffix=suffix — declares that a file with this suffix is a Fortran source file.
• -FSUFFIX=suffix — same energy, declares that a file with this suffix is a Fortran source file. (Yes, it's the uppercase twin, and yes, it's iconic in its own way 👑)
• -cuda[=option[,option...] — enables CUDA Fortran, adds the CUDA include paths, and links with the CUDA runtime libraries. ⚠️ Heads up: -cuda is required on the link line. If -cuda is used in compilation, it must also be used for linking. For target specific options, go look at -gpu. For linking additional CUDA libraries (e.g. math libraries), go look at -cudalib. Then use these sub-options to tailor the compilation of CUDA Fortran accelerator regions:
  • charstring — enable limited support for character strings in GPU kernels.
  • madconst — put Module Array Descriptors in CUDA Constant Memory.
• -i2 — treat INTEGER variables as two bytes.
• -i4 — treat INTEGER variables as four bytes.
• -i8 — treat default INTEGER and LOGICAL variables as eight bytes. For operations involving integers, use 64-bits for computations. 🧮
• -i8storage — allocates 8 bytes for INTEGER and LOGICAL.
• -Mallocatable[=95|03] — picks whether you get Fortran 1995 or Fortran 2003 semantics for assignments to allocatable objects and allocatable components of derived types. Fortran 1995 semantics require you to allocate the object or component, and require that an array object or component be conformant before the assignment. Fortran 2003 semantics require the compiler to add code checking whether the object or component is allocated and whether an array object is conformant before the assignment — and to allocate or reallocate if not. Bestie, that's the compiler doing your chores for you 🫶
• -Mbackslash, -Mnobackslash (default) — treat / don't treat backslash as a normal (non-escape) character in strings. -Mnobackslash causes the standard C backslash escape sequences to be recognized in quoted strings; -Mbackslash causes the backslash to be treated like any other character.
• -Mbyteswapio — swaps bytes from big-endian to little-endian or vice versa on input/output of unformatted Fortran data. Using it enables reading/writing of Fortran unformatted data files compatible with those produced on Sun or SGI systems.
• -Mcray=pointer — forces Cray Fortran (CF77) compatibility with respect to the listed options. Possible options include:
  • pointer — for purposes of optimization, assume that pointer-based variables do not overlap the storage of any other variable.
• -Mcuda[=option[,option...] — ⚠️ this option has been deprecated, please refer to -cuda. It enables CUDA (and CUDA Fortran) and links with the CUDA libraries. -Mcuda is required on the link line if there are no CUDA Fortran source files specified on the command line. If -Mcuda is used in compilation, it must also be used for linking.
• -Mdalign (default), -Mnodalign — align / don't align doubles in structures on 8-byte boundaries. Ngl -Mnodalign may lead to data alignment exceptions. 💀
• -Mdclchk, -Mnodclchk (default) — require / don't require that all variables be declared. (The "no vibes allowed, declare everything" switch.)
• -Mdefaultunit, -Mnodefaultunit (default) — treat / don't treat '*' as stdout/stdin regardless of the status of units 6/5. -Mnodefaultunit causes * to be a synonym for 5 on input and 6 on output; -Mdefaultunit causes * to be a synonym for stdin on input and stdout on output.
• -Mdlines, -Mnodlines (default) — treat / don't treat lines beginning with D in column 1 as executable statements, ignoring the D.
• -Mdollar=char — sets the character used to replace dollar signs in names to be char. Default is an underscore (_). 🍓
• -Mextend — allows 132-column source lines. Long lines rights ✨
• -Mfixed — processes Fortran source using fixed form specifications. The -Mfree options specify free form formatting. By default, files with a .f or .F extension use fixed form formatting.
• -Mfree, -Mfreeform, -Mnofree, -Mnofreeform — processes Fortran source using free form specifications. The -Mnofree and -Mfixed options specify fixed form formatting. By default, files with a .f90, .F90, .f95 or .F95 extension use freeform formatting. 🦋
• -Mi4 (default), -Mnoi4 — treat / don't treat INTEGER as INTEGER*4. -Mnoi4 treats INTEGER as INTEGER*2.
• -Miomutex, -Mnoiomutex (default) — generate / don't generate critical section calls around Fortran I/O statements.
• -Mlibsuffix=suffix — declares that a file with this suffix is an object library file.
• -Mllalign (default), -Mnollalign — align / don't align long longs or INTEGER*8 in structures or common blocks on 8-byte boundaries. -Mllalign is the default.
• -Mnomain — when the link step is called, don't include the object file which calls the Fortran main program. Super useful for using the nvfortran driver to link programs with the main program written in C or C++ and one or more subroutines written in Fortran. iykyk 🔥
• -Mobjsuffix=suffix — declares that a file with this suffix is a binary object file.
• -Monetrip, -Mnoonetrip (default) — force / don't force each DO loop to be iterated at least once.
• -Mr8, -Mnor8 (default) — treat / don't treat REAL as DOUBLE PRECISION and real constants as double precision constants.
• -Mr8intrinsics [=float], -Mnor8intrinsics (default) — treat / don't treat the intrinsics CMPLX as DCMPLX and REAL as DBLE.
  • float — also treat the FLOAT intrinsic as DBLE.
• -Mrecursive, -Mnorecursive (default) — allocate / don't allocate local variables on the stack, thus allowing recursion. ⚠️ SAVEd, data-initialized, or namelist members are always allocated statically, regardless of the setting of this switch.
• -Mref_externals, -Mnoref_externals (default) — force / don't force references to names appearing in EXTERNAL statements.
• -Msave, -Mnosave (default) — assume / don't assume that all local variables are subject to the SAVE statement. -Msave may allow many older Fortran programs to run but can greatly reduce performance. 😭 (the tradeoff is real)
• -Msignextend (default), -Mnosignextend — sign extend / don't sign extend when a narrowing conversion overflows. For example, when -Msignextend is in effect and an integer containing the value 65535 is converted to a short, the value of the short will be -1. ⚠️ ANSI C specifies that the result of such conversions are undefined.
• -Mstack_arrays, -Mnostack_arrays (default) — allocate automatic arrays on the stack (on the heap).
• -Mstandard — flags non-ANSI-Fortran usage. The compiler is snitching, but affectionately 💅
• -Msyntax-only — performs only syntax checking, semantic checking, and Fortran module (.mod) file generation. Like a vibe check but for your code.
• -Munixlogical, -Mnounixlogical (default) — when -Munixlogical is in effect, a logical is considered to be .TRUE. if its value is non-zero and .FALSE. otherwise. When -Mnounixlogical is in effect (the default), a logical is considered to be .TRUE. if its value is odd and .FALSE. if its value is even.
• -Mupcase, -Mnoupcase (default) — preserve / don't preserve case in names. -Mnoupcase causes all names to be converted to lower case. ⚠️ Note that, if -Mupcase is used, then variable name 'X' is different than variable name 'x', and keywords must be in lower case. Case-sensitive Fortran era, we're living it 🎀
• -module directory — save/search for module files in directory.
• -Munlink_module — instructs nvfortran to unlink a symlink to the desired module file before writing out the module file. Without this option, nvfortran will follow the symlink and write the module file to the symlink's target, provided it has permission to write there.
• -r4 — interpret DOUBLE PRECISION variables as REAL.
• -r8 — interpret REAL variables as DOUBLE PRECISION. Equivalent to using the options -Mr8 and -Mr8intrinsics.
• -Wh,option[,option...] — passes each comma-delimited option to the Fortran 90/95 front end.

---

🎯 Target-specific Options 🎯

Accelerator time, bestie — let's get this code running on the fancy hardware 👑

-acc

• -acc — enables OpenACC pragmas and directives to explicitly parallelize regions of code for execution by accelerator devices. See the -gpu flag to select options specific to NVIDIA GPUs. The options are:
  • autopar (default), noautopar — enable loop autoparallelization within parallel constructs.
  • gpu (default) — compile OpenACC directives for parallel execution on the GPU.
  • host — compile OpenACC directives for serial execution on the host CPU.
  • legacy — suppress warnings about deprecated PGI accelerator directives.
  • multicore — compile OpenACC directives for parallel execution on the host CPU.
  • routineseq, noroutineseq (default) — compile every routine for the device, as if it had a routine seq directive.
  • strict — issue warnings when accelerator directives are encountered which do not adhere to the OpenACC standard.
  • sync — ignore async clauses, and run every data transfer and kernel launch on the default sync queue.
  • verystrict — abort compilation with a fatal error when an accelerator directive is encountered which does not adhere to the OpenACC standard. 😤 no notes, no mercy.
  • wait (default), nowait — wait for each compute kernel to finish.
• -noacc — disables OpenACC directives and does not link with OpenACC libraries.

-gpu=option

• -gpu=option — use the following sub-options to tailor the compilation of target accelerator regions:

okay bestie, we're still deep in the -gpu sub-option buffet — grab a plate, we're not done yet 🍓

• autocompare — automatically compares CPU and GPU results for you. Accelerated code sections get run in redundant mode, and data gets compared whenever it would normally be shuffled off the accelerator. Free vibe check on your math ✨
• ccXY — generates code for a device with compute capability XY. You can list multiple compute capabilities and it'll make one version for each. By default the compiler sniffs out the compute capability of every GPU you've got installed. Peep -help -gpu to see which compute capabilities are valid for your install 👀
• ccall — generates code for all the compute capabilities supported for this target and by the CUDA Toolkit version you picked. Go big or go home 💅
• ccnative — detects the visible GPUs on your system and generates code for them. If no device is available, it falls back to the default compute capability, which is cc50.
• ccall-major — compiles for all major supported compute capabilities. Heads up though: it does not include PTX for the highest major virtual architecture — for that support, see the -gpu=[no]rdc option.
• cudaX.Y — uses CUDA X.Y Toolkit compatibility, where it's installed.
• deepcopy — enables Full Deepcopy support in OpenACC Fortran.
• fastmath — turns on the fast math library. It's got faster but lower precision implementations of certain math and intrinsic functions. Speed ✨ accuracy 🤏
• flushz, noflushz (default) — enable (or disable) flush-to-zero mode on the GPU.
• fma, nofma — generate (or don't) fused multiply-add operations on the GPU. This one's enabled by default at optimization level -O1.
• implicitsections, noimplicitsections (default) — change (or don't change) array element references in OpenACC and OpenMP data clauses into array section references.
• interceptdeallocations, nointerceptdeallocations — intercept (or don't intercept) LIBC function calls like free, and call the matching CUDA memory deallocation version if the address is in pinned or managed memory, and the regular version otherwise.
• keepbin — keeps the generated CUDA binary, with a .cubin suffix.
• keepgpu — keeps the generated CUDA GPU source files, with a .gpu suffix.
• keepltoir — keeps the generated GPU LTOIR files, with a .ltoir suffix. Only works when -gpu=lto is enabled.
• keepptx — keeps the generated portable assembly files, with a .ptx suffix.
• lineinfo, nolineinfo (default) — generate debugging line information.
• loadcache:[L1|L2] — generates code that caches global memory loads in the L1 or L2 hardware cache. Pick your cache bestie 💜
• lto — enables Device Link Time Optimization (Device LTO).
• maxregcount:n — sets the maximum number of registers to use in the generated GPU code.
• managed — allocates any dynamically allocated data in CUDA Managed memory. This option must appear in both the compile and link lines, and it may not be used with -gpu=pinned.
  • intercept — intercepts LIBC function calls like free, and calls their managed memory version if the address is in managed memory, and the regular version otherwise.
• nomanaged — do not allocate any dynamically allocated data in CUDA Managed memory. Use it with -stdpar to stop that flag's implicit use of -gpu=managed when CUDA Managed memory capability gets detected.
• nounified — do not compile for CUDA Unified memory capability. Use it with -stdpar to stop that flag's implicit use of -gpu=unified when CUDA Unified memory capability gets detected.
• pinned — allocates any dynamically allocated data in CUDA Pinned host memory. This option must appear in both the compile and link lines, and it may not be used with -gpu=managed|unified.
  • intercept — intercepts LIBC function calls like free, and calls their pinned memory version if the address is in pinned memory, and the regular version otherwise.
• mem:[mode] — picks your GPU memory mode, one of: separate, managed, unified. This one cannot be combined with -gpu=pinned, gpu=managed or -gpu=unified. Rude of it? maybe. Accurate? absolutely 💀
  • mem:separate — all data lives in separate CPU and GPU memories, and explicit memory copies happen when data is accessed from both CPU and GPU.
  • mem:managed — allocates any dynamically allocated data in CUDA Managed Memory. Data that isn't dynamically allocated sits in separate GPU memory and gets copied explicitly between CPU and GPU memories. This option must appear in both the compile and link lines.
  • mem:unified — compiles for full CUDA Unified Memory capability, where system memory is accessible from the GPU. Every variable in the CPU code is accessible from the GPU without explicit directives or attributes. This mode uses system and managed memory for dynamically allocated data unless you set explicit behavior through the -gpu=mem:unified:[no]managedalloc subflags. This option must appear in both the compile and link lines.
• mem:unified:managedalloc, mem:unified:nomanagedalloc — allocate (or do not allocate) any dynamically allocated data in CUDA Managed Memory.
• mem:separate:pinnedalloc, mem:separate:nopinnedalloc — allocate (or do not allocate) any dynamically allocated data in CUDA Pinned host memory.
• ptxinfo — prints ptxas information.
• rdc (default), nordc — generate (or don't generate) relocatable device code for separate compilation, and invoke the device linker before the host linker at the link step.
• redundant — runs accelerated code redundantly on the CPU. It's implied by autocompare.
• safecache — allows variable-sized array sections in cache directives; the compiler just assumes they fit into CUDA shared memory. Living dangerously, love that for you 🙈
• sm_XY — generates code for a device with compute capability XY. Multiple compute capabilities are allowed and you get one version for each. By default the compiler detects the compute capability for every installed GPU. Run -help -gpu to see the valid compute capabilities for your installation.
• stacklimit:limit (default), nostacklimit — ⚠️ this option has been deprecated and will be removed in a future release. It gives an error if the total stack size of a kernel or procedure goes over limit KBytes. The default is stacklimit:512.
• tripcount:host — calculates loop trip counts on the host for some compute constructs. This is the default behavior when -gpu=tripcount isn't specified. Heads up: this behavior is not compliant with the OpenACC specification — if you need compliance, please use -gpu=tripcount:device.
• tripcount:device — calculates loop trip counts on the device for some compute constructs. This behavior is compliant with the OpenACC specification, though it's not the default. To explicitly turn the default back on, please use -gpu=tripcount:host.
• tripcount:warn, tripcount:nowarn — enable (or disable) compile-time warnings for when loop trip counts get calculated on the host instead of on the device.
• tripcount:check, tripcount:nocheck — insert (or don't insert) runtime checks making sure the trip count calculated on the device matches the one calculated on the host. To get differences reported, set the environment variable NVCOMPILER_ACC_CHECK_TRIPCOUNT.
• unified — compiles for CUDA Unified memory capability, where system memory is accessible from the GPU. All variables in the CPU code are accessible from the GPU without explicit directives or attributes. This mode uses system and managed memory for dynamically allocated data unless explicit behavior is set through -gpu=[no]managed. This option must appear in both the compile and link lines, and it may not be used with -gpu=pinned.
  • intercept — intercepts LIBC function calls like free, and calls their unified version if the address is in unified memory, and the regular version otherwise.
• unroll, nounroll — automatically (or don't) unroll inner loops. This is enabled by default at optimization level -O3. She unrolls 💅

---

• -Kieee, -Knoieee (default) — performs floating-point operations in strict conformance with the IEEE 754 standard. Some optimizations get disabled with -Kieee, and a more accurate math library is used. The default -Knoieee goes for faster but very slightly less accurate methods. Pick your fighter ⚔️
• -Ktrap=option[,option]... — controls how the processor behaves when floating-point exceptions pop off during program execution. Possible options include:
  • denorm — trap on denormalized operands.
  • divz — trap on divide by zero.
  • fp — trap on floating-point exceptions.
  • inexact — trap on inexact result.
  • inv — trap on invalid operation.
  • none (default) — disables all traps. Note that -Ktrap=inv,none,ovf implies -Ktrap=ovf.
  • ovf — trap on floating-point overflow.
  • unf — trap on floating-point underflow. btw -Ktrap is only meaningful when compiling a C/C++ main function or a Fortran main program.

-Ktrap=fp is shorthand for -Ktrap=divz,inv,ovf. Saved you some typing, you're welcome 🫶

...these options are literally the processor's floating-point exception mask bits, bestie. Normally the processor's exception mask bits are enabled, meaning floating-point exceptions are masked — the processor recovers from the exception and keeps going. But if a mask bit is off (unmasked) and the matching exception happens, execution terminates with a floating-point exception (Linux FPE signal). 💅

• -march=target — same exact thing as -tp, so go peek at -tp for the details, iykyk.
• -m[no-]daz-ftz — tells the processor how denormals are handled at runtime. -mno-daz-ftz means denormal operands and results are honored; it's shorthand for -Mnodaz -Mnoflushz. -mdaz-ftz is the default setting and says denormal operands and results get treated as zero — shorthand for -Mdaz -Mflushz.
• -Mdaz, -Mnodaz — enable [disable] mode to treat denormal (subnormal) floating-point operands as zero. -Mdaz is the default setting for x86_64 and aarch64 processors.
• -Mflushz, -Mnoflushz — enable [disable] setting floating-point denormal (subnormal) results to zero. -Mflushz is the default setting for x86_64 and aarch64 processors.
• -Mfpmisalign, -Mnofpmisalign — allow (don't allow) vector arithmetic instructions with memory operands that are not aligned on 16-byte boundaries.
• -Mfprelaxed [=option[,option,...]], -Mnofprelaxed (default) — perform (don't perform) certain floating-point operations using relaxed precision when it improves speed. The options are:
  • div — perform divide using relaxed precision.
  • intrinsic — perform certain intrinsic functions using relaxed precision.
  • order, noorder — allow (don't allow) expression reordering, including factoring such as computing a*b+a*c as a*(b+c).
  • recip — perform reciprocal operations using relaxed precision.
  • rsqrt — perform reciprocal square root (1/sqrt) using relaxed precision.
  • sqrt — perform square root using relaxed precision.

With no options, -Mfprelaxed will choose to generate relaxed precision code for those operations that generate a significant performance improvement, depending on the target processor. ✨

• -Mfunc32 (default), -Mnofunc32 — align (don't align) functions on 32 byte boundaries.
• -Mlongbranch, -Mnolongbranch (default) — enable (disable) long branches.
• -Msecond_underscore, -Mnosecond_underscore (default) — add (don't add) a second underscore to the name of a Fortran global if its name already contains an underscore. This one is useful for maintaining compatibility with g77, which adds a second underscore to such symbols by default. 🫶
• -Mvarargs, -Mnovarargs (default) — generate code for calls made from Fortran to C routines to use the varargs calling sequence.
• -Mwritable-strings — store string constants in the writable data segment.
• -mcmodel=small|medium — pick your memory model vibe:
  • small — limits the combined area for a user's object or executable to 4GB. The maximum code size is 2GB.
  • medium — allows unrestricted data size. The maximum code size is 2GB. 👑
• -stdpar=option — enable (ISO Fortran 2018) DO-CONCURRENT. Options are:
  • gpu — (ISO Fortran 2018) DO-CONCURRENT is compiled for parallel execution on the GPU. This option implies -gpu=unified on targets with Unified memory capability and -gpu=managed otherwise.
  • multicore — (ISO Fortran 2018) DO-CONCURRENT is compiled for parallel execution on the CPU.
• -nostdpar — execute (ISO Fortran 2018) DO-CONCURRENT sequentially.
• -ta=target — this option has been deprecated, please refer to -acc. 😭
  • -ta=tesla — this option has been deprecated, please refer to -acc=gpu and -gpu.
  • -ta=multicore — this option has been deprecated, please refer to -acc=multicore.
  • -ta=host — this option has been deprecated, please refer to -acc=host.
• -target=option — select the target for all parallel programming paradigms used (OpenACC, OpenMP, Standard Languages). The possibilities are:
  • gpu — globally set the target device to an NVIDIA GPU.
  • multicore — globally set the target device to the host CPU.
• -tp=target — specify the type of the target processor. Issue:

nvfortran -help -tp

to display the list of recognized target processors. 🧚

---

📁 FILES 📁

• a.out — executable output file
• file.a — library of object files
• file.f — fixed-format Fortran source file
• file.F — fixed-format Fortran source file that requires preprocessing
• file.f90 — free-format Fortran source file
• file.F90 — free-format Fortran source file that requires preprocessing
• file.f95 — free-format Fortran source file
• file.F95 — free-format Fortran source file that requires preprocessing
• file.f03 — free-format Fortran source file
• file.F03 — free-format Fortran source file that requires preprocessing
• file.for — fixed-format Fortran source file
• file.fpp — fixed-format Fortran source file that requires preprocessing
• file.cuf — free-format CUDA Fortran source file
• file.CUF — free-format CUDA Fortran source file that requires preprocessing
• file.ipa — InterProcedural Analyzer (IPA) file
• file.ipo — InterProcedural Analyzer (IPA) file
• file.o — object file
• file.s — assembler source file
• .mynvfortranrc — you may add custom switches or make other additions to nvfortran by creating a file named .mynvfortranrc in your home directory. 🏠

The installation of this version of the compiler resides in Basedir/Linux_x86_64/dev/; other versions may coexist in Basedir/Linux_x86_64/release/. Basedir is the root of the compiler installation directory, specified by the installer. The default is /opt/nvidia/hpc_sdk. 💾

The compiler installation subdirectories are:

• compilers/bin/ — compiler and tool executables and configuration files (rcfiles).
• compilers/include/ — compiler include files.
• compilers/lib/ — runtime libraries and object files.
• comm_libs/ — communication libraries, including NCCL and NVSHMEM.
• math_libs/ — math libraries, including cuBLAS, cuTENSOR, cuSPARSE, cuFFT, cuSOLVER, and cuRAND.
• profilers/ — profilers, including Nsight Compute and Nsight Systems.

---

👀 SEE ALSO 👀

nvc (1), nvc++ (1), and the NVIDIA User's Guide. Go read those too, bestie. 📚

---

🚨 DIAGNOSTICS 🚨

The compiler produces information and error messages as it translates the input program. The linker and assembler may issue their own error messages, so don't blame the compiler for everything, okay? 😭💀

---

That's the whole page, periodt. 🎀 This page is from September 2026, and it's the pgf77(1) manual page — go off and compile something iconic, bestie. 💖✨🌈