SYNOPSIS

       pgCC [ -flag ]...  sourcefile...


DESCRIPTION

       pgCC is the interface to the Portland Group Inc. (PGI) C++ compiler for
       AMD64 and IA32/EM64T processors.  pgCC invokes the C++ compiler, assem-
       bler,  and linker with options derived from its command line arguments.


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

       .c     C++ source; preprocess, compile
       .C     C++ source; preprocess, compile
       .cc    C++ source; preprocess, compile
       .cpp   C++ source; preprocess, compile
       .i     C++ source after preprocessing; 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 pgf77 or pgfortran, Fortran file suffixes are also
       recognized and compiled with the  pgf77  or  pgfortran  compilers;  see
       pgf77,  pgfortran, and the 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,
       pgCC deletes the intermediate preprocessor and assembler files (see the
       options -c, -E, -P, --no_line_commands, --preprocess,  and  -Mkeepasm);
       if  a  single C++ program is compiled and linked with one pgCC 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, -P,
       --no_line_commands, --preprocess, or -S options, or unless  compilation
       errors stop the whole process.



A NOTE ON C++ OPTIMIZATION

       pgCC provides a number of options to enable different optimization lev-
       els.  PGI recommends the following switch  combination  as  a  starting
       point  for  setting  the  optimization level: -fast -Minline=levels:10.
       The best performance will be achieved if  exception  handling  is  also
       disabled  via --no_exceptions. To avoid excessive code expansion due to
       inlining, move Standard Template Library I/O out  of  inlined  objects.
       For  additional  optimizations,  refer  to  the  -Msafeptr  and  -Mvect
       options.


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.

              -M[no]ipa=option -M[no]lre[=assoc|noassoc] -M[no]movnt
              -Mneginfo=option -Mnoopenmp -Mnosgimp -Mnovintr -Mpfi[=option]
              -Mpfo[=option] -M[no]pre[=all] -M[no]prefetch=option
              -Mprof=option -M[no]propcond -Mquad -Msafe_lastval
              -M[no]safeptr=option -M[no]scalarsse -M[no]smart
              -M[no]smartalloc[=option] -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
              -g -gopt -M[no]bounds -Mchkfpstk -Mchkstk -Mcoff -Mdwarf1
              -Mdwarf2 -Mdwarf3 -Melf -Mnodwarf -[no]traceback

       Preprocessor Options
              -C -Dmacro -define_macromacro --dependencies
              --dependencies_quoted_only --dependencies_to_filefilename
              --dependencies_to_file_quoted_onlyfilename
              --dependencies_to_stdout --dependencies_to_stdout_quoted_only -E
              -Idirectory --include_directorydirectory -M
              -Mcpp=[[no]comment|m|md|mm|mmd|suffix:suff] -MD -MM
              -MMD[filename] -Mnostddef -Mnostdinc -Mpreprocess -N
              --no_line_commands -P --preprocess -Uname -undefine_macroname
              -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
              -pgf77libs -pgf90libs -r -Rdirectory -rpath directory -s -shared
              -soname name -uname --[no-]whole-archive
              -Wl,argument[,argument]...  -YC,directory -Yl,directory
              -YL,directory -YP,directory -YS,directory -YU,directory

       Language Options
              -$ -A -a --[no_]alternative_tokens --[no_]anachronisms
              --[no_]array_new_and_delete -asmsuffix=suffix
              --[no_]auto_instantiation -B -b -b3 --[no_]bool
              --[no_]brief_diagnostics --[no_]builtin --cfront_2.1
              --cfront_3.0 --comments --compress_names --no_compress_names
              -cppsuffix=suffix --create_pchfilename -csuffix=suffix
              --[no_]distinct_template_signatures --dollar -enumber
              --early_tiebreaker --[no_]enum_overloading --error_limitnumber
              --[no_]exceptions --[no_]explicit -fix_so_init
              --[no_]for_init_diff_warning --force_vtbl --gcc --gnu_extensions
              --[no_]guiding_decls --ieeenum --[no_]implicit_include
              --[no_]implicit_typename --late_tiebreaker --list --[no_]llalign
              --long_lifetime_temps --[no_]long_preserving_rules -M[no]builtin
              -M[no]dalign -Mdollar=char -Mfcon -Mlibsuffix=suffix
              -M[no]llalign -Mobjsuffix=suffix -Mschar -M[no]signextend
              -M[no]func32 -Mgccbugs -M[no]longbranch -M[no]loop32
              -M[no]reg_struct_return -M[no]second_underscore
              -Mwritable-strings -m32 -m64 -mcmodel=small|medium -pc val
              -tp=target

       When source files are compiled using any of the -g, -mp, -Mconcur,
       -Mipa, or -Mprof options, the same option(s) should be used when using
       pgCC 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
                 dash, so these should be avoided.

       -#        Display the invocations of the compiler, assembler, and
                 linker.  These invocations are the command lines created by
                 pgCC.

       -###      Display invocations of the compiler, assembler and linker,
                 but do not execute them.

       --actual_o_filefilename
                 Name the object file.

       -c        Skip the link step; compile and assemble only.

       -defaultoptions (default) -nodefaultoptions
                 Use (don’t use) the default options set in site-specific or
                 user-specific PREOPTIONS or POSTOPTIONS driver variables.

       --diag_errorarg
                 Override the normal error severity of the specified
                 diagnostic message(s); the message(s) may be specified using
                 a mnemonic error tag or using the error number.

       --diag_remarkarg
                 Override the normal error severity of the specified
                 diagnostic message(s); the message(s) may be specified using
                 a mnemonic error tag or using the error number.

       --diag_suppressarg
                 Override the normal error severity of the specified
                 diagnostic message(s); the message(s) may be specified using
                 a mnemonic error tag or using the error number.

       --diag_warningarg
                 Override the normal error severity of the specified
                 diagnostic message(s); the message(s) may be specified using
                 a mnemonic error tag or using the error number.

       --display_error_number
                 line switch errors.  Return a success error code if there are
                 no command-line switch errors.

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

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

       -Manno    Produce annotated assembly files, where source code is
                 intermixed with assembly language; implies -Mkeepasm.

       -Minform=level
                 Specify the minimum level of error severity that the compiler
                 displays during compilation.

                 fatal     Instructs the compiler to display fatal error
                           messages.

                 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, -P, or -S, and a single
                 input file, file is used as the name of the object,
                 preprocessor, or assembler output file.

       -rc rcfile
                 Specifies the name of a pgCC 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
                 file.c.

       -show     Produce help information describing the current pgCC
                 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.

       -V<ver>   If the specified version of the compiler is installed, that
                 version of the compiler is invoked.

       --version Display version messages and other information.

       -w        Do not print warning messages.

       -Wpass,option[,option...]
                 Pass option to the specified pass.  Each comma-delimited
                 area. The passes are:

                 c         Search for the C++ 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

       -alias=option
              Specifies whether to optimizing using ANSI C type-based pointer
              disambiguation rules.  The options can be one of:

              ansi      Assume ANSI C type-based pointer disambiguation rules
                        apply; this can enable better optimization in some
                        cases.  The rules state that a load or store through a
                        pointer of any type will not conflict with a load or
                        store of a variable or through a pointer of a
                        different type.  This is the default with -O2 and
                        above.

              traditional
                        Assume traditional C semantics apply.  The compiler
                        will assume that a load or store through any pointer
                        might conflict with any variable or pointer
                        dereference unless it can prove otherwise.  This is
                        the default with -O1 and below, and when there is a

              (dynamically linked libraries).

       -fPIC  Equivalent to -fpic; provided for compatibility with other
              compilers.

       -Kpic  Equivalent to -fpic; provided for compatibility with other
              compilers.

       -KPIC  Equivalent to -fpic; provided for compatibility with other
              compilers.

       -Mautoinline[option[,option...] -Mnoautoinline (default)
              Enable inlining of functions with the inline attribute.
              -Mautoinline is implied with the -fast switch.  The options are:

              levels:n  Inline up to n levels of function calls; the default
                        is to inline up to 10 levels.

              maxsize:n Only inline functions with a size of n or less.  The
                        size roughly corresponds to the number of statements
                        in the function, though the correspondence is not
                        direct.  The default is to inline functions with a
                        size of 100 or less.

              totalsize:n
                        Stop inlining when this function reaches a size of n.
                        The default is to stop inlining when a size of 8000
                        has been reached.

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

              dist:block
                        Parallelize with block distribution. Contiguous blocks
                        of iterations of a parallelizable loop are assigned to
                        the available processors.

              dist:cyclic
                        Parallelize with cyclic distribution. The outermost
                        parallelizable loop in any loop nest is parallelized.
                        If a parallelized loop is innermost, its iterations
                        are allocated to processors cyclically. For example,
                        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.

              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; the -Msafeptr switch
              provides a less dangerous way to accomplish the same thing.

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

       -Mextract=[option[,option,...]]
              Run the subprogram extraction phase to prepare for inlining.
                     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,...]]
              Emit useful information to stderr. The options are:

              all       Includes options accel, inline, ipa, loop, lre, mp,
                        opt, par, unified, vect.

              accel     Emit information about accelerator region targeting.

              ccff      Append complete CCFF information to the object files.

              ftn       Emit Fortran-specific information.

              hpf       Emit HPF-specific information.

              inline    Emit information about functions extracted and
                        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.
                        -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
                        containing number or less statements are inlined.  If
                        both number and function are specified, then functions
                        matching the given name(s) or meeting the size
                        requirements, are inlined.

              levels:number
                        number of levels of inlining are performed.  The
                        default is 1.

              reshape   For Fortran, the default is to not inline subprograms
                        with array arguments if the array shape does not match
                        the shape in the caller. This overrides the default.

       -Minstrument [=option]
              (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)
                        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.

                        nopfo
                            Ignore any profile frequency information from
                            -Mpfo when choosing which functions to inline.

                        reshape noreshape (default)
                            Enable (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.

              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;
                        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)
                        Perform (don’t perform) Fortran 90 shape propagation.

              summary   Only collect IPA summary information when compiling;
                        this prevents IPA optimization of this file, but
                        allows optimization for other files linked with this
                        file.

              vestigial novestigial (default)
                        Remove (don’t remove) functions that are not called.

       -Mlre[=assoc|noassoc] -Mnolre
              Enable (disable) loop-carried redundancy elimination.  The assoc
              option allows expression reassociation, and the noassoc option
              disallows expression reassociation.

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

       -Mpre[=all] -Mnopre (default)
              Enable (disable) the partial redundancy elimination
              optimization.

              all       Enable aggressive PRE.

       -Mprefetch[=option:n] -Mnoprefetch
              Add (don’t add) prefetch instructions for those processors that
              support them (Pentium 4, Opteron); -Mprefetch is default on
              Opteron; -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.  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:
              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
                        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 (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.

       -Msafeptr[=option[,option,...]] -Mnosafeptr (default)
              Override (don’t override) data dependence between C pointers and
              between pointers and variables or arrays.  This option must be
              used with care since the potential exists for code to be
              generated that will result in unexpected or incorrect results as
              is defined by ANSI C. However, when used properly, this option
              has the potential to greatly enhance the performance of code,
              especially floating point oriented loops.  Combinations of the
              options may be used and interact appropriately.

              all       All pointers are assumed not to overlap or conflict
                        with other data objects; -Msafeptr with no options
                        implies -Msafeptr=all.

              arg | dummy
                        C dummy arguments (pointers and arrays) are treated
                        with the same copyin/copyout semantics as Fortran
                        dummy arguments.

              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
                        supplied constant.  If this value is not supplied, the
                        m count is set to 4.

              n:u       Instructs the compiler to unroll u times, a single-
                        block loop which is not completely unrolled, or has a

              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.

              short noshort (default)
                        Enable (disable) recognition of short vector
                        operations that arise from scalar code outside of
                        loops or within the body of 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
                        affinity between threads and processors;
                        this is useful with NUMA (non-uniform
                        memory access) parallel architectures,
                        so memory allocated by a particular
                        thread will be allocated close to that
                        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

       -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)
              Add (don’t add) array bounds checking.  Bounds
              checking is not applied to a subscripting pointer.

       -Mchkfpstk
              Check for internal consistency of the IA-32
              floating point stack in the prologue of a function
              and after returning from a function or subroutine

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

       -traceback -notraceback (default)
              Add debug information for runtime traceback



