xlf(1)                 IBM (October 2005)                  xlf(1)



  NAME
         xlf, xlf90, xlf95, xlf_r, xlf90_r, xlf95_r, f90, f95,
         xlf_r7, xlf90_r7, xlf95_r7, f77, fort77 - invoke the IBM
         XL Fortran compiler

  SYNTAX
         <invocation-command> [ <option> | <inputfile> ] ...

  DESCRIPTION
         xlf and related invocation commands compile Fortran source
         files.  They also process assembler source files and
         object files. Unless you specify the -c option, these
         commands call the link editor to produce a single object
         file.

         The main difference between these commands is that they
         use different default options (which are set in the
         configuration file /etc/xlf.cfg).  For more information,
         refer to the XL Fortran Enterprise Edition Compiler
         Reference.

         The input file may have any of the following suffixes:
          .f - Fortran source file
          .f77 or .F77 - Fortran source file (fixed form) using
               f77 stanza configuration
          .f90 or .F90 - Fortran source file (free form) using
               xlf90 configuration
          .f95 or .F95 - Fortran source file (free form) using
               xlf95 configuration
          .o or .a - object file for ld command
          .s - assembler source file
          .F - Fortran source file with cpp preprocessor directives

  OPTIONS
         Compiler options are categorized by their functions. In
         each category, the flag options are listed first, followed
         by the keyword options.

  Input Control Options
         -I<dir>
                Adds a directory to the search path for include
                files and .mod files. If XL Fortran calls cpp, this
                option adds a directory to the search path for
                #include files. Before checking the default
                directories for include and .mod files, the
                compiler checks each directory in the search path.
                For include files, this path is only used if the
                file name in an INCLUDE line is not provided with
                an absolute path. By default, the following
                directories are searched in the following order:

                1) The current directory (where the compiler is
                executed)
                2) The directory where the source file is located

         -k     Specifies that the program is in free source form.
                This is the short form of -qfree=f90.

         -U     Makes the compiler case-sensitive to identifier
                names. By default the compiler interprets all names
                as if they were lower-case.

         -qci=<nums_list>
                Activates the specified INCLUDE lines. <nums_list>
                is a colon-separated list of identification numbers
                (from 1 to 255) of conditional includes.

         -qcr | -qnocr
                Allows you to control how the compiler interprets
                the CR (carriage return) character.  This allows
                you to compile code written using a MAC OS X or
                DOS/Windows editor.  The default is -qcr.

         -qdirective[=<list>] | -qnodirective[=<list>]
                Specifies target strings to be recognized in a
                comment directive. <list> is a colon-separated list
                of directives. If -qdirective is specified without
                any directives, it turns on the default trigger
                constant IBM* if it has been turned off by a
                previous -qnodirective.  The default is
                -qnodirective.

         -qdlines | -qnodlines
                This is the long form of the -D option. See -D for
                more information.  The default is -qnodlines.

         -qfixed[=<right_margin>]
                Indicates that the input source program is in fixed
                source form and optionally specifies the maximum
                line length, <right_margin>. The maximum
                <right_margin> value is 132.  The default is
                -qfixed=72 for xlf, xlf_r, xlf_r7, f77, and fort77
                invocation commands, and -qfree=f90 for f90, f95,
                xlf90, xlf90_r, xlf90_r7, xlf95, xlf95_r, and
                xlf95_r7.

         -qfree[={f90|ibm}]
                Indicates that the source code is in free source
                form. The 'ibm' and 'f90' suboptions specify
                compatibility with the free source form defined for
                VS Fortran and Fortran 90, respectively. Note that
                the free source form defined for Fortran 90 also
                applies to Fortran 95.  The default is -qfree=f90
                for f90, f95, xlf90, xlf90_r, xlf90_r7, xlf95,
                xlf95_r, and xlf95_r7 invocation commands, and
                -qfixed=72 for xlf, xlf_r, xlf_r7, f77, and fort77.

         -qmbcs | -qnombcs
                Indicates to the compiler whether character literal
                constants, Hollerith constants, H edit descriptors,
                and character string edit descriptors can contain
                Multibyte Character Set (MBCS) or Unicode
                characters. The default is -qnombcs.

         -qmixed | -qnomixed
                The long form of the -U option. Makes the compiler
                case-sensitive to identifier names. The default is
                -qnomixed.

         -qsuffix=<option>=<suffix>
                Specifies the source file suffix, <suffix>, on the
                command line instead of in the .cfg file, where
                <option> can be:

                f
                     Specifies that <suffix> is the new source file
                     suffix.
                o
                     Specifies that <suffix> is the new object-file
                     suffix.
                s
                     Specifies that <suffix> is the new assembler
                     source file suffix.
                cpp
                     Specifies that <suffix> is the new
                     preprocessor source file suffix.

  Output Control Options
         -c     Produces an object file instead of an executable
                file.  Prevents the completed object file from
                being sent to the ld command for link-editing. With
                this option, the output is a .o file for each
                source file.

         -d     Causes preprocessed source files that are produced
                by cpp to be kept rather than to be deleted. By
                default temporary files produced by cpp are
                deleted.

         -o <name>
                Specifies a name for the output object, executable,
                or assembler source file.  The default name is
                a.out for executable files. The default name for an
                object source file is the same as the source file
                except that it has a '.o' extension.

         -q32   Selects 32-bit mode compilation mode. The -q32 and
                -qarch options determine the target machines that
                the 32-bit executable will run on. The default is
                -q32.

         -q64[=<suboption>]
                Selects 64-bit compilation mode. The -q64 option
                indicates that the object module will be created in
                64-bit object format and that the 64-bit
                instruction set will be generated. Note that you
                may compile in a 32-bit environment to create 64-
                bit objects, but you must link them in a 64-bit
                environment with the -q64 option. Use -q32 and -q64
                options, along with the -qarch and -qtune compiler
                options, to optimize the output of the compiler to
                the architecture on which that output will be used.
                The suboptions are:

                largetype
                     The object file will use the 64-bit Large Data
                     Type (LDT) ABI. This object file may only be
                     used on versions of AIX greater than or equal
                     to 5.0.

         -qmoddir=<directory>
                Specifies the location for any .mod files that the
                compiler writes. By default .mod files are placed
                in the current directory.

         -qpic[=<suboption>] | -qnopic
                Generates Position Independent Code (PIC) that can
                be used in shared libraries.  The suboptions are:

                large
                     Allows the size of the Table of Contents to be
                     larger than 64K. This suboption allows for
                     more addresses to be stored in the Table of
                     Contents and generates larger code.
                small
                     Assumes that the size of the Table of Contents
                     can be at most 64K.

                The default is -qpic=small.

  Optimization Options
         -NS<bytes>
                Specifies the size (in bytes) of the register spill
                space; the internal program storage areas used by
                the optimizer for register spills to storage.  The
                default is -NS512.

         -O[<level>]
                Specifies whether to optimize code during
                compilation and, if so, at which level. -O<level>
                is equivalent to -qoptimize=<level>. <level> can
                be:

                (not specified)
                     This is equivalent to -O2.
                0
                     Almost all optimizations are disabled. This is
                     equivalent to -qnooptimize.
                1
                     Reserved for future use. Ignored by compiler.
                2
                     Performs a set of optimizations that are
                     intended to offer improved performance without
                     an unreasonable increase in time or storage
                     that is required for compilation.
                3
                     Performs additional optimizations that are
                     memory intensive, compile-time intensive, and
                     may change the semantics of the program
                     slightly, unless -qstrict is specified. We
                     recommend these optimizations when the desire
                     for run-time speed improvements outweighs the
                     concern for limiting compile-time resources.
                     This level of optimization also affects the
                     setting of the -qfloat option, turning on the
                     'fltint' and 'rsqrt' suboptions by default,
                     and setting -qmaxmem=-1.  This option implies
                     -qhot=level=0.
                4
                     Aggressively optimizes the source program,
                     trading off additional compile time for
                     potential improvements in the generated code.
                     You can specify the option at compile time or
                     at link time. if you specify it at link time,
                     it will have no effect unless you also specify
                     it at compile time for at least the file that
                     contains the main program. -O4 implies the
                     following other options:
                     -qhot
                     -qipa
                     -O3
                     -qarch=auto
                     -qtune=auto
                     -qcache=auto
                5
                     Performs all optimizations from -O4, and also
                     sets -qipa=level=2 to perform full inter-
                     procedural data flow and alias analysis.

                -O4 and -O5 perform whole-program analysis and
                should be specified at both compilation and link
                time to have maximal effect.  The default is -O0.

         -p[g]  Sets up the object file for profiling. Specifying
                '-pg' will produce more extensive statistics. The
                default is no profiling.

         -Q[<suboption>]
                Specifies whether Fortran 90 or Fortran 95
                procedures are inlined and/or the names of
                particular procedures that should or should not be
                inlined. names is a list of procedure names that
                are separated by colons. This option can take the
                form:

                -Q
                     Attempts to inline all appropriate functions,
                     subject to limits on the number of inlined
                     calls and the amount of code size increase as
                     a result.
                -Q!
                     Turns off inlining.
                -Q+<names_list>
                     Inlines the functions listed in <names_list>
                     and any other appropriate functions, where
                     <names_list> is a colon-separated list.
                -Q-<names_list>
                     Does not inline functions listed in
                     <names_list>, where <names_list> is a colon-
                     separated list. All other appropriate
                     functions are inlined.

         -s     Strips the symbol table, line number information,
                and relocation information from the output file.

         -qalias=<suboptions_list>
                Indicates whether a program contains certain
                categories of aliasing. The compiler limits the
                scope of some optimizations when there is a
                possibility that different names are aliases for
                the same storage locations. <suboptions_list> is a
                colon-separated list of one or more of the
                following suboptions:

                aryovrlp | noaryovrlp
                     Indicates whether the compilation units
                     contain any array assignments between
                     storage-associated arrays. If not, specify
                     noaryovrlp to improve performance.
                intptr | nointptr
                     Indicates whether the compilation units
                     contain any integer POINTER statements. If so,
                     specify intptr.
                pteovrlp | nopteovrlp
                     Indicates whether any pointee variables may be
                     used to refer to any data objects that are not
                     pointee variables, or whether two pointee
                     variables may be used to refer to the same
                     storage location. If not, specify nopteovrlp.
                std | nostd
                     Indicates whether the compilation units
                     contain any non-standard aliasing (see
                     Compiler Reference for more information). If
                     so, specify nostd.  (-qalias=nostd replaces
                     the obsolete -qxflag=xalias option.)

                For the xlf90, xlf90_r, xlf90_r7, xlf95, xlf95_r,
                xlf95_r7, f90 and f95 commands, the default
                suboptions are: aryovrlp, nointptr, pteovrlp, and
                std. For the xlf, xlf_r, xlf_r7, f77, and fort77
                commands, the default suboptions are: aryovrlp,
                intptr, pteovrlp, and std.

         -qalign=<suboptions_list>
                Specifies the alignment of data objects in storage
                to avoid performance problems with misaligned data.
                <suboptions_list> is a colon-separated list of one
                or more of the following suboptions:

                4k | no4k
                     Specifies whether large arrays and structures
                     (at least 4096 bytes in size) will be aligned
                     on a 4K (4096-byte, or page) boundary.  Use of
                     this option may help to improve the
                     performance of programs using data striping.
                bindc=<suboption>
                     Specifies that the alignment and padding for
                     an XL Fortran derived type with the BIND(C)
                     attribute are compatible with a C struct type
                     that is compiled with the corresponding XL C
                     alignment option. The compatible alignment
                     options are:
                     -qalign=bindc=bit_packed
                     -qalign=bindc={full|power}
                     -qalign=bindc=packed
                     -qalign=bindc={twobyte|mac68k}
                     -qalign=bindc=natural
                     Each of these "-qalign=bindc=" sub-suboptions
                     is equivalent to the XL C "-qalign=" suboption
                     of the same name.  (ie: For
                     -qalign=bindc=bit_packed, the corresponding XL
                     C option is -qalign=bit_packed)
                struct=<option>
                     Specifies how objects or arrays of a derived
                     type (declared using a record structure) are
                     stored, and whether or not padding is used
                     between components. The options are:
                     natural
                          Objects of a derived type are stored with
                          sufficient padding such that components
                          will be stored on their natural alignment
                          boundaries, unless storage association
                          requires otherwise.
                     packed
                          Objects of a derived type are stored with
                          no padding between components, other than
                          any padding represented by %FILL
                          components.
                     port
                          Storage padding is the same as described
                          above for the struct=natural suboption,
                          except that the alignment of components
                          of type complex is the same as the
                          alignment of components of type real of
                          the same kind. The padding for an object
                          that is immediately followed by a union
                          is inserted at the beginning of the first
                          map component for each map in that union.

                The default activated suboptions are: no4k,
                struct=natural, and bindc=power.

         -qarch=<suboption>
                Specifies which instructions the compiler can
                generate.  The suboptions are:

                auto
                     Automatically detects the specific
                     architecture of the compiling machine. It
                     assumes that the execution environment will be
                     the same as the compilation environment.
                com
                     You can run the executable file that the
                     compiler generated on any hardware platform
                     supported by the compiler, because the file
                     contains only instructions that are common to
                     all machines.
                p2sc
                     The executable file can be executed on any
                     POWER2 Super Chip hardware platform.
                ppc
                     Produces an object that contains instructions
                     that run on any of the 32-bit PowerPC hardware
                     platforms. Using -q64 with ppc upgrades the
                     architecture to ppc64grsq.
                ppcgr
                     In 32-bit mode, produces object code
                     containing optional graphics instructions for
                     PowerPC hardware platforms.  In 64-bit mode,
                     produces object code containing optional
                     graphics instructions that will run on 64-bit
                     PowerPC platforms, but not on 32-bit-only
                     platforms.  Using -q64 with ppcgr upgrades the
                     architecture to ppc64grsq.
                ppc64
                     Produces object code that will run on any 64-
                     bit PowerPC hardware platform. When compiled
                     in 32-bit mode, the resulting object code may
                     include instructions that are not recognized
                     or behave differently when run on 32-bit
                     PowerPC platforms.
                ppc64gr
                     Produces object code that will run on any 64-
                     bit PowerPC hardware platform that supports
                     the optional graphics instructions.
                ppc64grsq
                     Produces object code that will run on any 64-
                     bit PowerPC hardware platform that supports
                     the optional graphics and square root
                     instructions.
                pwr
                     Produces an object that contains instructions
                     that run on any of the POWER or POWER2
                     hardware platforms.
                pwr2s
                     The executable file can be executed on any
                     desktop implementation of the POWER2 chip.
                pwr2
                     Produces an object that contains instructions
                     that run on the POWER2 hardware platforms.
                pwrx
                     Equivalent to pwr2.
                pwr3
                     Produces an object that contains instructions
                     that run on the POWER3, POWER4, POWER5,
                     POWER5+ or PowerPC 970 hardware platforms.
                pwr4
                     Produces an object that contains instructions
                     that run on the POWER4, POWER5, POWER5+ or
                     PowerPC 970 hardware platforms.
                pwr5
                     Produces an object that contains instructions
                     that run on the POWER5 or POWER5+ hardware
                     platforms.
                pwr5x
                     Produces an object that contains instructions
                     that run on any POWER5+ hardware platform.
                rs64a
                     Produces an object that contains instructions
                     that run on an RS64I hardware platform.
                rs64b
                     Produces an object that contains instructions
                     that run on an RS64II hardware platform.
                rs64c
                     Produces an object that contains instructions
                     that run on an RS64III hardware platform.
                601
                     Produces an object that contains instructions
                     that run on PowerPC 601 systems.
                603
                     Produces an object that contains instructions
                     that run on PowerPC 603 systems.
                604
                     Produces an object that contains instructions
                     that run on PowerPC 604 systems.
                ppc970
                     Generates instructions specific to PowerPC 970
                     processors.
                ppc64v
                     Generates instructions for any 64-bit PowerPC
                     processor (like PowerPC 970) with VMX.

                The default is -qarch=com.

         -qassert=<suboptions_list>
                Provides information about the program to help
                fine-tune optimizations. <suboptions_list> is a
                colon-separated list of one or both of the
                following suboptions:

                deps | nodeps
                     Loops can contain loop-carried dependencies.
                itercnt=<n>
                     The iteration count of a typical loop is <n>.

                The default is -qassert=deps:itercnt=1024.

         -qcache=<suboptions_list>
                Specifies the cache configuration for a specific
                execution machine. <suboptions_list> is a colon-
                separated list of one or more of the following
                suboptions:

                assoc=<n>
                     Specifies the set-associativity of the cache:
                     0   = Directly-mapped
                     1   = Fully associative
                     (n > 1) = <n>-way set-associative
                auto
                     Automatically detects the specific cache
                     configuration of the compiling machine. It
                     assumes that the execution environment will be
                     the same as the compilation environment.
                cost=<cycles>
                     Specifies the performance penalty resulting
                     from a cache miss.
                level=<level>
                     Specifies which level of cache is affected:
                     1 = Basic cache
                     2 = Level-2 cache, or the table lookaside
                     buffer (TLB) if the machine has no level-2
                     cache
                     3 = TLB, in a machine that does have a level-2
                     cache
                line=<bytes>
                     Specifies the line size of the cache.
                size=<Kbytes>
                     Specifies the total size of the cache.
                type=<type>
                     Specifies the type of cache that the settings
                     apply to:
                     C or c = Combined data and instruction cache
                     D or d = Data cache
                     I or i = Instruction cache

                The default is determined by the -qtune and -qarch
                settings.

         -qcompact | -qnocompact
                Reduces optimizations that increase code size.  The
                default is -qnocompact.

         -qdirectstorage | -qnodirectstorage
                Specifies that a compilation unit might reference
                write-through-enabled or cache-inhibited storage.
                The default is -qnodirectstorage.

         -qenablevmx | -qnoenablevmx
                Enables generation of Vector Multimedia Extension
                (VMX) instructions.  The default is -qnoenablevmx.

         -qessl | -qnoessl
                Allows the use of the Engineering and Scientific
                Subroutine Library (ESSL) routines in place of
                Fortran 90 intrinsic procedures.  The default is
                -qnoessl.

         -qfdpr | -qnofdpr
                Provides object files with information that the AIX
                Feedback Directed Program Restructuring (fdpr)
                performance-tuning utility needs to optimize the
                resulting executable file.  The default is
                -qnofdpr.

         -qhot[=<suboptions>] | -qnohot
                Performs high-order loop analysis and
                transformations during optimization. This option is
                a powerful alternative to hand-tuning that provides
                opportunities to optimize loops and array language.
                The suboptions are:

                arraypad[=<n>]
                     When <n> is specified, the compiler will pad
                     every array in the code. The pad amount must
                     be a positive integer value. When <n> is not
                     specified, the compiler will pad any arrays
                     where it infers that there may be a benefit.
                level={0|1}
                     Specifies the level of high-order
                     transformation to perform during compilation.
                     At level=1, full high-order transformation is
                     performed, but at level=0 only a subset of the
                     high-order transformations are performed,
                     which reduces compile time. See the XL Fortran
                     Compiler Reference for more information.
                simd | nosimd
                     Converts certain operations in a loop that
                     apply to successive elements of an array into
                     a VMX (Vector Multimedia Extension)
                     instruction.  If you specify -qhot=nosimd, the
                     compiler performs optimizations on loops and
                     arrays, but avoids replacing certain code with
                     VMX instructions.
                vector | novector
                     Specifies whether to allow the compiler to
                     optimize by replacing code with calls to
                     vector library routines.  Only takes effect
                     when specified with -qnostrict or -O3 or
                     higher optimization level.

                The default is -qnohot. If -qhot is specified
                without parameters, the default is -qhot=vector.

         -qipa[=<suboptions_list>] | -qnoipa
                Enhances -O optimization by performing detailed
                analysis across procedures. Optimization level -O2
                or higher is required when using -qipa.
                <suboptions_list> is a colon-separated list of
                suboptions. Regular expressions are supported when
                specifying <procedure_names_list> in the following
                -qipa suboptions: exits, inline, noinline, lowfreq,
                pure, safe, and unknown. <procedure_names_list> is
                a comma-separated list. The suboptions are:

                exits=<procedure_names_list>
                     Specifies a selected set of procedures which
                     always end the program.
                clonearch=<architecture_list> | noclonearch
                     Allows you to specify multiple architectures
                     in the event that you want to compile your
                     application for multiple architectures with a
                     single binary file. <architecture_list> is a
                     comma-separated list of one or more of the
                     following architectures: pwr4, pwr5, ppc970,
                     and pwr5x. This must be specified during link
                     time.  The default is noclonearch.
                cloneproc=<names_list> | nocloneproc=<names_list>
                     Allows you to explicitly declare which
                     procedures the compiler should attempt to
                     clone. <names_list> is a comma-separated list
                     of the mangled names of the functions that you
                     wish to clone (or not clone). Please note that
                     this suboption has no effect unless
                     -qipa=clonearch=<arch> is specified. You can
                     use regular expression syntax when specifying
                     function names.  The default is nocloneproc.
                inline=<options_list>
                     Specifies a colon-separated list of inline
                     options, which are as follows:
                     auto | noauto
                          Specifies whether to automatically
                          perform inline expansion.  The default is
                          auto.
                     limit=<n>
                          Changes the size limits that the
                          inline=auto option uses to determine how
                          much inline expansion to do. <n> is the
                          optimizers approximation of the number of
                          bytes of code that will be generated.
                     <procedure_names_list>
                          Specifies the procedures to attempt to
                          inline.
                     threshold=<num>
                          Specifies the upper size limit on
                          procedures to inline. This argument is
                          implemented only when inline=auto is on.
                noinline=<procedure_names_list>
                     Specifies the procedures which are not to be
                     inlined.
                isolated=<procedure_names_list>
                     Specifies the procedures that are not compiled
                     with -qipa and do not directly refer to any
                     global variable.
                level=<level>
                     Determines the amount of IPA analysis and
                     optimization to perform:
                     0
                          Performs minimal inter-procedural
                          analysis and optimization.
                     1
                          Turns on inlining, limited alias
                          analysis, and limited call-site
                          tailoring.
                     2
                          Full inter-procedural data flow and alias
                          analysis.
                     The default level is 1.
                list[={<filename>|short|long}]
                     Specifies an output listing file name during
                     the link phase, in the event that an object
                     listing has been requested using the -qlist or
                     -qipa=list option. The default name is
                     "a.lst". Specifying 'long' or 'short'
                     determines which listing sections will be
                     included. The default is short.
                lowfreq=<procedure_names_list>
                     Specifies the procedures that are likely to be
                     called infrequently during the course of a
                     typical program run.
                malloc16 | nomalloc16
                     Instructs the compiler to assume that the
                     dynamic memory allocation routines (such as
                     malloc/calloc/realloc/new) will return 16-byte
                     aligned memory addresses. The compiler will
                     optimize based on this assumption. Note that
                     if the assertion is false, incorrect results
                     may be generated.  The default is 'malloc16'
                     in 64-bit mode, and 'nomalloc16' otherwise.
                missing={unknown|safe|isolated|pure}
                     Specifies the interprocedural behavior for
                     procedures not compiled with -qipa.  The
                     default is 'unknown'.
                object | noobject
                     Includes standard object code in the object
                     files. If the noobject option is specified, it
                     can substantially reduce overall compilation
                     time by not generating object code during the
                     first IPA phase. The default is object. Note,
                     this is a compile-time suboption.
                partition={small|medium|large}
                     Specifies the size of the regions within the
                     program to analyze. Larger partitions contain
                     more procedures, which result in better
                     interprocedural analysis but require more
                     storage to optimize.  The default is medium.
                pdfname=<filename>
                     Specifies the name of the profile data file
                     that contains the PDF profiling information.
                     The default filename is __pdf.
                pure=<procedure_names_list>
                     Specifies a list of procedures that are not
                     compiled with -qipa. Any procedure that you
                     specified as "pure" must be "isolated" and
                     "safe". It must not alter the internal state
                     nor have side-effects, which are defined as
                     potentially altering any data object visible
                     to the caller.
                safe=<procedure_names_list>
                     Specifies a list of procedures that are not
                     compiled with -qipa. Any procedure that you
                     specified as "safe" may modify global
                     variables and dummy arguments.
                stdexits | nostdexits
                     Specifies that certain predefined routines can
                     be optimized as with the exits suboption. The
                     procedures are abort, exit, _exit, and
                     _assert.  The default is nostdexits.
                threads[=<n>] | nothreads
                     Specifies the number of threads for the
                     compiler to use. When <n> is not specified,
                     the compiler decides the number of threads.
                     Otherwise, up to <n> threads are used to
                     invoke the compiler backend. Specifying
                     'nothreads' is equivalent to running one
                     serial process.
                unknown=<procedure_names_list>
                     Specifies a list of procedures that are not
                     compiled with -qipa. Any procedure specified
                     as "unknown" may make calls to other parts of
                     the program compiled with -qipa and modify
                     global variables and dummy arguments.

                Options intended for use by the link-time phase of
                -qipa are -qlibansi, -qlibessl, -qlibposix and
                -qthreaded.  The default is -qnoipa.

         -qkeepparm | -qnokeepparm
                Ensures that the incoming parameters are stored on
                the stack even when optimizing. This may negatively
                impact execution performance. This option then
                provides access to the values of incoming
                parameters to tools, such as debuggers, simply by
                preserving those values on the stack.  The default
                is -qnokeepparm.

         -qlargepage | -qnolargepage
                Indicates that a program, designed to execute in a
                large page memory environment, can take advantage
                of large 16 MB pages provided on POWER4 and higher
                based systems.  The default is -qnolargepage.

         -qlibansi | -qnolibansi
                Assumes that all functions with the name of an ANSI
                C defined library function are in fact the library
                functions.  The default is -qnolibansi.

         -qlibessl | -qnolibessl
                Assumes that all functions with the name of an ESSL
                defined library function are, in fact, the library
                functions.  The default is -qnolibessl.

         -qlibposix | -qnolibposix
                Assumes that all functions with the name of a POSIX
                1003.1 defined library function are, in fact, the
                system functions.  The default is -qnolibposix.

         -qmaxmem=<kbytes>
                Limits the amount of memory that the compiler
                allocates while performing specific, memory-
                intensive optimizations. If <kbytes> is -1, the
                compiler will take as much memory as it needs
                without checking for limits. The default is
                -qmaxmem=2048 when using optimization level -O2,
                and -qmaxmem=-1 when using -O3 or greater.

         -qoptimize[=<level>] | -qnooptimize
                The long form of the -O option. -qoptimize=<level>
                is equivalent to -O<level>. See the -O option.  The
                default is -qnooptimize.

         -qpdf1 Produces an object that is instrumented to collect
                run-time execution information. This is phase 1 of
                the profile-directed feedback optimization process.

         -qpdf2 Tunes application performance using the data
                generated by running a program compiled with
                -qpdf1. This is phase 2 of the profile-directed
                feedback optimization process.

         -qprefetch | -qnoprefetch
                Automatically inserts prefetch instructions where
                the optimizer perceives a benefit.  The default is
                -qprefetch.

         -qrecur | -qnorecur
                Not recommended. Allows external subprograms to be
                called recursively. For new programs, use the
                RECURSIVE keyword, which provides a standard-
                conforming way of using recursive procedures.  The
                default is -qnorecur.

         -qshowpdf | -qnoshowpdf
                Adds additional call and block count profiling
                information to an executable. This option is used
                together with the -qpdf1 option.  The default is
                -qnoshowpdf.

         -qsmallstack[=<suboption>] | -qnosmallstack
                Specifies that the compiler will minimize stack
                usage where possible. This option can take the
                form:

                -qsmallstack
                     Enables only general small stack
                     transformations.
                -qsmallstack=dynlenonheap
                     Asserts that automatic variables which are
                     dynamically-sized are allocated from the heap
                     and enables general small stack
                     transformations.
                -qsmallstack=nodynlenonheap
                     Disables dynamic-length variable allocation.
                -qnosmallstack
                     Disables only the general small stack
                     transformations.

                The default is -qnosmallstack.

         -qsmp[=<suboptions_list>] | -qnosmp
                Specifies that code should be produced for an SMP
                system.  <suboptions_list> is a colon-separated
                list of one or more of the following suboptions:

                auto | noauto
                     Enables automatic parallelization.
                nested_par | nonested_par
                     Specifies that prescriptive nested parallel
                     constructs should be parallelized by the
                     compiler.
                omp | noomp
                     Enforces compliance with the OpenMP Fortran
                     API.
                opt | noopt
                     Controls optimization for parallelization.
                     -qsmp=noopt specifies that the compiler should
                     do the least amount of optimization that is
                     required to parallelize the code and preserve
                     maximum debugability.
                rec_locks | norec_locks
                     Allows recursive locks to be used to avoid
                     problems associated with CRITICAL constructs.
                     If -qsmp=norec_locks is specified, recursive
                     locks will not be used to implement critical
                     sections.
                schedule=<suboptions>
                     The schedule suboption can take any of the
                     following sub-suboptions:
                     affinity[=<n>]
                     dynamic[=<n>]
                     guided[=<n>]
                     runtime
                     static[=<n>]
                     For their descriptions, refer to the XL
                     Fortran Compiler Reference.
                threshold=<n>
                     Controls the amount of automatic loop
                     parallelization that occurs. The value of <n>
                     represents the lower limit allowed for
                     parallelization of a loop, based on the level
                     of "work" present in a loop.

                The default is -qnosmp.  If you specify -qsmp
                without suboptions, the default suboptions are:
                auto, opt, noomp, norec_locks, nonested_par,
                schedule=runtime, and threshold=100.

         -qspillsize=<bytes>
                The long form of -NS. See the -NS option.  The
                default is -qspillsize=512.

         -qstacktemp=<num>
                Determines where to allocate applicable compiler
                temporaries at run time. The allocation depends on
                the value of <num>. The values are:

                0
                     Indicates that the compiler will decide
                     whether to allocate the applicable compiler
                     temporaries on the heap or the stack.
                -1
                     Indicates that applicable compiler temporaries
                     are to be always allocated on the stack. This
                     is the best-performing setting but uses the
                     most amount of stack storage.
                (1 or greater)
                     Indicates that applicable compiler temporaries
                     less than this value (bytes) should be
                     allocated on the stack and those greater than
                     or equal to this value should be allocated on
                     the heap.

                The default is -qstacktemp=0.

         -qstrict | -qnostrict
                Ensures that optimizations done by the -O3 and
                greater (and optionally -O2) options do not alter
                the semantics of a program. This option is ignored
                for -qnoopt.  For -O3 and greater, the default is
                -qnostrict. Otherwise the default is -qstrict.

         -qstrict_induction | -qnostrict_induction
                Prevents the compiler from performing induction
                (loop counter) variable optimizations that could
                alter the semantics of a program.  The default is
                -qnostrict_induction.

         -qthreaded
                Asserts that the compiler will generate thread-safe
                code when generating its own code or allocating
                compiler-created temporary data. User-written code
                that is algorithmically not thread-safe is
                unaffected by this option and will remain non-
                thread-safe. The default is -qthreaded when using
                xlf_r, xlf_r7, xlf90_r, xlf90_r7, xlf95_r, or
                xlf95_r7 invocation commands.

         -qtune=<suboption>
                Tunes instruction selection, scheduling, and other
                implementation-dependent performance enhancements
                for a specific implementation of a hardware
                architecture.  -qtune will not alter the ability of
                a program to run on a processor but will produce
                optimal code sequences tuned to a particular
                processor.  The suboptions are:

                auto
                     Automatically detects the specific processor
                     type of the compiling machine and produces an
                     object optimized for that processor.
                601
                     Produces an object optimized for all the
                     PowerPC 601 processors.
                603
                     Produces an object optimized for all the
                     PowerPC 603 processors.
                604
                     Produces an object optimized for all the
                     PowerPC 604 processors.
                pwr
                     Produces an object optimized for the POWER
                     hardware platforms.
                p2sc
                     The optimizations are tuned for the POWER2
                     Super Chip.
                pwr2
                     Produces an object optimized for the POWER2
                     hardware platforms.
                pwrx
                     This is equivalent to pwr2.
                pwr2s
                     The optimizations are tuned for the desktop
                     implementation of the POWER2 architecture,
                     which has a narrower processor-to-memory bus
                     than other POWER2 implementations.
                pwr3
                     Produces an object optimized for the POWER3
                     hardware platforms.
                pwr4
                     Produces an object optimized for the POWER4
                     hardware platforms.
                pwr5
                     Produces an object optimized for the POWER5
                     hardware platforms.
                rs64a
                     Produces an object optimized for the RS64I
                     processor.
                rs64b
                     Produces an object optimized for the RS64II
                     processor.
                rs64c
                     Produces an object optimized for the RS64III
                     processor.
                ppc970
                     Produces an object optimized for PowerPC 970
                     processors.

                The compiler uses -qtune setting that is compatible
                with the target architecture, which is controlled
                by the -qarch, -q32, and -q64 options.  The default
                setting is determined by the setting of -qarch.

         -qunroll[={auto|yes}] | -qnounroll
                Specifies whether unrolling DO loops is allowed in
                a program. Unrolling is allowed on outer and inner
                DO loops.  The suboptions are:

                auto
                     The compiler performs basic loop unrolling.
                yes
                     The compiler looks for more opportunities to
                     perform loop unrolling than is done with the
                     -qunroll=auto option. Specifying -qunroll with
                     no suboptions is equivalent to -qunroll=yes.

                The default is -qunroll=auto.

         -qunwind | -qnounwind
                Specifies that the compiler will preserve the
                default behavior for saves and restores to volatile
                registers during a procedure call.  If you specify
                -qnounwind, the compiler rearranges subprograms to
                minimize saves and restores to volatile registers.
                This rearrangement may make it impossible for the
                program or debuggers to walk through or "unwind"
                subprogram stack frame chains.  The default is
                -qunwind.

         -qvecnvol | -qnovecnvol
                Asserts that the compiled application will use both
                volatile and non-volatile vector registers. You
                should use this option only after understanding
                interoperability with old binaries. If you are
                compiling C/C++ code in Fortran which calls any of
                the following subroutines: setjmp(),longjmp(),
                sigsetjmp(), siglongjmp(), _setjmp(), _longjmp(),
                getcontext(), setcontext(), makecontext(), and
                swapcontext(), then you should set -qnovecnvol.
                bos.adt.include version 5.3.0.30 or greater should
                be installed to use -qvecnvol on the host system.
                The default is -qnovecnvol.

         -qzerosize | -qnozerosize
                Improves performance of Fortran 77 and some Fortran
                90 and Fortran 95 programs by preventing checking
                for zero-sized character strings and arrays.
                For the xlf90, xlf90_r, xlf90_r7, xlf95, xlf95_r,
                xlf95_r7, f90, and f95 commands, the default is
                -qzerosize.  For the xlf, xlf_r, xlf_r7, f77, and
                fort77 commands, the default is -qnozerosize.

  Error Checking and Debugging Options
         -C     Checks each reference to an array element, array
                section, or character substring for correctness.
                This is the short form of -qcheck.

         -D     Specifies whether the compiler compiles fixed
                source form lines with a D in column 1 or treats
                them as comments. Please note that in order to pass
                C-style -D macro definitions to the C preprocessor
                (e.g. compiling a file that ends with .F) use the
                -W option. For example:
                -WF,-DDEFINE_THIS
                -D is the short form of -qdlines.

         -g     Generates debug information for use by a symbolic
                debugger.

         -qcheck | -qnocheck
                The long form of the -C option. See -C for details.
                The default is -qnocheck.

         -qdbg | -qnodbg
                The long form of the -g option. See -g for details.
                The default is -qnodbg.

         -qdpcl | -qnodpcl
                Generates symbols that tools based on the Dynamic
                Probe Class Library (DPCL) API can use to see the
                structure of an executable file. You must also
                specify the -g option when you specify -qdpcl.
                This option has no effect when optimization (-O) is
                enabled. The default is -qnodpcl.

         -qextchk | -qnoextchk
                Sets up type-checking information for common
                blocks, procedure definitions, procedure
                references, and module data. Later, the linker can
                detect mismatches across compilation units using
                this information.  The default is -qnoextchk.

         -qflttrap[=<suboptions_list>] | -qnoflttrap
                Determines what types of floating-point exception
                conditions to detect at run time. The program
                receives a SIGTRAP signal when the corresponding
                exception occurs.  <suboptions_list> is a colon-
                separated list of one or more of the following
                suboptions:

                enable
                     Turn on checking for the specified exceptions
                     in the main program so that the exceptions
                     generate SIGTRAP signals.
                imprecise
                     Only check for the specified exceptions on
                     subprogram entry and exit.
                inexact
                     Detect and trap on floating-point inexact, if
                     exception checking is enabled.
                invalid
                     Detect and trap on floating-point invalid
                     operations.
                nanq
                     Detect and trap all quiet not-a-number (NaNQ)
                     values and signaling not-a-number (NaNS)
                     values.
                overflow
                     Detect and trap on floating-point overflow.
                underflow
                     Detect and trap on floating-point underflow.
                zerodivide
                     Detect and trap on floating-point division by
                     zero.

                The default is -qnoflttrap. When -qflttrap is
                specified with no suboptions, the default activated
                suboptions are: overflow, underflow, zerodivide,
                invalid, and inexact.

         -qfullpath | -qnofullpath
                Records the full (or absolute) path names of source
                and include files in object files compiled with
                debugging information (-g option).  The default is
                -qnofullpath.

         -qhalt=<sev>
                Stops before producing any object, executable, or
                assembler source files if the maximum severity of
                compile-time messages equals or exceeds the
                specified severity <sev>, where the severity levels
                are:

                i = informational messages
                l = language-level messages
                w = warning messages
                e = error messages
                s = severe error messages
                u = unrecoverable error messages
                q = no messages

                The default is -qhalt=s.

         -qinitauto[=<hex_value>] | -qnoinitauto
                Initializes each byte or word (4 bytes) of storage
                for automatic variables to a specific value,
                depending on the length specified in <hex_value>.
                This helps you to locate variables that are
                referenced before they are defined. <hex_value> is
                a 1 to 8 digit hexadecimal number.  The default is
                -qnoinitauto. If you specify -qinitauto without a
                <hex_value>, the compiler initializes the value of
                each byte of automatic storage to zero. This option
                should be used for debugging purposes only.

         -qlanglvl=<suboption>
                Determines which language standard (or
                subset/superset of a standard) to check against for
                nonconformance. This option will only produce
                messages; all code valid in extended mode will
                compile regardless of which suboption is specified.
                The suboptions are:

                77std
                     Accepts the language specified by the ANSI
                     Fortran 77 standard.
                90std
                     Accepts the language specified by the ISO
                     Fortran 90 standard.
                90pure
                     Same as 90std, except that it reports errors
                     for any obsolescent Fortran 90 features used.
                90ext
                     Obsolete suboption that is equivalent to
                     extended.
                95std
                     Accepts the language specified by the ISO
                     Fortran 95 standard.
                95pure
                     Same as 95std, except that it also reports
                     errors for any obsolescent Fortran 95 features
                     used.
                2003std
                     Accepts the language that the ISO Fortran 95
                     standard specifies, as well as all Fortran
                     2003 features supported by XL Fortran, and
                     reports anything else as an error.
                2003pure
                     The same as 2003std except that it also
                     reports errors for any obsolescent Fortran
                     2003 features used.
                extended
                     Accepts the full Fortran 95 language standard,
                     all Fortran 2003 features supported by XL
                     Fortran, and all extensions, effectively
                     turning off language-level checking.

                The default is -qlanglvl=extended.

         -qlinedebug | -qnolinedebug
                Generates line number and source file name
                information for the debugger. This option produces
                minimal debugging information, so the resulting
                object size is smaller than what is produced if the
                -g debugging option is specified. The default is
                -qnolinedebug.

         -qobject | -qnoobject
                Specifies whether to produce an object file or to
                stop immediately after checking the syntax of the
                source files.  The default is -qobject.

         -qsaa | -qnosaa
                Checks for conformance to the SAA Fortran language
                definition. It identifies nonconforming source code
                and also options that allow such nonconformances.
                The default is -qnosaa.

         -qsaveopt | -qnosaveopt
                Saves the command-line options used for compiling a
                source file, and other information, in the
                corresponding object file. The compilation must
                produce an object file for this option to take
                effect.  The default is -qnosaveopt.

         -qsigtrap[=<trap_handler>]
                When you are compiling a file that contains a main
                program, this option sets up the specified trap
                handler to catch SIGTRAP exceptions. This option
                enables you to install a handler for SIGTRAP
                signals without calling the SIGNAL subprogram in
                the program. Specifying -qsigtrap with no
                <trap_handler> is equivalent to -qsigtrap=xl__trce.

         -qtbtable=<suboption>
                Limits the amount of debugging traceback
                information in object files, which reduces the size
                of the program. The suboptions are:

                none
                     Includes no traceback information.
                small
                     Includes traceback information but not the
                     names of procedures or information about
                     procedure parameters.
                full
                     Includes complete traceback information.

                The default is full traceback information in the
                object file when compiling non-optimized (without
                -O) or for debugging (with -g).  Otherwise, the
                default is -qtbtable=small.

         -qwarn64 | -qnowarn64
                Assists in porting code from a 32-bit environment
                to a 64-bit environment by detecting the truncation
                of an 8-byte integer pointer to 4 bytes. The
                -qwarn64 option uses informational messages to
                identify statements that may cause problems with
                the 32-bit to 64-bit migration.  The default is
                -qnowarn64.

         -qxflag=<suboption>
                Specifies rarely-needed compiler behaviors.  The
                suboptions are:

                oldtab
                     For fixed source form programs, interprets a
                     tab in columns 1 to 5 as a single character.
                     The source statement still starts immediately
                     after the tab, but the tab character is
                     treated as a single character for counting
                     columns. This setting allows up to 71
                     characters of input, depending on where the
                     tab character occurs.
                dvz
                     Specifying -qxflag=dvz causes the compiler to
                     generate code to detect floating-point
                     divide-by-zero operations. With this option
                     on, the extra code calls the external handler
                     function __xl_dzx when the divisor is zero.
                xalias
                     This is obsolete. Please use -qalias=nostd in
                     your new applications.

         -qxlines | -qnoxlines
                Specifies whether fixed source form lines with a X
                in column 1 are compiled or treated as comments.
                The default is -qnoxlines.

  Listing and Message Options
         -#     Generates information on the progress of the
                compilation without actually running the individual
                components.

         -S     Produces one or more .s files, showing equivalent
                assembler source for each Fortran source file.

         -V     Generates information on the progress of the
                compilation. As the compiler executes commands to
                perform different compilation steps, this option
                displays a simulation of the commands it calls and
                the system argument lists it passes. This is the
                same as -v except that you can cut and paste
                directly from the display to create a command.

         -v     Generates information on the progress of the
                compilation. As the compiler executes commands to
                perform different compilation steps, this option
                displays a simulation of the commands it calls and
                the system argument lists it passes.

         -w     Suppresses informational, language-level, and
                warning messages. This option sets -qflag=e:e.

         -qattr[=full] | -qnoattr
                Specifies whether to produce the attribute
                component of the attribute and cross-reference
                section of the listing.  The listing contains all
                identifiers (-qattr=full) or only the names that
                are referenced (-qattr).  The default is -qnoattr.

         -qflag=<listing_severity>:<terminal_severity>
                Specifies the minimum severity level of diagnostic
                messages to be written to the listing file and to
                the user terminal. <listing_severity> determines
                the minimum level for the listing file, and
                <terminal_severity> determines the minimum level
                for the terminal.  The severity levels are:

                i = informational messages
                l = language-level messages
                w = warning messages
                e = error messages
                s = severe error messages
                u = unrecoverable error messages
                q = no messages

                Note that both <listing_severity> and
                <terminal_severity> must be specified.  The default
                is -qflag=i:i.

         -qlist[={offset|nooffset}] | -qnolist
                Produces a compiler listing that includes an object
                listing. You can use the object listing to help
                understand the performance characteristics of the
                generated code and to diagnose execution problems.
                Specifying -qlist with no suboptions is equivalent
                to specifying -qlist=nooffset.  The default is
                -qnolist.

         -qlistopt | -qnolistopt
                Determines whether to show the setting of every
                compiler option in the listing file or only
                selected options. These selected options include
                those specified on the command line or directives
                plus some that are always put in the listing.  The
                default is -qnolistopt.

         -qnoprint
                Prevents the compiler from creating the listing
                file, regardless of the settings of other listing
                options.

         -qphsinfo | -qnophsinfo
                Determines whether timing information is displayed
                on the terminal for each compiler phase.  The
                output takes the form <number1>/<number2> for each
                phase where <number1> represents the CPU time used
                by the compiler and <number2> represents the total
                of the compiler time and the time that the CPU
                spends handling system calls.  The default is
                -qnophsinfo.

         -qreport[=<suboptions>] | -qnoreport
                Determines whether to produce transformation
                reports showing how the program is parallelized and
                how loops are optimized.  The suboptions are:

                hotlist
                     Produces a report showing how loops are
                     transformed.
                smplist
                     Produces a report showing how the program is
                     parallelized.

                The default is -qnoreport.

         -qsource | -qnosource
                Determines whether to produce the source section of
                the listing.  The default is -qnosource.

         -qsuppress[={<msg_nums_list>|cmpmsg}] | -qnosuppress
                Determines which messages to suppress from the
                output stream.  The suboptions are:

                <msg_nums_list>
                     A colon-separated list of 7-digit compiler
                     message numbers.
                cmpmsg
                     Suppresses the informational messages that
                     report compilation progress and a successful
                     completion.

                The default is -qnosuppress.

         -qversion
                Displays the version and release of the invoking
                compiler. Specify this option on its own with the
                compiler command.

         -qxref[=full] | -qnoxref
                Determines whether to produce the cross-reference
                component of the attribute and cross-reference
                section of the listing.  If you specify only
                -qxref, only identifiers that are used are
                reported. If you specify -qxref=full, the listing
                contains information about all identifiers that
                appear in the program, whether they are used or
                not.  The default is -qnoxref.

  Compatibility Options
         -1     Executes each DO loop in the compiled program at
                least once if its DO statement is executed, even if
                the iteration count is 0. This option provides
                compatibility with Fortran 66. The default is to
                follow the behavior of later Fortran standards,
                where DO loops are not performed if the iteration
                count is 0. This is the short form of the -qonetrip
                option.

         -u     Specifies that no implicit typing of variable names
                is permitted. It has the same effect as using the
                IMPLICIT NONE statement in each scope that allows
                implicit statements. By default, implicit typing is
                allowed.

         -qautodbl=<setting>
                Converts single-precision floating-point
                calculations to double-precision or converts
                double-precision calculations to extended-
                precision.  <setting> can be:

                none
                     Does not promote or pad any objects that share
                     storage.
                dbl4
                     Promotes floating-point objects that are
                     single precision or are composed of such
                     objects.
                dbl8
                     Promotes floating-point objects that are
                     double-precision or are composed of such
                     objects.
                dbl
                     Combines the promotions done by dbl4 and dbl8.
                dblpad4
                     Performs the same promotions as dbl4, and pads
                     objects of other types (except CHARACTER) that
                     can share storage with promoted objects.
                dblpad8
                     Performs the same promotions as dbl8, and also
                     pads objects of other types (except CHARACTER)
                     if they can share storage with promoted
                     objects.
                dblpad
                     Combines the promotions done by dbl4 and dbl8,
                     and also pads objects of other types (except
                     CHARACTER) if they can share storage with
                     promoted objects.

                The default is -qautodbl=none.

         -qcclines | -qnocclines
                Enables recognition of conditional compilation
                lines in fixed source form and F90 free source
                form. IBM free source form is not supported.  The
                default is -qcclines if -qsmp=omp is specified.
                Otherwise, the default is -qnocclines.

         -qctyplss[={arg|noarg}] | -qnoctyplss
                Specifies whether character constant expressions
                are allowed wherever typeless constants may be
                used. Specifying -qctyplss=arg allows character
                constant expressions, but if a Hollerith constant
                is used as an actual argument, it is passed to the
                procedure as if it was an integer actual argument.
                The default is -qnoctyplss. If -qctypless is
                specified with no suboption, the default is
                -qctyplss=noarg.

         -qddim | -qnoddim
                Specifies that the bounds of pointee arrays are
                re-evaluated each time the arrays are referenced
                and removes some restrictions on the bounds
                expressions for pointee arrays.  The default is
                -qnoddim.

         -qdpc[=<e>] | -qnodpc
                Increases the precision of real constants, for
                maximum accuracy, when assigning real constants to
                DOUBLE PRECISION variables. -qdpc=<e> also promotes
                constants with an <e> exponent.  The default is
                -qnodpc.

         -qescape | -qnoescape
                Specifies whether the backslash is treated as an
                escape character in character strings, Hollerith
                constants, H edit descriptors, and character string
                edit descriptors.  The default is -qescape.

         -qextern=<procedure_names_list>
                Allows user-written procedures to be called instead
                of XL Fortran intrinsics. <procedure_names_list> is
                a colon-separated list of procedure names.  The
                procedure names are treated as if they appear in an
                EXTERNAL statement in each compilation unit being
                compiled.

         -qextname[=<names_list>] | -qnoextname
                Adds an underscore to the names of all global
                entities, which helps in porting programs from
                systems where this is a convention for mixed-
                language programs. <names_list> is a colon-
                separated list of global entity names.  The default
                is -qnoextname.

         -qinit=f90ptr
                Makes the initial association status of pointers
                disassociated instead of undefined. The default
                association status of pointers is undefined.

         -qintlog | -qnointlog
                Allows mixture of integer and logical data entities
                in expressions and statements. The default is
                -qnointlog.

         -qintsize={2|4|8}
                Sets the size (in bytes) of default INTEGER and
                LOGICAL data entities (that is, those for which no
                length or kind is specified).  The default is
                -qintsize=4.

         -qlog4 | -qnolog4
                Specifies whether the result of a logical operation
                with logical operands is a LOGICAL(4) or is a
                LOGICAL with the maximum length of the operands.
                The default is -qnolog4.

         -qmodule=mangle81
                Specifies that the compiler should use the XL
                Fortran Version 8.1 naming convention for non-
                intrinsic module files. This option allows you to
                produce modules and their associated object files
                with the Version 10.1 compiler and link these
                object files with others compiled with the Version
                8.1 compiler, or earlier.

         -qnullterm | -qnonullterm
                Appends a null character to each character constant
                expression that is passed as a dummy argument, to
                make it more convenient to pass strings to C
                functions. The default is -qnonullterm.

         -qonetrip | -qnoonetrip
                The long form of the -1 option. See -1 for details.
                The default is -qnoonetrip.

         -qport=<suboption> | -qnoport
                Increases flexibility when porting programs to XL
                Fortran, providing a number of options to
                accommodate Fortran language extensions.  The
                suboptions are:

                clogicals | noclogicals
                     Allows non-zero integers to be treated as true
                     when used as logicals. The change affects all
                     logical operators. This suboption only takes
                     effect if -qintlog is activated.  The default
                     is noclogicals.
                hexint | nohexint
                     Specifies that typeless constant hexadecimal
                     strings are converted to integers when passed
                     as actual arguments to the INT intrinsic
                     function. Typeless constant hexadecimal
                     strings which are not passed as actual
                     arguments to INT remain unaffected.  The
                     default is nohexint.
                mod | nomod
                     Relaxes existing constraints on the MOD
                     intrinsic function, allowing two arguments of
                     the same data type parameter to be of
                     different kind type parameters. The result
                     will be of the same type as the argument, but
                     with the larger kind type parameter value.
                     The default is nomod.
                nullarg | nonullarg
                     For an external or internal procedure
                     reference, this causes the compiler to treat
                     an empty argument (which is delimited by a
                     left parenthesis and a comma, two commas, or a
                     comma and a right parenthesis) as a null
                     argument. This suboption has no effect if the
                     argument list is empty.  The default is
                     nonullarg.
                sce | nosce
                     By default, the compiler performs short
                     circuit evaluation in selected logical
                     expressions using XL Fortran rules. Specifying
                     'sce' allows the compiler to use non-XL
                     Fortran rules. The compiler will perform short
                     circuit evaluation if the current rules allow
                     it.  The default is nosce.
                typestmt | notypestmt
                     The TYPE statement, which behaves in a manner
                     similar to the PRINT statement, is supported
                     whenever this option is specified. The default
                     is notypestmt.
                typlssarg | notyplssarg
                     Converts all typeless constants to default
                     integers if the constants are actual arguments
                     to an intrinsic procedure whose associated
                     dummy arguments are of integer type. Dummy
                     arguments associated with typeless actual
                     arguments of non-integer type remain
                     unaffected by this option.  The default is
                     notyplssarg.

                The default is -qnoport.

         -qposition={appendold|appendunknown}
                Positions the file pointer at the end of the file
                when data is written after an OPEN statement with
                no "POSITION=" specifier, and the corresponding
                "STATUS=" value (OLD or UNKNOWN) is specified.  The
                default depends on the I/O specifiers in the OPEN
                statement and on the compiler invocation command.
                The default is -qposition=appendold for the xlf,
                xlf_r, xlf_r7, and f77/fort77 commands and the
                defined Fortran 90 and Fortran 95 behaviors for the
                xlf90, xlf90_r, xlf90_r7, xlf95, xlf95_r, xlf95_r7,
                f90 and f95 commands.

         -qqcount | -qnoqcount
                Accepts the character-count Q edit descriptor (Q)
                as well as the extended-precision Q edit descriptor
                (Qw.d). With -qnoqcount, all Q edit descriptors are
                interpreted as the extended-precision Q edit
                descriptor.  The default is -qnoqcount.

         -qrealsize=<bytes>
                Sets the default size of REAL, DOUBLE PRECISION,
                COMPLEX and DOUBLE COMPLEX values. The allowed
                values for <bytes> are 4 and 8.  The default is
                -qrealsize=4.

         -qsave[=<suboption>] | -qnosave
                Specifies the default storage class for local
                variables.  The suboptions are:

                all
                     The default storage class for all local
                     variables is STATIC. This is the default when
                     -qsave is specified without a suboption.
                defaultinit
                     The default storage class is STATIC for local
                     variables of derived type that have default
                     initialization specified.

                Specifying -qnosave sets the default storage class
                to AUTOMATIC.  The default is -qsave for xlf,
                xlf_r, xlf_r7, f77, or fort77 to duplicate the
                behavior of FORTRAN77 commands, and -qnosave
                otherwise.

         -qsclk[=<suboption>]
                Specifies the resolution that the SYSTEM_CLOCK
                intrinsic procedure uses in a program.  The
                suboptions are:

                centi
                     Uses centisecond resolution for the values
                     returned.
                micro
                     Uses microsecond resolution.

                The default is -qsclk=centi.

         -qswapomp | -qnoswapomp
                Specifies that the compiler should recognize and
                substitute OpenMP routines in XL Fortran programs.
                The default is -qswapomp.

         -qundef | -qnoundef
                The long form of the -u option. See -u for details.
                The default is -qnoundef.

         -qxlf77=<settings_list>
                Provides compatibility with Fortran 77 aspects of
                language semantics and I/O data format that have
                changed. Most of these changes are required by the
                Fortran 90 standard. <settings_list> is a colon-
                separated list of one or more of the following
                suboptions:

                blankpad | noblankpad
                     For internal, direct-access, and stream-access
                     files, uses a default setting equivalent to
                     pad='no'. This setting produces conversion
                     errors when reading from such a file if the
                     format requires more characters than the
                     record has, thus duplicating the XL Fortran
                     Version 2 behavior.
                gedit77 | nogedit77
                     Uses Fortran 77 semantics for the output of
                     REAL objects with the G edit descriptor.
                intarg | nointarg
                     Converts all the integer arguments of an
                     intrinsic procedure to the kind of the longest
                     argument, if they are of different kinds.
                intxor | nointxor
                     Treats .XOR. as a logical binary intrinsic
                     operator rather than a defined operator.
                leadzero | noleadzero
                     Produces a leading zero in real output under
                     the D, E, L, F and Q edit descriptors.
                oldboz | nooldboz
                     Turns blanks into zeros for data read by B, O,
                     and Z edit descriptors, regardless of the
                     "BLANK=" specifier or any BN or BZ control
                     edit descriptors.
                persistent | nopersistent
                     Saves the addresses of arguments to
                     subprograms with ENTRY statements in static
                     storage.
                softeof | nosofteof
                     Allows READ and WRITE operations when a unit
                     is positioned after its endfile record, unless
                     that position is the result of executing an
                     ENDFILE statement.

                The default suboptions are: blankpad, nogedit77,
                nointarg, nointxor, leadzero, nooldboz,
                nopersistent, and nosofteof for the f90, xlf90,
                xlf90_r, xlf90_r7, f95, xlf95, xlf95_r, and
                xlf95_r7 commands, and are the exact opposite for
                the xlf, xlf_r, xlf_r7, f77, and fort77 commands.

         -qxlf90=<settings_list>
                Provides backward compatibility with XL Fortran for
                AIX Version 5 and the Fortran 90 standard for
                certain aspects of the Fortran language.
                <settings_list> is a colon-separated list of one or
                both of the following suboptions:

                signedzero | nosignedzero
                     Determines how the SIGN(A,B) function handles
                     signed real 0.0. Prior to XL Fortran Version
                     6.1, SIGN(A,B) returned |A| when B=-0.0. This
                     behavior conformed with the Fortran 90
                     standard. Now, if you specify the
                     -qxlf90=signedzero compiler option, SIGN(A,B)
                     returns -|A| when B=-0.0. This behavior
                     conforms to the Fortran 95 standard and is
                     consistent with the IEEE standard for binary
                     floating-point arithmetic.
                autodealloc | noautodealloc
                     Determines whether the compiler deallocates
                     allocatable objects that are declared locally
                     without either the SAVE or the STATIC
                     attribute and have a status of currently
                     allocated when the subprogram terminates.

                The default suboptions are signedzero and
                autodealloc for the xlf95, xlf95_r, xlf95_r7 and
                f95 invocation commands. For all other invocation
                commands, the default suboptions are nosignedzero
                and noautodealloc.

  Linking Options
         -b64   The AIX operating system provides 64-bit shared
                object files in both libc.a and libm.a. In 64-bit
                mode, you can use the -b64 linker option to
                instruct ld to bind with 64-bit objects.

         -bdynamic, -bshared, -bstatic
                Controls the processing of -l options and the way
                shared objects are processed by the linkage editor.
                This is available on AIX 4.2 and above.

                -bdynamic
                     Specifies that shared objects are linked
                     dynamically.
                -bshared
                     Equivalent to -bdynamic.
                -bstatic
                     Specifies that shared objects are statically
                     linked into the output file.

                The default is -bdynamic.

         -bhalt:<error_level>
                Specifies the maximum error level that is allowed
                before the linker (ld) command halts. If any linker
                command has an error return value greater than the
                value that is specified by the <error_level>
                variable, linking stops.  The default value is 4,
                as specified in the configuration file.

         -bloadmap:<filename>
                Requests that a log of linker actions and messages
                be saved in file <filename>. You can use the log to
                help diagnose linking problems.

         -bmaxdata=<bytes>
                Specifies the maximum amount of space to reserve
                for the program data segment for programs where the
                size of these regions is a constraint.  The default
                is -bmaxdata=0.

         -bmaxstack:<bytes>
                Specifies the maximum amount of space to reserve
                for the program stack segment for programs where
                the size of these regions is a constraint.

         -brtl | -bnortl
                Determines which algorithm will be used to find
                libraries that are specified with the -l option. If
                -brtl is specified, run-time linking is enabled.

         -bshared
                Controls the processing of -l options and the way
                shared objects are processed by the linkage editor.
                See "-bdynamic, -bshared, -bstatic" for details.
                This is equivalent to -bdynamic.

         -bstatic
                Controls the processing of -l options and the way
                shared objects are processed by the linkage editor.
                See "-bdynamic, -bshared, -bstatic" for details.

         -L<dir>
                Searches in directory <dir> for libraries specified
                by -l<key>.

         -l<key>
                Searches the specified library file at link time,
                where <key> selects the library lib<key>.a.

  Compiler Customization Options
         -B<prefix>
                Determines a substitute path name for executable
                files used during compilation, such as the compiler
                of linker. <prefix> is the name of a directory
                where the alternative executable files reside. It
                is added to the beginning of the standard program
                names and must end in a slash (/). This option can
                be used in combination with the -t option, which
                determines which of these components are affected
                by -B.

         -F[<config_file>][:<stanza>]
                Specifies an alternative configuration file
                <config_file>, the command to be used (<stanza>)
                within the configuration file, or both. At least
                one of the arguments must be supplied.  The default
                stanza depends on the name of the command used to
                invoke the compiler.

         -P{v|k}[!]
                This option is obsolete and has no effect. Invokes
                the selected optimizing preprocessor.

         -P     Invokes the -Pv preprocessor before the compiler.

         -Pv    Invokes the -Pv preprocessor before the compiler.

         -Pk    Invokes the -Pk preprocessor before the compiler.

         -P!    Invokes the -Pv preprocessor only.

         -Pv!   Invokes the -Pv preprocessor only.

         -Pk!   Invokes the -Pk preprocessor only.

         -t<components_list>
                Applies the prefix from the -B option to the
                specified program, <components_list>, where
                <components_list> is a chain (with no separator
                character inbetween each <component>, ie: "-taFp")
                containing one or more of the following:

                COMPONENT NAME           <component>       PROGRAM
                assembler                 a                as
                C preprocessor            F                cpp
                VAST-2 preprocessor       p                fpp
                KAP preprocessor          p                fppk
                compiler front end        c                xlfentry
                array language optimizer  h                xlfhot
                IPA/loop optimizer        I (upper-case i) ipa
                code generator            b                xlfcode
                binder                    z                bolt
                linker                    l (lower-case L) ld
                disassembler              d                dis

         -W<component>,<options_list>
                Passes the listed options to a component that is
                executed during compilation. <options_list> is a
                comma-separated list of one or more options, and
                <component> is one of the following:

                COMPONENT NAME           <component>       PROGRAM
                assembler                 a                as
                C preprocessor            F                cpp
                VAST-2 preprocessor       p                fpp
                KAP preprocessor          p                fppk
                compiler front end        c                xlfentry
                array language optimizer  h                xlfhot
                IPA/loop optimizer        I (upper-case i) ipa
                code generator            b                xlfcode
                binder                    z                bolt
                linker                    l (lower-case L) ld
                disassembler              d                dis

  Integer and Floating-Point Options
         -y<rounding_mode>
                Specifies compile-time rounding of constant
                floating-point expressions. It is equivalent to the
                -qieee option. <rounding_mode> is one of the
                following:

                n = Round to nearest
                m = Round toward minus infinity
                p = Round toward plus infinity
                z = Round toward zero

                The default is -yn.

         -qfloat=<suboptions_list>
                Determines different strategies for speeding up or
                improving the accuracy of floating-point
                calculations. <suboptions_list> is a colon-
                separated list of one or more of the following
                suboptions:

                fltint | nofltint
                     Speeds up floating-point-to-integer
                     conversions by using an inline sequence of
                     code instead of a call to a library function.
                fold | nofold
                     Evaluates constant floating-point expressions
                     at compile time.
                hsflt | nohsflt
                     Speeds up calculations by removing range-
                     checking on single-precision float results,
                     and on conversions from floating-point to
                     integer.
                hssngl | nohssngl
                     Speeds up calculations in a safer way than
                     hsflt, by rounding single-precision
                     expressions only when the results are stored
                     into REAL(4) memory locations
                maf | nomaf
                     Generates multiply-add instructions where
                     appropriate.
                nans | nonans
                     Allows you to use the -qflttrap=invalid:enable
                     option to detect and deal with exception
                     conditions that involve signaling NaN (not-a-
                     number) values.
                rndsngl | norndsngl
                     Rounds the result of each single-precision
                     (REAL(4)) operation to single-precision,
                     rather than waiting until the full expression
                     is evaluated. It sacrifices speed for
                     consistency with results from similar
                     calculations on other types of computers.
                rrm | norrm
                     Turns off compiler optimizations that require
                     the rounding mode to be the default, round-
                     to-nearest, at run time.
                rsqrt | norsqrt
                     Allows the optimizer to change a division by
                     the result of a square root operation into a
                     multiply by the reciprocal of the square root.
                strictnmaf | nostrictnmaf
                     Turns off floating-point transformations that
                     are used to introduce negative MAF
                     instructions, as these transformations do not
                     preserve the sign of a zero value.
                The default active suboptions are: nofltint, fold,
                nohsflt, nohssngl, maf, nonans, norelax, norndsngl,
                norrm, norsqrt, and nostrictnmaf.

         -qieee=<mode>
                Specifies the rounding mode for the compiler to use
                when evaluating constant floating-point expressions
                at compile time, where <mode> is one of:

                near = Round to nearest representable number
                minus = Round toward minus infinity
                plus = Round toward plus infinity
                zero = Round toward zero

                The default is -qieee=near.

         -qstrictieeemod | -qnostrictieeemod
                Specifies that the compiler will adhere to the
                Fortran 2003 IEEE arithmetic rules for the
                ieee_arithmetic and ieee_exceptions intrinsic
                modules.  The default is -qstrictieeemod.

  SEE ALSO
         xlfndi(1), showpdf(1), cleanpdf(1), mergepdf(1),
         resetpdf(1)

         For more information, refer to the following Web sites:
         www.ibm.com/software/awdtools/fortran/xlfortran/library/
         www.ibm.com/software/awdtools/fortran/xlfortran/support/

  COPYRIGHT
         Licensed Materials - Property of IBM

         IBM(R) XL Fortran Enterprise Edition V10.1 for AIX(R)

         5724-M13

         (C) Copyright IBM Corp. 1991, 2005, and by others. All
         Rights Reserved.

         IBM and AIX are trademarks or registered trademarks of IBM
         Corp. in the U.S., other countries or both.

         US Government Users Restricted Rights - Use, duplication
         or disclosure restricted by GSA ADP Schedule Contract with
         IBM Corp.