SYNOPSIS

       pgf90 [ -flag ]...  sourcefile...


DESCRIPTION

       pgf90  is  the interface to The Portland Group Inc. (PGI) Fortran 90/95
       compiler for AMD64 and IA32/EM64T processors.  pgf90 invokes  the  For-
       tran compiler, assembler, and linker with options derived from its com-
       mand line arguments.  pgf90 is an alias for pgfortran.

       Suffixes of source file names indicate the type  of  processing  to  be
       done:

       .f     fixed-format Fortran source; compile
       .F     fixed-format Fortran source; preprocess, compile
       .f90   free-format Fortran source; compile
       .F90   free-format Fortran source; preprocess, compile
       .f95   free-format Fortran source; compile
       .F95   free-format Fortran source; preprocess, compile
       .f03   free-format Fortran source; compile
       .F03   free-format Fortran source; preprocess, compile
       .for   fixed-format Fortran source; compile
       .FOR   fixed-format Fortran source; preprocess, compile
       .ftn   fixed-format Fortran source; compile
       .FTN   fixed-format Fortran source; preprocess, compile
       .fpp   fixed-format Fortran source; preprocess, compile
       .FPP   fixed-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

       If  coinstalled with pgcc, C file suffixes are also recognized and com-
       piled with the pgcc compiler; see pgcc and  PGI  User’s  Guide.   Other
       files are passed to the linker (if linking is requested) with a warning
       message.

       Unless one overrides the default action using  a  command-line  option,
       pgf90  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 pgf90 command, the intermediate object
       file is also deleted.  Linking is the last stage of  the  compile  pro-
       cess,  unless  you  use one of the -c, -E, -F, or -S options, or unless
       compilation errors stop the whole process.


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.

       Overall Options
              -M[no]stride0 -M[no]unroll=option -M[no]unsafe_par_align
              -M[no]vect=option -M[no]zerotrip -mp[=option] -Olevel -pg

       Debugging Options
              -C -g -gopt -M[no]bounds -Mchkfpstk -Mchkptr -Mchkstk -Mcoff
              -Mdwarf1 -Mdwarf2 -Mdwarf3 -Melf -Mnodwarf -M[no]pgicoff
              -[no]traceback

       Preprocessor Options
              -Dmacro -E -F -Idirectory
              -Mcpp=[[no]comment|m|md|mm|mmd|suffix:suff] -Mnostddef
              -Mnostdinc -Mpreprocess -Uname -YI,directory -Yp,directory

       Assembler Options
              -Wa,argument[,argument]...  -Ya,directory

       Linker Options
              -acclibs --[no-]as-needed -Bdynamic -Bstatic -Bstatic_pgi
              -g77libs -llibrary -Ldirectory -m -M[no]eh_frame -Mlfs
              -Mmpi=option -Mnostartup -Mnostdlib -M[no]rpath -Mscalapack
              -pgcpplibs -pgf77libs -pgf90libs -r -Rdirectory -rpath directory
              -s -shared -soname name -uname --[no-]whole-archive
              -Wl,argument[,argument]...  -YC,directory -Yl,directory
              -YL,directory -YS,directory -YU,directory

       Language Options
              -asmsuffix=suffix -byteswapio -csuffix=suffix -fsuffix=suffix
              -FSUFFIX=suffix -i2 -i4 -i8 -i8storage -Mallocatable[=95|03]
              -M[no]backslash -Mbyteswapio -Mcray=pointer -Mcuda=option
              -M[no]dalign -M[no]dclchk -M[no]defaultunit -M[no]dlines
              -Mdollar=char -Mextend -Mfixed -M[no]free[form] -M[no]i4
              -M[no]iomutex -Mlibsuffix=suffix -M[no]llalign -Mnomain
              -Mobjsuffix=suffix -M[no]onetrip -M[no]r8
              -M[no]r8intrinsics=float -M[no]recursive -M[no]ref_externals
              -M[no]save -M[no]signextend -Mstandard -M[no]unixlogical
              -M[no]upcase -module directory -r4 -r8

       Target-specific Options
              -K[no]ieee -Ktrap=option -M[no]daz -M[no]flushz
              -M[no]fpapprox=option -M[no]fpmisalign -M[no]fprelaxed=option
              -M[no]func32 -M[no]large_arrays -M[no]longbranch -M[no]loop32
              -M[no]second_underscore -M[no]varargs -Mwritable-strings -m32
              -m64 -mcmodel=small|medium -pc val -ta=target -tp=target

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