Preprocessor Options

       -C     Preserve comments in preprocessed C source files.

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

       -define_macroname[=def]
              The same as -Dname[=def].  Define name to be def
              in the preprocessor. If def is missing, it is
              assumed to be empty.

       --dependencies
              Generate a list of make dependences and print them
              to stdout.

       --dependencies_quoted_only
              Generate a list of make dependences for quoted
              include files only, and print them to standard
              output.

       --dependencies_to_filefilename
              Generate a list of make dependences and print them
              to the file filename.

       --dependencies_to_file_quoted_onlyfilename
              Generate a list of make dependences for quoted
              include files only and print them to the file
              filename.

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

       --include_directorydirectory
              Add directory to the compiler’s search path for
              include files.  For include files surrounded by <
              >, each --include_directory 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 --include_directory
              directories, followed by the standard area.

       -M     Generate a list of make dependences and print them
              to stdout.

       -Mcpp=[[no]comment|m|md|mm|mmd|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 (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.

              line Include line numbers into the preprocessed
                   output.

              Generate a list of make dependences and print them
              to the the specified file, if given, or to file
              file.d, where file is the root name of the file
              under compilation. Ignore system includes.

       -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 assembler source files.

       -N     Preprocess each file and leave the output in a
              file named file.i for each file named file.c.

       --no_line_commands
              Preprocess each file and leave the output in a
              file named file.i for each file named file.cc;
              remove comments and leave out line control
              information.

       -P     Preprocess each file and leave the output in a
              file named file.i for each file named file.cc.

       --preprocess
              Preprocess each file and leave the output in a
              file named file.i for each file named file.cc;
              remove comments and add line control information.

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

       -undefine_macroname
              Undefine a macro; See -U.

       -YI,directory
              Look in directory for the standard compiler
              include files.

       -Yp,directory
              Look in directory for the preprocessor executable.

       --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 pgCC 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
              Red Hat 7.0 or SuSE 7.1.  This will support files
              from Fortran I/O that are larger than 2GB.
              Equivalent to -L$PGI/linux86/12.4-0/liblf.

       -Mmpi=option
              (PGI CDK only) -Mmpi adds the include and library

              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.

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

       -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
              (Linux only) Passed to the linker. Instructs the
              linker to generate a shared object file
              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.

       -YP,directory
              Add a standard library 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

       -$     Accept dollar signs in identifiers.

       -A        Same as --strict.  Enable strict ANSI/ISO mode,
                 which issues error messages when non-standard
                 features are used, and disables features that
                 conflict with ANSI/ISO C or C++.

       -a        Enable ANSI/ISO mode; issue warning messages
                 when non-standard features are used.

       --alternative_tokens --no_alternative_tokens (default)
                 Enable (disable) recognition of alternative
                 tokens; this controls recognition of digraph
                 tokens and of the operator (e.g., and)
                 keywords.

       --anachronisms --no_anachronisms (default)
                 Allow (disallow) C++ anachronisms.

       --array_new_and_delete --no_array_new_and_delete
                 Enable array new and delete operations.

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

       --bool (default) --no_bool
                 Enable (disable) recognition of the bool
                 datatype.

       --brief_diagnostics --no_brief_diagnostics (default)
                 Enable (disable) brief diagnostic mode; when
                 enabled, the original source line is not
                 displayed, and the error message is not wrapped
                 even when too long to fit on a single line.

       --builtin (default) --no_builtin
                 Compile (don’t compile) with builtin math
                 subroutine support, certain math library
                 routines inlined.

       --cfront_2.1
                 Enable compilation of C++ with cfront 2.1
                 compatibility.  This causes the compiler to
                 accept language constructs that, while not part
                 of the C++ language definition, are accepted by
                 the AT&T C++ language system (cfront release
                 2.1).  This option also enables acceptance of
                 anachronisms.

       --cfront_3.0
                 Enable compilation of C++ with cfront 3.0
                 compatibility.  This causes the compiler to
                 accept language constructs that, while not part
                 of the C++ language definition, are accepted by
                 the AT&T C++ language system (cfront release
                 3.0).  This option also enables acceptance of
                 anachronisms.

       --comments
                 Preserve comments.

       --compress_names --no_compress_names (default)
                 Compress C++ mangled names to fit into 1024
                 characters.  All C++ user code must be compiled
                 with the same setting of --compress_names or
                 --no_compress_names.

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

       --create_pchfilename
                 Create a precompiled header file with the
                 specified name, if applicable.  This switch
                 conflicts with --pch (automatic PCH mode).

                 errors.

       --early_tiebreaker
                 Select the way that tie-breakers (e.g., cv-
                 qualifier differences) apply in overload
                 resolution. In "early" tie-breaker processing,
                 the tie-breakers are considered at the same
                 time as other measures of the goodness of the
                 match of an argument value and the
                 corresponding parameter type (this is the
                 standard approach).  This is the default for
                 Linux; see --late_tiebreaker.

       --enum_overloading --no_enum_overloading
                 Enable (disable) support for using operator
                 functions to overload builtin operations on
                 enum-typed operands.  The default is
                 --enum_overloading, except on WIN64.

       --error_limitnumber
                 Set the C++ front end error limit to the
                 specified number. The C++ compiler will abandon
                 compilation after the specified number of
                 errors.  By default, the limit is 100.

       --exceptions (default) --no_exceptions
                 Enable (disable) exception handling support.

       --explicit (default) --no_explicit
                 Enable (disable) support for the explicit
                 keyword.

       -fix_so_init
                 Tell prelinker to gather .init sections into an
                 assembly file.

       --for_init_diff_warning (default) --no_for_init_diff_warning
                 Enable (disable) a warning that is issued when
                 programs compiled under the new for-init
                 scoping rules would have different behavior
                 under the old rules.

       --force_vtbl
                 Force definition of virtual function tables in
                 cases where the heuristic used by the front end
                 to decide on definition of virtual function
                 tables provides no guidance; see
                 --suppress_vtbl.

       --gcc     Generate GNU-compatible C++ code and link with
                 the GNU libraries.

                 template entities to be instantiated.

       --implicit_typename (default) --no_implicit_typename
                 Enable (disable) implicit determination, from
                 context, whether a template parameter dependent
                 name is type or nontype.

       --late_tiebreaker
                 Select the way that tie-breakers (e.g., cv-
                 qualifier differences) apply in overload
                 resolution.  In "late" tiebreaker processing,
                 tie-breakers are ignored during the initial
                 comparison, and considered only if two
                 functions are otherwise equally good on all
                 arguments; the tie-breakers can then be used to
                 choose one function over another.  This is the
                 default for WIN65; see --early_tiebreaker.

       --listfilename
                 Generate raw listing information in the file
                 filename.  This information is likely to be
                 used to generate a formatted listing. The raw
                 listing file contains raw source lines,
                 information on transitions into and out of
                 include files, and diagnostics generated by the
                 front end.

       --llalign --no_llalign
                 Align (don’t align) long longs in structures on
                 8-byte boundaries; the same as -M[no]llalign.
                 --llalign is the default for 64-bit systems.

       --long_lifetime_temps
                 Select long lifetime for temporaries, meaning
                 to the earliest of end of scope, end of switch
                 clause, or the next label; this is used by
                 cfront.  See --short_lifetime_temps.

       --long_preserving_rules --no_long_preserving_rules (default)
                 Enable (disable) the K&R usual arithmetic
                 conversion rules with respect to long.

       -Mbuiltin (default) -Mnobuiltin
                 Compile (don’t compile) with math subroutine
                 builtin support, which causes selected math
                 library routines to be inlined.

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

                 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.

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

       -Mschar (default)
                 Specify that the char type is signed by
                 default; see -Muchar.

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

       -Msingle -Mnosingle (default)
                 Suppress (don’t suppress) the ANSI-specified
                 conversion of float to double when passing
                 arguments to a function with no prototype in
                 scope.  -Msingle may result in faster code when
                 single precision is used a lot, but is non-ANSI
                 compliant.

       -Muchar   Specify that the char type is unsigned by
                 default; see -Mschar.

       --namespaces --no_namespaces
                 Enable (disable) support for namespaces.

       --new_for_init
                 Control the scope of a declaration in a for-
                 init-statement; the new standard-conforming
                 rules in effect wrap the entire for statement
                 in its own impicitly generated scope.  This is
                 the default except on WIN64; see
                 --old_for_init.

       --no_use_before_set_warnings
                 Suppress warning messages about variables used
                 before being set.

       --no_warnings
                 Suppress all warning messages.
                 Enable (disable) old-style specialization
                 declarations.

       --pch     Automatically use and/or create a precompiled
                 header file.  This command conflicts with
                 --use_pch or --create_pch (manual PCH mode).

       --pch_dirdirectory
                 Name the directory in which to search for
                 and/or create a precompiled header file. This
                 option may be used with automatic PCH mode
                 (--pch) or manual PCH mode (--create_pch or
                 --use_pch).

       --pch_memnum
                 Specify the memory to be used for PCG
                 processing.

       --pch_messages --no_pch_messages
                 Enable (disable) the display of a message
                 indicating that a precompiled header file was
                 created or used in the current compilation.

       --pedantic
                 Don’t supress warnings from system include
                 files.

       --preincludefilename
                 Specify a file to be included at the beginning
                 of compilation to set system-dependent macros,
                 types, etc.

       --prelink_objects
                 When used with the
                 --one_instantiation_per_object switch, this
                 creates template instantiations for a set of
                 objects that are about to become a template
                 library. This is required for template
                 libraries that reference other template
                 libraries.

       --remarks Issue remarks, which are diagnostic messages
                 even milder than warnings.

       --remove_unneeded_entities
                 Remove unnecessary IL entries.

       --restrict --no_restrict (default)
                 Enable (disable) the use of the restrict
                 keyword.

       --rtti(default) --no_rtti
                 end to decide on definition of virtual function
                 tables provides no guidance. The virtual
                 function table for a class is defined if the
                 compilation contains a definition of the first
                 non-inline non-pure virtual function of the
                 class.

       --timing  Display C++ front end compilation times.

       --trace_includes
                 List include files.

       --typename --no_typename
                 Enable (disable) typename.

       --use_pchfilename
                 Use a precompiled header file of the specified
                 name as part of the current compilation.  This
                 command conflicts with --pch.

       --using_std (default) --no_using_std
                 Enable (disable) implicit use of the std
                 namespace when standard header files are
                 included.

       --wrap_diagnostics --no_wrap_diagnostics
                 Enable (disable) diagnostic wrapping.

       -Xfilename
                 Generate cross reference information and place
                 output in the specified file.

       --zc_eh   Generate zero-cost exception handlers.



Target-specific Options

       -Kieee -Knoieee (default)
              Perform floating-point operations in strict
              conformance with the IEEE 754 standard.  Some
              optimizations are disabled with -Kieee, and a more
              accurate math library is used.  The default
              -Knoieee uses faster but very slightly less
              accurate methods.

       -Ktrap=[option,[option]...]
              Controls the behavior of the processor when
              exceptions occur.  Possible options include

              align   Trap on memory alignment errors, currently
                      ignored.

              denorm  Trap on denormalized operands.
              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
                        point square root.
       With no options, -Mfpapprox will approximate all three
       operations.

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

       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.

       -Mgccbugs
              Match the behavior of certain bugs in gcc.

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

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

       -Mreg_struct_return -Mnoreg_struct_return (default)
              Return (don’t return) small struct/union function
              values in registers.  This switch only affects
              32-bit code.

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

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

       -m32   Compile for 32-bit target.

       -m64   Compile for 64-bit target.

       -mcmodel=small|medium
              (AMD64 and IA32/EM64T only) Use the memory model
              that limits objects to less than 2GB (small) or
              allows data sections to be larger than 2GB
              (medium); implies -Mlarge_arrays

       -pc val
              The IA-32 architecture implements a floating-point
              stack using 8 80-bit registers. Each register uses
              bits 0-63 as the significand, bits 64-78 for the
              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
              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.

       -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
                      processor, 64-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
                      any 64-bit x86 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.C      C++ source file
       $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), pgf77 (1), pgfortran (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                           pgCC(1)

Man(1) output converted with man2html