Overall Options

       --        Anything after this switch is treated as a filename.  Note
                 that most tools will not allow a filename starting with a

       -dryrun   Use this option to display the invocations of the compiler,
                 assembler, and linker but do not execute them.

       -drystdinc
                 Display the standard include directories without invoking the
                 compiler.

       --flagcheck
                 Don’t compile anything; just emit any messages for command-
                 line switch errors.  Return a success error code if there are
                 no command-line switch errors.

       -flags    Display all valid pgf90 command-line options in alphabetical
                 order.

       -help[=option]
                 Displays command-line options recognized by pgf90 on the
                 standard output.  pgf90 -help -otherswitch will give help
                 about -otherswitch.  The default is to list pgf90 command
                 line options by group; 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 pgf90 configuration; this is the same as
                          -show.
                           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.

       -Mkeepasm Keep the assembly file for each source file, but continue 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 an
                 warning message; the default behavior is to print an error
                 message and halt.

       -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 pgf90 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 pgf90
                 configuration.

       -silent   Do not print warning messages. Same as -Minform=severe.

       -time     Print execution times for the various steps in the compiler
                 itself.

       -v        Verbose mode; print out the command line for each tool before
                 it is executed.

       -V        Display version messages and other information.
                 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
              pgf90 -fast -help to see the equivalent switches.  Note this
              sets the optimization level to a minimum of 2; see -O.

       -fastsse
              Chooses generally optimal flags for a processor that supports
              SSE instructions (Pentium 3/4, AthlonXP/MP, Opteron) and SSE2
              (Pentium 4, Opteron).  Use pgf90 -fastsse -help to see the

       -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.

       -Mconcur[=option[,option,...]]
              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  Use all available cores when the environment variables
                        OMP_NUM_THREADS and NCPUS are not set.  This must be
                        specified at link time.

              bind      Bind threads to cores or processors.  This must be
                        specified at link time.

              altcode:n noaltcode
                        Generate (don’t generate) alternate scalar code for
                        parallelized loops.  The parallelizer generates scalar
                        code to be executed whenever the loop count is less
                        than or equal to n.  If noaltcode is specified, the
                        parallelized version of the loop is always executed
                        regardless of the loop count.

              altreduction[:n]
                        Generate alternate scalar code for parallelized loops
                        containing a reduction.  If a parallelized loop
                        contains a reduction, the parallelizer generates
                        scalar code to be executed whenever the loop count is
                        less than or equal to n.

              assoc (default) noassoc
                        Enable (disable) parallelization of loops with
                        reductions.

              cncall nocncall (default)
                        Assume (don’t assume) that loops containing calls are
                        safe to parallelize. Also, no minimum loop count
                        threshold must be satisfied before parallelization
                        will occur, and last values of scalars are assumed to
                        be safe.


              innermost noinnermost (default)
                        Enable (disable) parallelization of innermost loops.

              levels:n  Parallelize loops nested at most n levels deep; the
                        default is 3.

              numa nonuma
                        (Linux only) Use (don’t use) thread/processor affinity
                        for NUMA architectures; use this option when linking
                        the program.  -Mconcur=numa will link in a numa
                        library and objects to prevent the operating system
                        from migrating threads from one processor to another.

       -Mdepchk (default) -Mnodepchk
              Assume (don’t assume) that potential data dependencies exist.
              -Mnodepchk may result in incorrect code.

       -Mdse -Mnodse (default)
              Enable (disable) the dead store elimination optimization.

       -Mextract=[option[,option,...]]
              Run the subprogram extraction phase to prepare for inlining.
              The =lib:filename option must be used with this switch to name
              an extract library.  See -Minline for more details on inlining.

              subprogram[,subprogram]
                     A non-numeric option not containing 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 less statements are extracted.  If
                     both number and function are specified, then functions
                     matching the given name(s) or meeting the size
                     requirements, are extracted.

       -Mframe -Mnoframe (default)
              Set up (don’t set up) a true stack frame pointer for functions;
              -Mnoframe allows slightly more efficient operation when a stack
              frame is not needed, but some options override -Mnoframe.

       -Minfo[=option[,option,...]]
                        inlined.

              intensity Emit compute intensity information about loops.

              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.

              unified   Emit information about which routines are selected for
                        target-specific optimizations using the PGI Unified
                        Binary.

              vect      Emit information about automatic loop vectorization.
       With no options, -Minfo is the same as
       -Minfo=accel,inline,ipa,loop,lre,mp,opt,par,unified,vect.

       -Minline[=option[,option,...]]
              Pass 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.

              [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.

              [size:]number
                        A numeric option is assumed to be a size.  Functions

              (linux86-64 only) Generate additional code to enable function-
              level instrumentation.  This option implies -Minfo=ccff and
              -Mframe.  The option is

              functions (default)

       -Mipa [=option[,option,...]] -Mnoipa (default)
              Enable and specify options for InterProcedural Analysis (IPA).
              This also sets the optimization level to a minimum of 2; see -O.
              If no option list is specified, then it is equivalent to
              -Mipa=const.  The options are:

              align noalign (default)
                        Enable (disable) recognition when pointer targets are
                        all cache-line aligned, allowing better SSE code
                        generation.

              arg noarg (default)
                        Remove (don’t remove) arguments replaced by
                        -Mipa=ptr,const.  -Mipa=noarg implies
                        -Mipa=nolocalarg.

              cg nocg (default)
                        Generate information for the pgicg call graph display
                        tool.  Run pgicgexecutable to see the call graph
                        information.

              const (default) noconst
                        Enable (disable) propagation of constants across
                        procedure calls.

              f90ptr nof90ptr (default)
                        Enable (disable) Fortran 90 pointer disambiguation
                        across procedure calls.

              fast      Chooses generally optimal -Mipa flags for the target
                        platform; use pgf90 -Mipa -help to see the equivalent
                        options.

              force     Force all objects to recompile regardless of whether
                        IPA information has changed.

              globals noglobals (default)
                        Analyze (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.


              keepobj (default) nokeepobj
                        Keep (don’t keep) the optimized object files, using
                        file name mangling, to reduce recompile time in
                        subsequent application builds.

              libc nolibc (default)
                        Optimize calls to certain standard C library routines.

              libinline nolibinline (default)
                        Allow (don’t allow) inlining from routines in
                        libraries; -Mipa=libinline implies -Mipa=inline.

              libopt nolibopt (default)
                        Allow (don’t allow) recompiling and reoptimizing
                        routines from libraries with IPA information.

              localarg nolocalarg (default)
                        Enable (disable) feature to externalize local
                        variables to allow arguments to be replaced by
                        -Mipa=ptr.  -Mipa=localarg implies -Mipa=arg.

              main:func Specify a function to serve as a global entry point;
                        may appear multiple times; disables linking.

              ptr noptr (default)
                        Enable (disable) pointer disambiguation across
                        procedure calls.

              pure nopure (default)
                        Detect (don’t detect) pure functions.

              quiet     Don’t print out messages about which files are
                        recompiled at link time.

              required  Return an error condition if IPA is inhibited for any
                        reason, rather than the default behavior of linking
                        without IPA optimization.

              safe:[function|library]
                        Declares that the named function, or all functions in
                        the named library are safe; a safe procedure does not
                        call back into the known procedures and does not
                        change any known global variables.  Without
                        -Mipa=safe, any unknown procedures will cause IPA to
                        fail.

              safeall nosafeall (default)
                        Declares that all unknown functions are safe (not
                        safe); see -Mipa=safe.

              shape noshape (default)

       -Mmovnt -Mnomovnt
              Force (disable) generation of nontemporal moves.  -Mmovnt used
              with -fastsse can sometimes be faster than -fastsse alone.
              -Mnomovnt also disables -Mvect=movntaltcode.  By default
              nontemporal moves are generated for loops with large loop
              counts.

       -Mneginfo=option[,option...]
              Instructs the compiler to produce information on why certain
              optimizations are not performed.  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 to be used in a subsequent
              compile; -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 (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, which contains
              the result of an execution of the program compiled with -Mpfi.
              The options are:

              indirect noindirect (default)
                        Enable (disable) indirect function call inlining; this
                        requires a pgfi.out file generated from a binary built
                        with -Mpfi=indirect.

              layout (default) nolayout
                        Enable (disable) basic block layout to take 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

              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.  Use of 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, PGI-style profiling
              implies compiler-generated source instrumentation.  MPICH-style
              profiling implies the use of instrumented wrappers for MPI
              library routines.  The -Mprof options are:

              ccff

              dwarf     Generate limited DWARF symbol information sufficient
                        for most performance profilers.

              func      Perform PGI-style function level profiling.

              hwcts     Generate a profile using event-based sampling of
                        hardware counters via the PAPI interface (linux86-64
                        only, PAPI must be installed).

              lines     Perform PGI-style line level profiling.

              hpmpi     (PGI CDK only) Perform MPICH-style profiling for the
                        HP Implies -Mmpi=hpmpi.

              mpich1    (PGI CDK only) Perform MPICH-style profiling for
                        MPICH-1.  Implies -Mmpi=mpich1.

              mpich2    (PGI CDK only) Perform MPICH-style profiling for
                        MPICH-2.  Implies -Mmpi=mpich2.

              mvapich1  (PGI CDK only) Perform MPICH-style profiling for
                        MVAPICH.  Implies -Mmpi=mvapich1.

              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

              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.

       -Mscalarsse -Mnoscalarsse
              Utilize (don’t use) SSE (Pentium 3, 4, AthlonXP/MP, Opteron) and
              SSE2 (Pentium 4, Opteron) instructions to perform the operations
              coded. This requires the assembler to be capable of interpreting
              SSE/SSE2 instructions.  The default is -Mscalarsse for Opteron
              in 64-bit mode, and -Mnoscalarsse otherwise.

       -Msmart -Mnosmart (default)
              Enable (disable) optional AMD64-specific post-pass instruction
              scheduling.

       -Msmartalloc=option[,...] -Mnosmartalloc (default)
              Add (don’t add) a call to the routine mallopt in the main
              routine; this can have a dramatic impact on the performance of
              programs that dynamically allocate memory.  To be effective,
              this switch must be specified when compiling the file containing
              the Fortran, C, or C++ main routine.  This is currently only
              available on 64-bit Linux systems.  The behavior of -Msmartalloc
              can be modified with the following options:

              huge      Link in the huge page runtime library, so dynamic
                        memory will be allocated in huge pages.

              huge:n    Link in the huge page runtime library and allocate n
                        huge pages.

              hugebss   (x86-64 only) Link in the huge page runtime library
                        and allocate the BSS section (containing uninitialized
                        static symbols) in huge pages.  This requires that the
                        huge page runtime library be linked dynamically, so
                        the -rpath option for that directory will be added
                        regardless of the setting of -Mnorpath.

              nohuge    Override any previous -Msmartalloc=huge or
                        -Msmartalloc=hugebss switches; do not link in the huge
                        page runtime library.

       -Mstride0 -Mnostride0 (default)
              Generate (don’t generate) alternate code for a loop that
              contains an induction variable whose increment may be zero.

       -Munroll[=option[,option...]] -Mnounroll (default)
              Invoke (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       Instructs the compiler to completely unroll loops with
                        a constant loop count less than or equal to m, a

              -Mnounroll instructs the compiler not to unroll loops.

       -Munsafe_par_align -Mnounsafe_par_align
              Use (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 -Mscalarsse or -Mvect=sse.  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; see -O.  If no option list
              is specified, then the following vector optimizations are used:
              assoc,cachesize:c,nosse, where c is the actual cache size of the
              machine.  The -Mvect options are:

              altcode (default) noaltcode
                        Enable (disable) alternate code generation for vector
                        loops, depending on such characteristics as array
                        alignments and loop counts.

              assoc (default) noassoc
                        Enable (disable) certain associativity conversions
                        that can change the results of a computation due to
                        floating point roundoff error differences.  A typical
                        optimization is to change the order of additions,
                        which is mathematically correct, but can be
                        computationally different, due to roundoff error.

              cachesize:number (default=automatic)
                        Instructs the vectorizer, when performing cache tiling
                        optimizations, to assume a cache size of number.

              fuse nofuse (default)
                        Enable (disable) loop fusion to combine adjacent loops
                        into a single loop.

              gather (default) nogather
                        Enable (disable) vectorization of loops with indirect
                        array references.

              idiom noidiom (default)
                        Enable idiom recognition; this currently has no
                        effect.

              levels:n  Set maximum nest level of loops to optimize.

              partial   Enable partial loop vectorization via innermost loop
                        distribution.

              prefetch  Use prefetch instructions in loops where profitable.
              sizelimit[:number] nosizelimit (default)
                        Limit the size of loops that are
                        vectorized; the default is to attempt to
                        vectorize all loops.

              sse nosse (default)
                        Use (don’t use) SSE, SSE2, 3Dnow, and
                        prefetch instructions in loops where
                        possible.

              tile notile (default)
                        Enable (disable) loop tiling to optimize
                        for cache locality.

              uniform nouniform (default)
                        Perform the same optimizations in the
                        vectorized and residual loops.  This may
                        affect the performance of the residual
                        loop.

       -Mnovect disables the vectorizer, and is the default.

       -Mzerotrip (default) -Mnozerotrip
              Include (don’t include) a zero-trip test for
              loops.  Use -Mnozerotrip only when all loops are
              known to execute at least once.

       -mp[=option]
              Interpret OpenMP pragmas to explicitly parallelize
              regions of code for execution by multiple threads
              on a multi-processor system. Most OpenMP pragmas
              as well as the SGI parallelization pragmas are
              supported. See Chapters 5 and 6 of the PGI User’s
              Guide for more information on these pragmas.  The
              options allowed are:

              align noalign (default)
                        Modify (don’t modify) default loop
                        iteration scheduling to align iterations
                        with array references.  The default is
                        to use simple static scheduling.

              allcores  Use all available cores when the
                        environment variables OMP_NUM_THREADS
                        and NCPUS are not set.  This must be
                        specified at link time.

              bind      Bind threads to cores or processors.
                        This must be specified at link time.

              numa nonuma
                        Use (don’t use) libraries to give

              optimization level is set to 2.  The optimization
              levels and their meanings are as follows:

              0         A basic block is generated for each C
                        statement. No scheduling is done between
                        statements. No global optimizations are
                        performed.

              1         Scheduling within extended basic blocks
                        is performed.  Some register allocation
                        is performed. No global optimizations
                        are performed.

              2         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.

              3         All level 1 and 2 optimizations are
                        performed.  In addition, this level
                        enables more aggressive code hoisting
                        and scalar replacement optimizations
                        that may or may not be profitable.

              4         All level 1, 2 and 3 optimizations are
                        performed.  In addition, hoisting of
                        guarded invariant floating point
                        expressions is enabled.

       -pg    (Linux only) Enable gprof-style sample-based
              profiling; implies -Mframe.



Debugging Options

       -C     Add array bounds checking; 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.
              Using -O0 the generated code will be slower than
              code generated at other optimization levels.

       -gopt  Generate symbolic debug information, without
              affecting optimizations.  This may give confusing
              results when debugging with optimizations; it is
              intended for use with other tools that use the
              debug information.

       -Mbounds -Mnobounds (default)

       -Mchkptr
              Check for unintended de-referencing of NULL
              pointers.

       -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.

       -Mdwarf1
              (IA-32 only) Generate DWARF1 debug information
              with -g.

       -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.

       -Mpgicoff -Mnopgicoff
              Generate additional symbolic debug 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 is 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.

       -F     Preprocess each file and leave the output in a
              file named file.f for each file named file.F.  No
              compilation, assembly, or linking is performed.

       -Idirectory
              Add directory to the compiler’s search path for
              include files.  For include files surrounded by <
                   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.

              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 any initial definition of name in the
              preprocessor. The only names predefined by the
              preprocessor itself are the standard ANSI C
              predefined macros. The driver may predefine other
              names (see the following description for the
              -Mnostddef option).  NOTE: ANSI C predefined
              macros can be defined and undefined on the command
              line, but not with #define and #undefine
              directives in the source.

       -YI,directory


Linker Options

       -acclibs
              Link-time option to add the accelerator libraries
              to the link line.

       --as-needed --no-as-needed
              (Linux only; not supported by all linkers) Passed
              to the linker.  Instructs 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
              (Linux only) Passed to the linker to specify
              dynamic binding.

       -Bstatic
              (Linux only) Passed to the linker to specify
              static binding.

       -Bstatic_pgi
              (Linux only) Statically link in the PGI libraries,
              while using dynamic linking for the system
              libraries; implies -Mnorpath.

       -g77libs
              (Linux only) Link-time option which allows object
              files generated by GNU g77 (or gcc) to be linked
              in to pgf90 main programs.

       -llibrary
              Passed to the linker; load the library
              liblibrary.a from the standard library directory.
              See also the -L option.

       -Ldirectory
              Add directory to the list of directories in which
              the linker searches for libraries.

       -m     Cause the linker to display a link map.

       -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.

       -Mlfs  (32-bit Linux only) Link in the Large File Support
              routines available on Linux versions later than
              MPICH-1 and MPICH-2 are set in localrc.  The -Mmpi
              options are:

              hpmpi     Select preconfigured HP-MPI libraries.

              mpich1    Select preconfigured MPICH-1 libraries.

              mpich2    Select preconfigured MPICH-2 libraries.

              mvapich1  Select preconfigured MVAPICH libraries.

              The user can set the environment variables MPIDIR
              and MPILIBNAME to override the default values for
              the MPI directory and library name.

       -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 PGI shared
              objects.  Use -Mnorpath to instruct the driver not
              to add any -rpath switches to the link line.

       -Mscalapack
              (PGI CDK only) Add the Scalapack libraries.

       -pgcpplibs
              Link-time option to add the C++ runtime libraries,
              allowing mixed-language programming.

       -pgf77libs
              Link-time option to add the pgf77 runtime
              libraries, allowing mixed-language programming.

       -pgf90libs
              Link-time option to add the pgf90 runtime
              libraries, allowing mixed-language programming.

       -r     Passed to the linker; generate a re-linkable
              object file.

       -Rdirectory
              (Linux only) Passed to the linker; always search
              directory for shared object files when running the
              generated executable.

              shared object, instructs the linker to set the
              internal DT_SONAME field to the specified name.

       -uname Passed to the linker; generate undefined
              reference.

       --whole-archive --no-whole-archive
              (Linux only) Passed to the linker.  Instructs the
              linker to include all objects in subsequent
              archive files.  --no-whole-archive restores the
              default behavior.

       -Wl,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
              Look in directory for the standard system library
              files.

       -YS,directory
              Look in directory for the standard system startup
              object files.

       -YU,directory
              Passed to the linker; change library search path.



Language Options

       -asmsuffix=suffix
              Define that a file with the given suffix is an
              assembly language file.

       -byteswapio
              Swap bytes from big-endian to little-endian or
              vice versa on input/output of unformatted Fortran
              data. Use of this option enables reading/writing
              of Fortran unformatted data files compatible with
              those produced on Sun or SGI systems.

       -csuffix=suffix
              Define that a file with the given suffix is a C
              source file.

       -fsuffix=suffix
              Define that a file with the given suffix is a

       -i8storage
              Allocates 8 bytes for INTEGER and LOGICAL.

       -Mallocatable[=95|03]
              Select whether to use Fortran 1995 or Fortran 2003
              semantics for assignments to allocatable objects
              and allocatable components of derived types.
              Fortran 1995 semantics require the user to
              allocate the object or component and that an array
              object or component be conformant before the
              assignment.  Fortran 2003 semantics require the
              compiler to add code to check whether the object
              or component is allocated and whether an array
              object is conformant before the assignment, and to
              allocate or reallocate if not.

       -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
              Swap bytes from big-endian to little-endian or
              vice versa on input/output of unformatted Fortran
              data. Use of this option enables reading/writing
              of Fortran unformatted data files compatible with
              those produced on Sun or SGI systems.

       -Mcray=pointer
              Force 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...]
              Enable CUDA Fortran extensions, and link with the
              CUDA Fortran libraries.  -Mcuda is required on the
              link line if there are no CUDA Fortran source
              files specified on the command line.  The options
              are:

              emu       Enable emulation mode; in emulation
                        mode, all code is executed on the host
                        processor, allowing host-level
                        debugging.
                        capability 1.3.

              cc2x      Generate code for the lowest compute
                        capability 2.x device that supports all
                        the features required in the program.

              cc20      Generate code for a device with compute
                        capability 2.0.

              cuda4.0   Use the CUDA 4.0 toolkit to build the
                        GPU code.

              4.0       An alias for -Mcuda=cuda4.0.

              fastmath  Use the faster (but lower precision)
                        versions of math library routines.

              flushz noflushz (default)
                        Enable (disable) flush-to-zero mode on
                        the GPU.

              keepbin   Keep the generated CUDA binary files,
                        with a .bin suffix.

              keepgpu   Keep the generated CUDA GPU source
                        files, with a .gpu suffix.

              keepptx   Keep the generated portable assembly
                        files, with a .ptx suffix.

              maxregcount:n
                        Set the maximum number of registers to
                        use in the generated GPU code.

              ptxinfo   Print the resource usage for each kernel
                        routine from the PTX assembler.
       Note that multiple compute capabilities can be specified,
       and one version will be generated for each capability
       specified.  The default is to generate one version for
       the lowest compute capability that will support all the
       features in the program, one version with compute
       capability 1.3, and if the CUDA 3.0 toolkit is used, one
       version with compute capability 2.0.

       -Mdalign (default) -Mnodalign
              Align (don’t align) doubles in structures on
              8-byte boundaries.  -Mnodalign may lead to data
              alignment exceptions.

       -Mdclchk -Mnodclchk (default)
              Require (don’t require) that all variables be
              declared.
              names to be char.  Default is an underscore (_).

       -Mextend
              Allow 132-column source lines.

       -Mfixed
              Process 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
              Process 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
              Define that a file with the given suffix is an
              object library file.

       -Mllalign -Mnollalign (default)
              Align (don’t align) long longs or INTEGER*8 in
              structures or common blocks on 8-byte boundaries.
              -Mnollalign is the default, and this is a change
              beginning with release 4.0. Releases prior to 4.0
              aligned long longs on 8-byte boundaries.

       -Mnomain
              When the link step is called, don’t include the
              object file which calls the Fortran main program.
              Useful for using the pgf90 driver to link programs
              with the main program written in C or C++ and one
              or more subroutines written in Fortran.

       -Mobjsuffix=suffix
              Define that a file with the given suffix is a
              binary object file.

       -Monetrip -Mnoonetrip (default)
              Force (don’t force) each DO loop to be iterated at
              least once.

              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.

       -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.

       -Mstandard
              Flag non-ANSI-Fortran usage.

       -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 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.

       -module directory
              Save/search for module files in directory

       -r4    Interpret DOUBLE PRECISION variables as REAL.

       -r8    Interpret REAL variables as DOUBLE PRECISION.
              Equivalent to using the options -Mr8 and
              -Mr8intrinsics.



Target-specific Options

       -Kieee -Knoieee (default)
              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 operands.

              none (default)
                      Disable all traps.

              ovf     Trap on floating point overflow.

              unf     Trap on floating point underflow.
       -Ktrap is only processed when compiling a main
       function/program.  -Ktrap=fp is equivalent to
       -Ktrap=divz,inv,ovf.  These options correspond to the
       processor’s exception mask bits.  Normally, the
       processor’s exception mask bits are on, meaning floating-
       point exceptions are masked; the processor recovers from
       the exception and continues.  If a mask bit is off
       (unmasked) and the corresponding exception occurs,
       execution terminates with floating point exception (Linux
       FPE signal).

       -Mdaz -Mnodaz
              Enable (disable) mode to treat denormalized
              floating point numbers as zero.  -Mdaz is default
              for -tp p7-64 targets; -Mnodaz is default
              otherwise.

       -Mflushz (default) -Mnoflushz
              Set SSE to flush-to-zero mode.

       -Mfpapprox [=option[,option,...]] -Mnofpapprox (default)
              Perform (don’t perform) certain single-precision
              floating point operations using low-precision
              approximation.  This can be very dangerous; the
              low-precision approximations are much faster than
              the full precision computation, but the results
              will be different.  This option should be used
              only with the utmost care.  The options are

              div       Approximate single precision floating
                        point division.

              rsqrt     Approximate single precision floating
                        point reciprocal square root.

              sqrt      Approximate single precision floating
              div       Perform divide 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.

       -Mlarge_arrays -Mnolarge_arrays (default)
              (linux86-64 only). Allow (don’t allow) arrays
              larger than 2GB; -Mlarge_arrays is default with
              -mcmodel=medium.

       -Mlongbranch -Mnolongbranch (default)
              Enable (disable) long branches.

       -Mloop32 -Mnoloop32 (default)
              Align (don’t align) innermost loops on 32 byte
              boundaries for -tp barcelona.

       -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 option is useful for maintaining
              compatibility with g77, which adds a second
              underscore to such symbols by default.

       -Mvarargs -Mnovarargs (default)
              (x86-64 only) Generate code for calls made from
              Fortran to C routines to use varargs calling
              sequence.

       -Mwritable-strings
              Store string constants in the writable data
              segment.

              exponent, and bit 79 is the sign bit. This 80-bit
              real format is the default format (called the
              extended format).  When values are loaded into the
              floating point stack they are automatically
              converted into extended real format.  The
              precision of the floating point stack can be
              controlled, however, by setting the precision
              control bits (bits 8 and 9) of the floating
              control word appropriately. In this way, the
              programmer can explicitly set the precision to
              standard IEEE double using 64 bits, or to single
              precision using 32 bits.  The default precision
              setting is system dependent.  If you use -pc to
              alter the precision setting for a routine, the
              main program must be compiled with the same value
              for -pc.  The command line option -pc val lets the
              programmer set the compiler’s precision
              preference. Valid values for val are:
                  32 single precision
                  64 double precision
                  80 extended precision
              Operations performed exclusively on the floating
              point stack using extended precision, without
              storing into or loading from memory, can cause
              problems with accumulated values within the extra
              16 bits of extended precision values.  This can
              lead to answers, when rounded, that do not match
              expected results.

       -ta=target
              Specify the type of the accelerator to which to
              target accelerator regions; accepted values are

              -ta=nvidia
                      Compile the accelerator regions for a
                      CUDA-enabled NVIDIA GPU.  Additional
                      suboptions valid after -ta=nvidia are:

                      analysis
                          Perform the analysis, but do not
                          generate GPU code.

                      nofma
                          Do not generate fused multiply-add
                          operations.

                      cc1x
                          Generate code for the lowest compute
                          capability 1.x device that supports
                          all the features required in the
                          program.

                          compute capability 1.3.

                      cc2x
                          Generate code for the lowest compute
                          capability 2.x device that supports
                          all the features required in the
                          program.

                      cc20
                          Generate code for a device with
                          compute capability 2.0.  This requires
                          -ta=nvidia,cuda3.0, or changing the
                          default CUDA version to 3.0 in the
                          siterc file.

                      cuda4.0
                          Use the CUDA 4.0 toolkit to build the
                          GPU code.

                      4.0 An alias for -Mcuda=cuda4.0.

                      fastmath
                          Enable the fast math library, which
                          includes faster, but lower precision,
                          implementations of certain math and
                          intrinsic functions.

                      flushz noflushz (default)
                          Enable (disable) flush-to-zero mode on
                          the GPU.

                      keepbin
                          Keep the generated CUDA binary, with a
                          .bin suffix.

                      keepgpu
                          Keep the generated CUDA GPU source
                          files, with a .gpu suffix.

                      keepptx
                          Keep the generated portable assembly
                          files, with a .ptx suffix.

                      maxregcount:n
                          Set the maximum number of registers to
                          use in the generated GPU code.

                      mul24
                          Use 24-bit multiplication for array
                          subscripting.

                      time
                      the host processor.

              The default in the absence of the -ta flag is to
              ignore the accelerator directives and compile for
              the host.  Multiple targets are allowed, such as
              -ta=nvidia,host, in which case two versions of
              each routine with accelerator regions are
              generated, one to run on the NVIDIA GPU and one on
              the host; the selection of which version to
              execute is made at run time.

       -tp=target
              Specify the type of the target processor;
              possibilities are

              -tp= amd64
                      AMD Opteron or Athlon-64 in 64-bit mode

              -tp= amd64e
                      AMD Opteron revision E or later, in 64-bit
                      mode; includes SSE3 instructions

              -tp= athlon
                      AMD Athlon processor

              -tp= athlonxp
                      AMD AthlonXP and AthlonMP processor

              -tp= barcelona
                      AMD Barcelona processor

              -tp= barcelona-32
                      AMD Barcelona processor in 32-bit mode

              -tp= barcelona-64
                      AMD Barcelona processor in 64-bit mode

              -tp= bulldozer
                      AMD Bulldozer processor

              -tp= bulldozer-32
                      AMD Bulldozer processor in 32-bit mode

              -tp= bulldozer-64
                      AMD Bulldozer processor in 64-bit mode

              -tp= core2
                      Intel core2 processor

              -tp= core2-32
                      Intel core2 processor in 32-bit mode


              -tp= k7 AMD Athlon processor

              -tp= k8 AMD Opteron or Athlon-64

              -tp= k8-32
                      AMD Opteron or Athlon-64 in 32-bit mode

              -tp= k8-64
                      AMD Opteron or Athlon-64 in 64-bit mode

              -tp= k8-64e
                      AMD Opteron revision E or later, in 64-bit
                      mode; includes SSE3 instructions

              -tp= nehalem
                      Intel Nehalem architecture Core processor

              -tp= nehalem-32
                      Intel Nehalem architecture Core processor,
                      32-bit mode

              -tp= nehalem-64
                      Intel Nehalem architecture Core processor,
                      64-bit mode

              -tp= p5 Pentium processor

              -tp= p6 Pentium Pro / Pentium II

              -tp= p7 IA32/EM64T processor

              -tp= p7-32
                      IA32/EM64T processor in 32-bit mode

              -tp= p7-64
                      IA32/EM64T processor in 64-bit mode

              -tp= penryn
                      Intel Penryn architecture Pentium
                      processor

              -tp= penryn-32
                      Intel Penryn architecture Pentium
                      processor, 32-bit mode

              -tp= penryn-64
                      Intel Penryn architecture Pentium
                      processor, 64-bit mode

              -tp= piii
                      Pentium III processor

              -tp= sandybridge
                      Intel SandyBridge architecture Core
                      processor

              -tp= sandybridge-32
                      Intel SandyBridge architecture Core
                      processor, 32-bit mode

              -tp= sandybridge-64
                      Intel SandyBridge architecture Core
                      processor, 64-bit mode

              -tp= shanghai
                      AMD Shanghai architecture Opteron
                      processor

              -tp= shanghai-32
                      AMD Shanghai architecture Opteron
                      processor, 32-bit mode

              -tp= shanghai-64
                      AMD Shanghai architecture Opteron
                      processor, 64-bit mode

              -tp= x64
                      Single binary where each procedure is
                      optimized for both the AMD Opteron and the
                      Intel IA32/EM64T in 64-bit mode; the
                      selection of which optimized copy to
                      execute is made at run time depending on
                      the machine executing the code.

              The default in the absence of the -tp flag is to
              compile for the type of CPU on which the compiler
              is running.  Where available, -tp=target-64 is
              equivalent to -m64 -tp=target, and -tp=target-32
              is equivalent to -m32 -tp=target.  When 32- and
              64-bit targets are available for a target,
              -tp=target by itself will compile for a 32-bit or
              64-bit target depending on whether the 32-bit or
              64-bit compiler is invoked from your command line
              path.


FILES

       a.out       executable output file
       pgpf.out    Profile feedback data file; see -Mpfi
       pgprof.out  PGPROF output file; see -Mprof
       file.a      library of object files
       file.f      fixed-format Fortran source file
       file.F      fixed-format Fortran source file that
                   requires preprocessing
                   requires preprocessing
       file.ipa    InterProcedural Analyzer (IPA) file
       file.ipo    InterProcedural Analyzer (IPA) file
       file.o      object file
       file.s      assembler source file
       .mypgf90rc  You may add custom switches or make other
                   additions to pgf90 by creating a file named
                   .mypgf90rc in your home directory.

       The installation of this version of the compiler resides
       in $PGI/target/12.4-0/; other versions may coexist in
       $PGI/target/release/.  $PGI is an environment variable
       that points to the root of the compiler installation
       directory. If $PGI is not set, the default is /usr/pgi.
       The target is one of the following:
       linux86     for 32-bit IA32 Linux targets
       linux86-64  for 64-bit AMD64 or IA32/EM64T Linux targets

       The compiler installation subdirectories are:
       bin/        compiler and tool executables and
                   configuration (rc) files
       include/    compiler include files
       lib/        libraries and object files
       liblf/      libraries and object files


SEE ALSO

       pgcc (1), pgCC (1), pgf77 (1), pghpf (1), pgprof (1),
       pgdbg (1), and the PGI User’s Guide.


DIAGNOSTICS

       The compiler produces information and error messages as
       it translates the input program. The linker and assembler
       may issue their own error messages.



                                  April 2012                          pgf90(1)

Man(1) output converted with man2html