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


  DESCRIPTION
         The invocation commands compile Fortran source files.
         The commands and their recommended usages are described below.

         Invocations                   Usage (supported standards)
         _________________________________________________________

         xlf, xlf_r, f77,              Compile FORTRAN 77 source
         fort77                        files.

         xlf90, xlf90_r, f90           Compile Fortran 90 source
                                       files.

         xlf95, xlf95_r, f95           Compile Fortran 95 source
                                       files.

         xlf2003, xlf2003_r,           Compile Fortran 2003 source
         f2003                         files.

         xlf2008, xlf2008_r,           Compile Fortran 2008 source
         f2008                         files.

         The main difference between these commands is that they use different default options (which are set in the configuration file
         /opt/ibm/xlf/15.1.3/etc/xlf.cfg.${OSRelease}.gcc${gccVersion}).
         See the XL Fortran Compiler Reference for more information on these invocation commands.

         All invocations with a suffix of _r allow for thread-safe compilation. Use these commands to create threaded applications or to link programs that use multi-threading.

         These commands also process assembler source files and object files. The compiler calls the link editor to produce a single executable unless you specify the compiler options
         that prevent object files from being linked.

         The input file may have any of the following suffixes:

          .f, .f77, .f90, .f95,        Fortran source file
          .f03, .f08

          .o or .a                     Object file for ld command

          .s                           Assembler source file

          .so or .a                    Shared object file

          .F, .F77, .F90, .F95,        Fortran source file
          .F03, .F08                   with cpp preprocessor
                                                directives


  Output control options
         -c     Instructs the compiler to compile or assemble the source files only but do not link. This option produces an object file, file_name.o, for each valid source file.

         -d     Keeps temporary files produced by C preprocessor (cpp), instead of deleting them. By default, temporary files produced by cpp are deleted.

         -MMD

         -qmakedep[=gcc]
                Produces a dependency output file containing targets suitable for inclusion in a description file for the make command. The dependency output file is named with a .d
                suffix. -qmakedep is the long form of -MMD. The suboption can be:

                gcc
                     The format of the generated make rule to match the GCC format: the dependency output file includes a single target that lists all of the source file's
                     dependencies.

         -MF <file_path>
                Specifies the name or location for the dependency output files that are generated by the -qmakedep or -MMD option, where <file_path> can be a full directory path or
                file name.

         -qmkshrobj
                Creates a shared object from the generated object files.
                By default, the output object is linked with the runtime libraries and startup routines to create an executable file.
                Specifying -qmkshrobj implies -qpic.
                You can also use the following related options with -qmkshrobj.
                -o shared_file
                -e name

         -qmoddir=<directory>
                Specifies the location for any .mod or .smod files that the compiler writes.

                Default:
                     .mod and .smod files are placed in the current directory.

         -MT <target>
                Specifies the target name of the object file in the make rule in the dependency output file that is generated by the -qmakedep or -MMD option.

         -o <name>
                Specifies a name for the output object, assembler, or executable file.

                Default: -o a.out

         -S     Generates an assembler language file (.s) for each source file. The resulting .s files can be assembled to produce object .o files or an executable file (a.out).

         -qtimestamps | -qnotimestamps
                Controls whether or not implicit time stamps are inserted into an object file.

                This option does not affect time stamps inserted by pragmas and other explicit mechanisms.

                Default: -qtimestamps

  Input control options

                Default: -qnocr

         -qdirective[=<directive_list>] | -qnodirective[=<directive_list>]
                Specifies sequences of characters, known as trigger constants, that identify comment lines as compiler comment directives.

                Default: -qnodirective

         -qfixed[=<right_margin>]
                Indicates that the input source program is in fixed source form and optionally specifies the maximum line length.

                Default:
                     o -qfixed=72 for the xlf, xlf_r, f77, and fort77 invocation commands
                     o -qfree=f90 for the xlf90, xlf90_r, f90, xlf95, xlf95_r, f95, xlf2003, xlf2003_r, f2003, xlf2008, xlf2008_r and f2008 invocation commands

         -WF,-qfpp[=<suboptions_list>] | -WF,-qnofpp
                Controls Fortran-specific preprocessing in the C preprocessor.
                Note: This is a C preprocessor option, and must therefore be specified using the -WF option.

                Default: -WF,-qnofpp

                <suboptions_list> is a colon-separated list of one or more of the following suboptions:

                comment | nocomment
                     Instructs the C preprocessor (cpp) to recognize the ! character as a comment delimiter in macro expansion. When this suboption is enabled, the ! character and all
                     characters following it on that line will be ignored.
                     Default: comment
                linecont | nolinecont
                     Instructs cpp to recognize the & character as a line continuation character. When this suboption is enabled, cpp treats the & character and the C-style  line
                     continuation character equivalently.
                     Default: linecont

         -qfree[=f90|ibm]
                Indicates that the source code is free form.

                ibm
                     Specifies compatibility with the free source form defined for VS FORTRAN.
                f90
                     Specifies compatibility with the free source form defined for Fortran 90, Fortran 95,  Fortran 2003, and Fortran 2008.

                Default:
                     o -qfixed=72 for the xlf, xlf_r, f77, and fort77 invocation commands
                     o -qfree=f90 for the xlf90, xlf90_r, f90, xlf95, xlf95_r, f95, xlf2003, xlf2003_r, f2003, xlf2008, xlf2008_r and f2008 invocation commands

         -I <directory_path>
                Adds a directory to the search path for #include files and .mod 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.

         -k     Indicates that the source code is in free source form.
                This option is the short form of -qfree=f90.

         -qmixed | -qnomixed
                     where <suffix> is the new preprocessor source-file suffix.

         -U     Makes the compiler case sensitive for names. Suppresses lowercase folding of Fortran code. By default, the compiler interprets all names as if they were in lowercase.

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

                Default: -qnoxlines

         -WF,-q[no]ppsuborigarg
                Instructs the C preprocessor to substitute original macro arguments before further macro expansion.
                Note: -qppsuborigarg is a C preprocessor option, and must therefore be specified using the -WF option.

                Default: -WF,-qnoppsuborigarg

  Language element control options
         -qaltivec[=le | be]
                Specifies the order of vector elements in vector registers.
                le
                     In vector registers, changes the vector element sequence to little-endian element order, with the first element on the right.
                be
                     In vector registers, changes the vector element sequence to big-endian element order, with the first element on the left.
                Default: -qaltivec=le

         -D     Specifies whether the compiler compiles fixed source form lines with a D in column 1 or treats them as comments.

         -qdlines | -qnodlines
                The long form of the -D option.

                Default: -qnodlines

         -qlanglvl=<suboptions_list>
                Determines which language standard (or superset, or subset of a standard) to consult for nonconformance. It identifies nonconforming source code and also options that
                allow such nonconformances.
                <suboptions_list> is a colon-separated list of the following suboptions:

                77std
                     Accepts the language that the ANSI FORTRAN 77 standard specifies and reports anything else using language-level messages.
                90std
                     Accepts the language that the ISO Fortran 90 standard specifies and reports anything else using language-level messages.
                90pure
                     The same as 90std except that it also reports language-level messages for any obsolescent Fortran 90 features used.
                90ext
                     Obsolete suboption that is equivalent to extended. To avoid problems in the future, use the extended suboption instead.
                95std
                     Accepts the language that the ISO Fortran 95 standard specifies and reports anything else using language-level messages.
                95pure
                     The same as 95std except that it also reports language-level messages for any obsolescent Fortran 95 features used.
                2003std
                     Accepts the language that the ISO Fortran 2003 standard specifies and reports anything else using language-level messages.
                2003pure
                     The same as 2003std except that it also reports language-level messages for any obsolescent Fortran 2003 features used.

         -qmbcs | -qnombcs
                Specifies that string literals and comments can contain multi-byte characters.

                Default: -qnombcs

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

                Default: -qnonullterm

         -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 is the short form of the -qonetrip
                option.

         -qonetrip | -qnoonetrip
                The long form of the -1 option.

                Default: -qnoonetrip

         -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 setting depends on the I/O specifiers in the OPEN statement and on the compiler invocation command.

                Default:
                     o -qposition=appendold for the xlf, xlf_r, f77 and fort77 invocation commands.
                     o The defined Fortran 90 and Fortran 95 behaviors for the xlf90, xlf90_r, f90, xlf95, xlf95_r, f95, xlf2003, xlf2003_r, f2003, xlf2008, xlf2008_r and f2008
                     invocation 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.

                Default: -qnoqcount

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

                Default: -qnosaa

         -qsave[={all|defaultinit}] | -qnosave
                Specifies the default storage class for local variables.

                all
                     The default storage class for all local variables is STATIC. Specifying this suboption is the same as specifying the -qsave option without any suboptions.
                defaultinit
                     The default storage class is STATIC for local variables of derived type that have default initialization specified.

                Default:
                     o -qsave for the xlf, xlf_r, f77 and fort77 invocation commands
                     o -qnosave otherwise. -qnosave sets the default storage class to AUTOMATIC.

         -qsclk={centi|micro}

                Default: -qnoundef

         -qxlf77=<settings>
                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.
                Suboptions include:

                blankpad | noblankpad
                     Pads an internal or direct-access file if the format requires more characters than the record contains.
                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, 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.

                Default:
                     blankpad, nogedit77, nointarg, nointxor, leadzero, nooldboz, nopersistent and nosofteof.

         -qxlf90=<suboption>
                Determines whether the compiler provides the Fortran 90 or the Fortran 95 level of support for certain aspects of the language. <suboption> can be one of the following
                suboptions:

                signedzero | nosignedzero
                     Determines how the SIGN(A,B) function handles signed real 0.0. In addition, determines whether negative internal values will be prefixed with a minus when
                     formatted output would produce a negative sign zero.
                autodealloc | noautodealloc
                     Determines whether the compiler deallocates allocatable arrays that are declared locally without either the SAVE or the STATIC attribute and have a status of
                     currently allocated when the subprogram terminates.
                oldpad | nooldpad
                     When the PAD=specifier is present in the INQUIRE statement, specifying -qxlf90=nooldpad returns UNDEFINED when there is no connection, or when the connection is
                     for unformatted I/O. This behavior conforms to the Fortran 95 standard and above. Specifying -qxlf90=oldpad preserves the Fortran 90 behavior.

                Default:
                     o nosignedzero, noautodealloc and oldpad for the xlf, xlf_r, f77, fort77, xlf90, xlf90_r and f90 invocation commands
                     o signedzero, autodealloc and nooldpad for the xlf95, xlf95_r, f95, xlf2003, xlf2003_r, f2003, xlf2008, xlf2008_r and f2008 invocation commands

         -qxlf2003=<suboptions_list>
                Provides the ability to use language features introduced in the Fortran 2003 standard.
                <suboptions_list> is a colon-separated list of one or more of the following suboptions:

                autorealloc | noautorealloc
                     Controls whether the compiler automatically reallocates the left-hand-side (LHS) with the shape of the right-hand-side RHS when assigning into an allocatable
                     When polymorphic is in effect, the compiler allows polymorphic entities in Fortran source files and runtime type information is generated for each derived type
                     definition.
                     When nopolymorphic is in effect, polymorphic entities cannot be specified in the Fortran source files and no runtime type information is generated.
                signdzerointr | nosigndzerointr
                     When signdzerointr is in effect, the passing of signed zeros to the SQRT, LOG, and ATAN2 intrinsic functions returns results consistent with the Fortran 2003
                     standard. The -qxlf90=signedzero option must be in effect, as well. For the xlf90, xlf77 and xlf invocations, specify both options to have the Fortran 2003
                     behavior.
                stopexcept | nostopexcept
                     When stopexcept is in effect, STOP statements will display informational messages about signaling IEEE floating-point exceptions.
                     When nostopexcept is in effect, informational messages are suppressed.
                volatile | novolatile
                     When volatile is in effect, a nonvolatile entity that is use- or host-associated can be specified as VOLATILE in inner or local scope.

                Default:
                     o autorealloc, bozlitargs, nodynamicacval, nooldnaninf, polymorphic, signdzerointr, stopexcept and volatile for the f2003, xlf2003, xlf2003_r, xlf2008, xlf2008_r
                     or f2008 invocation commands
                     o noautorealloc, nobozlitargs, nodynamicacval, oldnaninf, nopolymorphic, nosigndzerointr, nostopexcept and novolatile for all other invocation commands

         -qxlf2008=<suboption>
                Provides the ability to use language features specific to the Fortran 2008 standard when compiling with compiler invocations that conform with earlier Fortran
                standards, as well as the ability to disable these features when compiling with compiler invocations that conform with the Fortran 2008 standard. The suboptions are:

                checkpresence | nocheckpresence
                     When checkpresence is in effect, presence of optional dummy argument is checked according to the Fortran 2008 standard. When nocheckpresence is in effect, dummy
                     argument presence is checked according to previous Fortran standards.

                Default:
                     o checkpresence for the f2008, xlf2008 or xlf2008_r invocation commands
                     o nocheckpresence for all the other invocation commands

  Floating-point and integer control options
         -qautodbl=<suboption>
                Provides an automatic means of converting single-precision floating-point calculations to double-precision and of converting double-precision calculations to extended-
                precision. The suboptions are:

                none
                     Does not promote or pad any objects that share storage.
                dbl4
                     Promotes floating-point objects that are single-precision (4 bytes in size) to double-precision.
                     This suboption requires the libxlfpmt4.a library during linking.
                dbl8
                     Promotes floating-point objects that are double-precision (8 bytes in size) to extended-precision.
                     This suboption requires the libxlfpmt8.a library during linking.
                dbl
                     Combines the promotions that dbl4 and dbl8 perform.
                     This suboption requires the libxlfpmt4.a and libxlfpmt8.a libraries during linking.

                Default: -qautodbl=none

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

                Default: -qenum=4

         -qfloat=<suboptions_list>
                Specifies various floating-point suboptions. This provides 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:

                fold | nofold
                     Specifies that constant floating-point expressions are to be evaluated at compile time rather than at run time.
                     Default: fold
                hscmplx | nohscmplx
                     Speeds up operations involving complex division and complex absolute value. This suboption, which provides a subset of the optimizations of the hsflt suboption,
                     is preferred for complex calculations.
                     Default: nohscmplx
                gcclongdouble | nogcclongdouble
                     Specifies whether the compiler should use GCC-supplied or IBM-supplied library functions for 128-bit REAL(16) and COMPLEX(32) operations. gcclongdouble ensures
                     binary compatibility with GCC for mathematical calculations but nogcclongdouble produces better performance.
                     Default: nogcclongdouble
                hsflt | nohsflt
                     The hsflt option speeds up calculations by truncating instead of rounding computed values to single precision before storing and on conversions from floating-
                     point to integer. The nohsflt suboption specifies that single-precision expressions are rounded after expression evaluation and that floating-point-to-integer
                     conversions are to be checked for out-of-range values.
                     Default: nohsflt
                maf | nomaf
                     Makes floating-point calculations faster and more accurate by using floating-point multiply-add instructions where appropriate.
                     Default: maf
                nans | nonans
                     Generates extra instructions to detect signaling NaN when converting from single-precision to double-precision at run time. The option nonans specifies that this
                     conversion need not be detected.
                     Default: nonans
                rngchk | norngchk
                     Specifying norngchk instructs the compiler to skip range checking, allowing for increased performance where division and sqrt operations are performed repeatedly
                     within a loop.
                     When rngchk is specified, range checking is performed for input arguments for software divide and inlined sqrt operations.
                     When -qstrict, -qstrict=infinities, -qstrict=operationprecision, or -qstrict=exceptions is active, the setting of this option is forced to -qfloat=rngchk. When
                     -qnostrict is active, the setting of this option is -qfloat=norngchk unless the -qfloat=rngchk option is explicitly set by the user.
                     Default: rngchk
                rrm | norrm
                     Prevents floating-point optimizations that require the rounding mode to be the default, round-to-nearest, at run time, by informing the compiler that the
                     floating-point rounding mode may change or is not round-to-nearest at run time. You should use rrm if your program changes the runtime rounding mode by any means;
                     otherwise, the program may compute incorrect results.
                     Default: norrm
                rsqrt | norsqrt
                     Specifies whether a sequence of code that involves division by the result of a square root can be replaced by calculating the reciprocal of the square root and
                     multiplying. Allowing this replacement produces code that runs faster. -qfloat=rsqrt has no effect unless -qignerrno is also specified.
                     Default:
                       o norsqrt at -O2 optimization
                       o rsqrt when  -qnostrict or -O3 or higher optimization level is in effect
                strictnmaf | nostrictnmaf
                     Ensures that the compiler does not perform optimizations that introduce multiply-add operations that do not preserve the sign of a zero value.
                     Default: nostrictnmaf
                subnormals | nosubnormals
                Zero
                     Round towards zero

                Default: -qieee=near

         -qintlog | -qnointlog
                Allows mixing of INTEGER and LOGICAL values in expressions and statements.

                Default: -qnointlog

         -qintsize={2|4|8)
                Sets the size of default INTEGER and LOGICAL values.

                Default: -qintsize=4

         -qrealsize=(4|8}
                Sets the default size in bytes of REAL, DOUBLE PRECISION, COMPLEX and DOUBLE COMPLEX values.

                Default: -qrealsize=4

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

                Default: -qstrictieeemod

         -y <rounding_mode>
                Equivalent to the -qieee option.
                Specifies the compile-time rounding mode of constant floating-point expressions, where <rounding_mode> is one of the following options:

                m = round towards minus infinity
                n = round to the nearest representable number, ties to even
                p = round towards plus infinity
                z = round towards zero

                Default: -yn

  Object code control options
         -qinlglue | -qnoinlglue
                This option inlines glue code that optimizes external function calls when compiling at -O2 and higher.

                Note:
                This option is ignored as glue code is always generated.

                Default: -qinlglue

         -qpic | -qnopic
                Generates position-independent code (pic) suitable for use in shared libraries.

                You must specify -qpic when you build shared libraries.

                Default: -qnopic

                     A traceback table is generated with no name or parameter information. This is the default with optimization if -g is not specified.
                full
                     A full traceback table is generated. This is the default with -qnoopt or -g specified.

                Default:
                     o -qtbtable=full when compiling non-optimized (without -O) or for debugging (with -g)
                     o -qtbtable=small otherwise

         -qthreaded
                Ensures that all optimizations will be thread-safe for executing in a multi-threaded environment.

                Default:
                     -qthreaded for the xlf90_r, xlf95_r, xlf_r and xlf2003_r, xlf2008_r commands.

  Error checking and debugging options
         -#     Traces the compilation and generates information on the progress of the compilation without invoking the preprocessor, compiler, or linkage editor.

         -C     Generates code that performs certain types of runtime checking.

         -qcheck[=<suboptions_list>] | -qnocheck
                Generates code that performs certain types of runtime checking.

                The long form of the -C option.

                <suboptions_list> is a colon-separated list of one or more of the following suboptions:

                all
                     Enables all suboptions.
                bounds | nobounds
                     Checks each reference to an array element, array section, or character substring to ensure the reference stays within the defined bounds of the entity.
                stackclobber | nostackclobber
                     Detects stack corruption of nonvolatile registers in the save area in user programs. This type of corruption happens only if any of the nonvolatile registers in
                     the save area of the stack is modified.
                     If the -qstackprotect option and this suboption are both on, this suboption catches the stack corruption first.
                unset | nounset
                     Checks for automatic variables that are used before they are set at run time.

                Specifying -qcheck with no suboption is equivalent to specifying -qcheck=all.

                Default: -qnocheck

         -qdbg[=<level>] | -qnodbg
                The long form of the -g option.

                -qdbg=level=0
                     Equivalent to -qnodbg or -g0.
                -qdbg=level=1
                     Equivalent to -g1.
                -qdbg=level=2
                     Equivalent to -g2.
                -qdbg=level=3
                     Equivalent to -g3.

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

                Default: -qnofullpath

         -g     Generates debugging information for use by a symbolic debugger, and makes the program state available to the debugging session at selected source locations.

                When the -O2 optimization level is in effect, the debug capability is completely supported. When an optimization level higher than -O2 is in effect, the debug
                capability is limited.

                -g has the following levels:

                -g0
                     Generates no debugging information. No program state is preserved.
                -g1
                     Generates minimal read-only debugging information about line numbers and source file names. No program state is preserved.
                -g2
                     Generates read-only debugging information about line numbers, source file names, and variables. When the -O2 optimization level is in effect, no program state is
                     preserved.
                -g3, -g4
                     Generates read-only debugging information about line numbers, source file names, and variables. When the -O2 optimization level is in effect, no program state is
                     preserved, and procedure parameter values are available to the debugger at the beginning of each procedure.
                -g5, -g6, -g7
                     Generates read-only debugging information about line numbers, source file names, and variables. When the -O2 optimization level is in effect, program state is
                     available to the debugger at IF constructs, loop constructs, procedure definitions, and procedure calls, and procedure parameter values are available to the
                     debugger at the beginning of each procedure.
                -g8
                     Generates read-only debugging information about line numbers, source file names, and variables. When the -O2 optimization level is in effect, program state is
                     available to the debugger at the beginning of every executable statement, and procedure parameter values are available to the debugger at the beginning of each
                     procedure.
                -g9
                     Generates debugging information about line numbers, source file names, and variables. You can modify the value of the variables in the debugger. When the -O2
                     optimization level is in effect, program state is available to the debugger at the beginning of every executable statement, and procedure parameter values are
                     available to the debugger at the beginning of each procedure.

                Default:
                o -g0 , equivalent to -qnodbg
                o When no optimization is enabled (-qnoopt), -g is equivalent to -g9 or -qdbg=level=9.
                o When the -O2 optimization level is in effect, -g is equivalent to -g2 or -qdbg=level=2.

         -qhalt=<sev>
                Stops the compiler after the first phase if the severity level of errors detected equals or exceeds the specified level, <sev>. The severity levels in increasing order
                of severity are:

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

         -qinfo[=<suboption>] | -qnoinfo
                Produces or suppresses additional informational messages.
                The suboptions are:

                all
                     Enables diagnostic messages for all groups except mt.
                noall
                     Disables all diagnostic messages for all groups.
                mt|nomt
                     Reports potential synchronization issues in parallel code.
                     To use the -qinfo=mt suboption, you must enable the -qthreaded option and specify at least one of the following options:
                     o -O3
                     o -O4
                     o -O5
                     o -qipa
                     o -qhot
                     o -qsmp
                     The default option is -qinfo=nomt.
                HOSTASSOCiation | NOHOSTASSOCiation
                     Issues an information message for an entity that is accessed by host association for the first time. However, if the entity is accessed by an IMPORT statement, no
                     information message is issued.  You can use -qinfo=all / noall to control whether to enable the -qinfo=HOSTASSOCiation option. -qinfo=NOHOSTASSOCiation is the
                     default option.
                stp | nostp
                     Issues warnings for procedures that are not protected against stack corruption. -qinfo=stp has no effects unless the -qstackprotect option is also enabled. Like
                     other -qinfo options, -qinfo=stp is enabled or disabled through -qinfo=all / noall.  -qinfo=nostp is the default option.
                unset | nounset
                     Detects automatic variables that are used before they are set, and flags them with informational messages at compile time.

                Default: -qnoinfo
                Specifying -qinfo with no suboptions is equivalent to -qinfo=all.

         -qinit=f90ptr
                Makes the initial association status of pointers disassociated instead of undefined.
                This option applies to Fortran 90 and above.

                Default:
                     The default association status of pointers is undefined.

         -qinitalloc[=<hex_value>] | -qnoinitalloc
                Initializes allocatable and pointer variables that are allocated but not initialized to a specific value, for debugging purposes. This option can slow down the
                execution of your program and should only be used for error determination.  If you specify -qinitalloc without a <hex_value>, the compiler initializes the value of
                each byte of allocated storage to zero.

                Default: -qnoinitalloc

         -qinitauto[=<hex_value>] | -qnoinitauto
                Specifies a hexadecimal value <hex_value> of 1 to 8 digits to initialize automatic variables.  This generates extra code and should only be used for error
                determination.  If you specify -qinitauto without a <hex_value>, the compiler initializes the value of each byte of automatic storage to zero.

                Default: -qnoinitauto

         -qkeepparm | -qnokeepparm
                i = informational messages
                l = language-level messages
                w = warning messages
                e = error messages
                s = severe error messages

                Default: -qnomaxerr

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

                Default: -qobject

         -qsigtrap[=<trap_handler>]
                Sets up the specified trap handler to catch SIGTRAP exceptions when compiling a file that contains a main program.
                This option enables you to install a handler for SIGTRAP signals without calling the SIGNAL subprogram in the program.

         -qwarn64 | -qnowarn64
                Enables checking for possible data conversion problems between 32-bit and 64-bit compiler modes.

                Default: -qnowarn64

         -qxflag=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.
                By default, no code is generated to detect floating-point divide-by-zero operations.

  Listing and messages options
         -qattr[=full] | -qnoattr
                Produces a compiler listing that includes an attribute listing for all identifiers. If -qattr is specified, the listing contains only those identifiers that are used.
                If -qattr=full is specified, the listing contains all names. If -qnoattr is specified, no listing is produced.

                Default: -qnoattr

         -qflag=<listing_severity>:<terminal_severity>
                Defines the minimum severity level of diagnostic messages to be written to the listing file and to the user terminal. <listing_severity> is the minimum level for the
                listing file, and <terminal_severity> is the minimum level for the terminal. The message 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, even if the compiler encounters
                    unrecoverable errors

                Default: -qflag=i:i

         -qhelp
                Displays the man page of the compiler.

                     Indicates that the report should be generated in XML format.
                html
                     Indicates that the report should be generated in HTML format.  If an XML report has been generated before, you can convert the report to the HTML format using the
                     genhtml command.

                <suboptions_list> is a colon-separated list of the following options:

                contentSelectionList
                     Provides a filter to limit the type and quantity of information in the report.  <contentSelectionList> is a colon-separated list of any of the following
                     suboptions:

                               data | nodata
                                    Produces information about data reorganizations.
                               inlines | noinlines
                                    Produces inlining information.
                               pdf | nopdf
                                    Produce profile-directed feedback information.
                               transforms | notransforms
                                    Produces information about loop transformations.
                               all
                                    Produces all available report information.
                               none
                                    Does not produce a report.

                filename
                     Specifies the name of the report file. One file is produced during the compile phase, and one file is produced during the IPA link phase.  If no filename is
                     specified, a file with the suffix .xml is generated in a way that is consistent with the rules of name generation for the given platform.
                stylesheet
                     Specifies the name of an existing XML stylesheet for which an xml-stylesheet directive is embedded in the resulting report. The default behavior is to not include
                     a stylesheet. The stylesheet supplied with XL Fortran is xlstyle.xsl. This stylesheet renders the XML to an easily read format when viewed using a browser that
                     supports XSLT.
                version
                     Specifies the major version of the content that will be generated. If you have written a tool that requires a certain version of this report, you must specify the
                     version.

                When used with an option that enables inlining such as -qinline, the report shows which functions were inlined and why others were not inlined.

                To generate a loop transformation listing, you must also specify one of the following options on the command line:
                o -qhot
                o -qsmp
                o -O3 or higher

                To generate a parallel transformation listing or parallel performance messages, you must also specify one of the following options on the command line:
                o -qsmp
                o -O5
                o -qipa=level=2

                When used with the option that enables profiling, -qpdf, the report contains information about call and block counts and cache misses.

                When used with an option that produces data reorganizations such as -qipa=level=2, the report contains information about those reorganizations.

                Default: This option is off by default. If none of the contentSelectionList suboptions is specified, all available report information is produced. For example,
                Prevents the compiler from creating the listing file, regardless of the settings of other listing options.

         -qreport[={smplist|hotlist}] | -qnoreport
                Produces listing files that show how sections of code have been optimized. A listing file is generated with a .lst suffix for each source file named on the command
                line. When you specify -qreport with an option that enables automatic parallelization or vectorization, the listing file shows a pseudo-Fortran code listing and a
                summary of how program loops are parallelized or optimized. The report also includes diagnostic information to show why specific loops cannot be parallelized or
                vectorized.
                For -qreport to generate a loop transformation listing, you must also specify the following option on the command line:
                o -qhot
                o -qsmp
                o -O3 or higher
                For -qreport to generate PDF information in the listing, you must specify the following option in the command line:
                o -qpdf2 -qreport
                For -qreport to generate a parallel transformation listing or parallel performance messages, you must also specify one of the following options on the command line:
                o -qsmp
                o -O5
                o -qipa=level=2

                Suboptions are:

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

                Specifying -qreport with no suboptions is equivalent to -qreport=hotlist.

                Default: -qnoreport

         -qsource | -qnosource
                Produces a compiler listing that includes source code.

                Default: -qnosource

         -qstackprotect[={all | size=N}] | -qnostackproteck
                Provides protection against malicious code or programming errors that overwrite or corrupt the stack. The suboptions are:

                all
                     Protects all procedures whether or not procedures have vulnerable objects.  This option is not set by default.
                size=N
                     Protects all procedures containing automatic objects greater or equal to N bytes in size. The default size is 8 when -qstackprotect is enabled.

                Note:

                Default: -qnostackprotect

         -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.
                     comp_name Version: VV.RR(product_name) Level: comp_level
                     where:
                     comp_name specifies an installed component, such as the low-level optimizer.
                     comp_level represents the level of the installed component.

                Default: -qnoversion

         -w     Suppresses informational, language-level and warning messages.
                Specifying this option is equivalent to specifying -qflag=e:e.

         -qxref[=full] | -qnoxref
                Specifies whether to produce a compiler listing that includes a cross-reference listing of all identifiers.
                Specifying -qxref will report only identifiers that are used, -qxref=full reports all identifiers in the program, and -qnoxref does not report any identifiers in the
                program. The -qnoprint option overrides this option.

                Default: -qnoxref

  Optimization and tuning options
         -qalias=<suboptions_list>
                Indicates whether a program contains certain categories of aliasing to determine whether certain optimizations are performed. <suboptions_list> is a colon-separated
                list 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.
                     Default: aryovrlp
                intptr | nointptr
                     Indicates whether the compilation units contain any integer POINTER statements. If so, specify intptr.
                     Default: nointptr
                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.
                     Default: pteovrlp
                std | nostd
                     Indicates whether the compilation units contain any nonstandard aliasing (which is explained below). If so, specify nostd.
                     Default: std

                Default:
                     o -qalias=aryovrlp:nointptr:pteovrlp:std for the xlf90, xlf90_r, f90, xlf95, xlf95_r, f95, xlf2003, xlf2003_r and f2003 invocation commands.
                     o -qalias=aryovrlp:intptr:pteovrlp:std for the xlf, xlf_r, f77 and fort77 invocation commands.

         -qarch[=<suboption>]
                Specifies the processor architecture, or family of architectures, where the code may run. This allows the compiler to take maximum advantage of the machine
                instructions specific to an architecture, or common to a family of architectures.  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.  This option is implied if the -O4 or -O5 option is set or implied.
                pwr8
                     Produces object code containing instructions that run on the POWER8 hardware platforms.

                Default:
                     o -qarch=pwr8
                     When -qassert=contiguous is enabled, the compiler assumes that:
                     o For all compilation units in the program, all array pointers are pointer associated with contiguous targets.
                     o All assumed shape arrays are argument associated with contiguous actual arguments.
                     When -qassert=contig is specified, the compiler can perform optimizations according to the memory layout of the objects occupying contiguous blocks of memory.
                     Default:  NOCONTIGuous
                     Note:
                     o The contiguous suboption is not supported through the IBM ASSERT directive.
                     o For Fortran 2008, to ensure proper results, use the CONTIGUOUS attribute, which undergoes syntax and semantic checking.
                REFalign | NOREFalign
                     Specifies that all pointers inside the compilation unit only point to data that is naturally aligned according to the length of the pointer types.

                Default:  -qassert=deps:norefalign:nocontig

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

                assoc=<number>
                     Specifies the set associativity of the cache, where <number> is one of the following values:
                          0         Direct-mapped cache
                          1         Fully associative cache
                          (n > 1)   n-way set associative cache
                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, in CPU cycles, resulting from a cache miss.
                level=<level>
                     Specifies which level of cache is affected, where level is one of the following levels:
                          1     Basic cache
                          2     Level-2 cache
                          3     Table Lookaside Buffer (TLB)
                     If a machine has more than one level of cache, use a separate -qcache option.
                line=<bytes>
                     Specifies the line size of the cache.
                size=<Kbytes>
                     Specifies the total size of the cache.
                type=<cache_type>
                     The settings apply to the specified type of cache, where <cache_type> is one of the following values:
                          c = Combined data and instruction cache
                          d = Data cache
                          i = Instruction cache

                Default:
                     The -qtune setting determines the optimal default -qcache settings for most typical compilations. -O4, -O5, or -qipa must be specified with the -qcache option.

         -qessl | -qnoessl
                Specifies that, if either -lessl or -lesslsmp are also specified, then Engineering and Scientific Subroutine Library (ESSL) routines should be used in place of some
                Fortran 90 intrinsic procedures when there is a safe opportunity to do so.

                Default: -qnoessl

                     2
                          The compiler performs the default set of high-order transformations and some more aggressive loop transformations. -qhot=level=2 must be used with -qsmp.
                vector | novector
                     When specified with -qnostrict, or an optimization level of -O3 or higher (otherwise -qhot=vector has no effect), the compiler converts certain operations in a
                     loop that apply to successive elements of an array into a call to a routine in the Mathematical Acceleration Subsystem (MASS) library, part of the libxlopt.a
                     library.
                     If you specify -qhot=novector, the compiler performs optimizations on loops and arrays, but avoids replacing certain code with calls to vector library routines.
                fastmath | nofastmath
                     Tunes your application to either use fast scalar versions of math functions or use the default versions.
                     -qhot=fastmath enables the replacement of math routines with available math routines from the XLOPT library only if -qstrict=nolibrary is enabled. -qhot=fastmath
                     is enabled by default if -qhot is specified regardless of the hot level.

                Default:
                     o -qnohot
                     o -qhot=noarraypad:level=0:novector:fastmath
                     when -O3 is in effect.
                     o -qhot=noarraypad:level=1:vector:fastmath when -qsmp,
                     -O4 or -O5 is in effect.

         -qipa[=<suboptions_list>] | -qnoipa
                Turns on or customizes a class of optimizations known as interprocedural analysis (IPA). <suboptions_list> is a colon-separated list of the following suboptions:

                exits=<procedure_names>
                     Specifies names of procedures which represent program exits.  <procedure_names> is a comma-separated list of procedure names.
                isolated=<procedures>
                     Specifies a comma-separated list of 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 performed, where <level> can be equal to:
                     0
                          Performs only minimal interprocedural analysis and optimization.
                     1
                          Turns on inlining, limited alias analysis, and limited call-site tailoring.
                     2
                          Full interprocedural data flow and alias analysis.
                          To generate data reorganization information, specify the optimization level -qipa=level=2 or -O5 together with -qreport.
                     Default: 1
                list[={<file_name>|short|long}]
                     Specifies an output listing file name during the link phase. The default name is "a.lst". Specifying 'long' or 'short' can be used to request more or less
                     information in the listing file to determine which listing sections will be included.
                     Default: short
                lowfreq=<procedures>
                     Specifies a comma-separated list of procedures that are likely to be called infrequently during the course of a typical program run.
                missing={unknown|safe|isolated|pure}
                     Specifies the default assumption for procedures not compiled with -qipa.
                     unknown
                          Greatly restricts the amount of interprocedural optimization for calls to unknown procedures.
                     safe
                          Procedures which do not indirectly call a visible (not missing) procedure either through direct call or procedure pointer.
                     isolated
                          Procedures which do not directly reference global variables accessible to visible procedures.
                     pure
                          Procedures which are safe and isolated and which do not indirectly alter storage accessible to procedures.

                Default: nostdexits
           threads[=<suboption>] | nothreads
                Runs portions of the IPA optimization process during pass 2 in parallel threads, which can speed up the linking process on multi-processor systems. <suboption> can be
                one of the following suboptions:
                auto | noauto
                     When auto is in effect, the compiler selects a number of threads heuristically based on machine load. When noauto is in effect, the compiler creates one thread
                     per machine processor.
                <number>
                     Instructs the compiler to use a specific number of threads. <number> can be any integer value in the range of 1 to 32767. However, <number> is effectively limited
                     to the number of processors available on your system.
                Specifying threads with no suboptions implies threads=auto.
                Default: -qipa=threads
           unknown=<procedures>
                Specifies a comma-separated list of procedures that are not compiled with -qipa and that may update global variables and dummy arguments and call other parts of the
                program compiled with -qipa.
           <file_name>
                Specifies the name of a file that contains suboption information in a special format.

           Regular expressions are supported when specifying procedure names for these suboptions:
           exits, isolated, lowfreq, pure, safe, unknown.

           Default:
                o -qnoipa
                o -qipa=level=1:missing=unknown:
                partition=medium:threads=auto when -O4 is in
                effect.
                o -qipa=level=2:missing=unknown:
                partition=medium:threads=auto when -O5 is in
                effect.
                o -qipa=level=0:missing=unknown:
                partition=medium:threads=auto when -qpdf1 or
                -qpdf2 is in effect.

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

                Default: -qnolibansi

         -O[<level>]
                Optimizes code at a choice of levels during compilation. This is equivalent to -qoptimize[=<level>]. <level> can be:

                0
                     Performs only quick local optimizations such as constant folding and elimination of local common subexpressions.
                2
                     Performs optimizations that the compiler developers considered the best combination for compilation speed and runtime performance. The optimizations may change
                     from product release to release.
                3
                     Performs some memory and compile-time intensive optimizations in addition to those executed with -O2. The -O3 specific optimizations have the potential to alter
                     the semantics of a program. The compiler guards against these optimizations at -O2 and the option -qstrict is provided at -O3 to turn off these aggressive
                     optimizations.
                     Specifying -O3 implies -qhot=level=0.
                4

                Default: -qnooptimize

         -p[g]  Sets up the object files produced by the compiler for profiling.
                -pg is like -p, but it produces more extensive statistics.

         -qpdf1[=<suboption_list>] | -qnopdf1
                Tunes optimizations through profile-directed feedback (PDF), where results from sample program execution are used to improve optimization near conditional branches and
                in frequently executed code sections. Optimizes an application for a typical usage scenario based on an analysis of how often branches are taken and blocks of code are
                run.
                <suboptions_list> is a colon-separated list of the following suboptions:

                pdfname=<file_path>
                     Specifies the directories and names for PDF files and any existing PDF map files. By default, if the PDFDIR environment variable is set, the compiler places the
                     PDF and PDF map files in the directory specified by PDFDIR. Otherwise, if the PDFDIR environment variable is not set, the compiler places these files in the
                     current working directory. If the PDFDIR environment variable is set but the specified directory does not exist, the compiler issues a warning message. The name
                     of the PDF map file follows the name of the PDF file.
                unique | nounique
                     Specifies whether a unique PDF file is created for each process during run time. You can use the -qpdf1=unique option to avoid locking a single PDF file when
                     multiple processes are writing to the same PDF file in the PDF training step. The default option is -qpdf1=nounique.
                level = 0 | 1 | 2
                     Supports cache miss, block counter, call counter, and extended value profiling. You can compile your application with -qpdf1=level=0|1|2 to generate profiling
                     data with different levels of optimization. 1 is the default compiler instrumentation, which is equivalent to -qpdf1. Higher PDF levels profile more optimization
                     opportunities but have a larger overhead.
                exename
                     Generates the name of the PDF file based on what you specify with the -o option. You can use this suboption with -qpdf1.
                defname
                     Reverts the PDF file to its default file name if -qpdf1=exename is also specified. You can use this suboption with -qpdf1.

              Default: -qnopdf1

         -qpdf2[=<suboption_list>] | -qnopdf2
                Tunes optimizations through profile-directed feedback (PDF), where results from sample program execution are used to improve optimization near conditional branches and
                in frequently executed code sections. Optimizes an application for a typical usage scenario based on an analysis of how often branches are taken and blocks of code are
                run.

                pdfname=<file_path>
                     Specifies the directories and names for PDF files and any existing PDF map files. By default, if the PDFDIR environment variable is set, the compiler places the
                     PDF and PDF map files in the directory specified by PDFDIR. Otherwise, if the PDFDIR environment variable is not set, the compiler places these files in the
                     current working directory. If the PDFDIR environment variable is set but the specified directory does not exist, the compiler issues a warning message. The name
                     of the PDF map file follows the name of the PDF file.
                exename
                     Generates the name of the PDF file based on what you specify with the -o option. You can use this suboption with -qpdf2.
                defname
                     Reverts the PDF file to its default file name if the -qpdf1=exename is also specified. You can use this suboption with -qpdf2.

                Default: -qnopdf2

         -qprefetch[=<suboption_list>] | -qnoprefetch
                Inserts prefetch instructions automatically where there are opportunities to improve code performance.
                <suboptions_list> is a colon-separated list of the following suboptions:

                     high-order transformation (HOT) is in effect. The default value of dscr is 0. The value that you specify for dscr must be 0 or greater, and representable as a
                     64-bit unsigned integer. The value can be either decimal or hexadecimal.

                Default:
                o -qprefetch=noassistthread:noaggressive:dscr=0

         -qinline [<=suboption>] | -qnoinline
                Attempts to inline procedures instead of generating calls to those procedures, for improved performance.

                You must specify a minimum optimization level of -O2 along with -qinline to enable inlining of procedures.

                auto | noauto
                     Enables or disables automatic inlining. When option -qinline=auto is in effect, all functions are considered for inlining by the compiler.  When option
                     -qinline=noauto is in effect, the compiler only inlines small functions that it deems appropriate for inlining.
                level=number
                     Indicates the relative degree of inlining. The values for number must be integers from 0 to 10 inclusive. The default value for number is 5. The greater the value
                     of number, the more aggressive inlining the compiler conducts.
                -qinline+<procedure_name>
                     Inlines the procedures listed in <procedure_name>.
                -qinline-<procedure_name>
                     Specifies that procedures listed in <procedure_name> do not get inlined.

                Default:
                     o If -qinline is not specified, the default option is -qnoinline at the -O0 or -qnoopt optimization level, or -qinline=noauto:level=5 at the -O2 or higher
                     optimization levels.
                     o If -qinline is specified without any suboptions, the default option is -qinline=auto:level=5.

         -qshowpdf | -qnoshowpdf
                Used with -qpdf1 and a minimum optimization level of -O2 to create a PDF map file containing additional profiling information to be consumed by the showpdf tool.

                Default: -qshowpdf

         -qsimd[=<suboption>]
                Controls whether the compiler can automatically take advantage of vector instructions for processors that support them. -qsimd can take the following suboption:

                auto | noauto
                     Enables or disables the automatic generation of vector instructions for processors that support them.

                Default: Whether -qsimd is specified or not, -qsimd=auto is implied at the -O3 or higher optimization level; -qsimd=noauto is implied at the -O2 or lower optimization
                level.

         -qsmallstack[=<suboption>] | -qnosmallstack
                Minimizes 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.
                     Enables strict OpenMP compliance. Only OpenMP parallelization directives are recognized.
                     Default: noomp
                opt | noopt
                     Enables automatic parallelization but disables optimization of parallelized program code. If noopt is specified, optimization of parallelized program code is
                     disabled.
                     Default: opt
                ostls | noostls
                     Enables thread-local storage (TLS) provided by the operating system to be used for threadprivate data. The noostls suboption is to enable non-TLS for
                     threadprivate.
                     Default: ostls
                rec_locks | norec_locks
                     Specifies whether to use recursive locks.
                     Default: norec_locks
                schedule=<type>
                     Specifies what kinds of scheduling algorithms and chunking are used for loops to which no other scheduling algorithm has been explicitly assigned in the source
                     code. <type> can be:
                       o affinity[=<num>]
                       o auto
                       o dynamic[=<num>]
                       o guided[=<num>]
                       o runtime
                       o static[=<num>],
                     where <num> is the number of loop iterations.
                     Note: The affinity scheduling type is deprecated.  Consider using the guided scheduling type.
                     Default: schedule=auto
           stackcheck | nostackcheck
                Causes the compiler to check for stack overflow by worker threads at run time, and issue a warning if the remaining stack size is less than the number of bytes
                specified by the stackcheck option of the XLSMPOPTS environment variable. This suboption is intended for debugging purposes, and only takes effect when
                XLSMPOPTS=stackcheck is also set.
                Default: nostackcheck
           threshold[=<num>]
                When -qsmp=auto is in effect, controls the amount of automatic loop parallelization that occurs. The value of <num> represents the lower limit allowed for
                parallelization of a loop, based on the level of "work" present in a loop.
                Default:
                  <num> must be a positive integer of 0 or greater. If you specify threshold with no suboption, the program uses a default value of 100.

           Specifying -qsmp without suboptions is equivalent to -qsmp=auto:explicit:opt:noomp:norec_locks:
           nonested_par:schedule=auto:nostackcheck:threshold=100:ostls

           Default: -qnosmp

         -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.
                     o -qnostrict or -qstrict=none is the default when -O3 or a higher optimization level is in effect

                <suboptions_list> is a colon-separated list of one or more of the following suboptions:

                all | none
                     all disables all semantics-changing transformations, including those controlled by the ieeefp, order, library, precision, and exceptions suboptions.  none enables
                     these transformations.
                precision | noprecision
                     precision disables all transformations that are likely to affect floating-point precision, including those controlled by the subnormals, operationprecision,
                     association, reductionorder, and library suboptions.  noprecision enables these transformations.
                exceptions | noexceptions
                     exceptions disables all transformations likely to affect exceptions or be affected by them, including those controlled by the nans, infinities, subnormals,
                     guards, and library suboptions. noexceptions enables these transformations.
                ieeefp | noieeefp
                     ieeefp disables transformations that affect IEEE floating-point compliance, including those controlled by the nans, infinities, subnormals, zerosigns, and
                     operationprecision suboptions. noieeefp enables these transformations.
                nans | nonans
                     nans disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce IEEE floating-point NaN (not-a-number)
                     values. nonans enables these transformations.
                infinities | noinfinities
                     infinities disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce floating-point infinities.
                     noinfinities enables these transformations.
                subnormals | nosubnormals
                     subnormals disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce IEEE floating-point subnormals.
                     nosubnormals enables these transformations.
                zerosigns | nozerosigns
                     zerosigns disables transformations that may affect or be affected by whether the sign of a floating-point zero is correct. nozerosigns enables these
                     transformations.
                operationprecision | nooperationprecision
                     operationprecision disables transformations that produce approximate results for individual floating-point operations. nooperationprecision enables these
                     transformations.
                vectorprecision | novectorprecision
                     vectorprecision disables vectorization in loops where it might produce different results in vectorized iterations than in nonvectorized residue iterations, to
                     ensure that every loop iteration of identical floating point operations on identical data produces identical results. novectorprecision enables vectorization even
                     when different iterations might produce different results from the same inputs.
                order | noorder
                     order disables all code reordering between multiple operations that may affect results or exceptions, including those controlled by the association,
                     reductionorder, and guards suboptions. noorder enables code reordering.
                association | noassociation
                     association disables reordering operations within an expression. noassociation enables reordering operations.
                reductionorder | noreductionorder
                     reductionorder disables parallelizing floating-point reductions. noreductionorder enables parallelizing these reductions.
                guards | noguards
                     guards disables moving operations past guards (that is, past IF statements, out of loops, or past subroutine or function calls which might end the program) which
                     control whether the operation should be executed. noguards enables moving operations past guards.
                library | nolibrary
                     library disables transformations that affect floating-point library functions. nolibrary enables these transformations.

         -qstrict_induction | -qnostrict_induction
                Turns off loop induction variable optimizations that have the potential to alter the semantics of your program.

                Default:
                <smt_option> must be one of the following options:

                balanced
                     Optimizations are tuned for performance across various SMT modes for a selected range of recent hardware.
                st
                     Optimizations are tuned for single-threaded execution.
                smt2
                     Optimizations are tuned for SMT2 execution mode (two threads).
                smt4
                     Optimizations are tuned for SMT4 execution mode (four threads).
                smt8
                     Optimizations are tuned for SMT8 execution mode (eight threads).

                Default: -qtune=balanced:balanced

         -qunroll[={auto|yes|<n>}] | -qnounroll
                Unrolls inner loops in the program. This can help improve program performance.

                auto
                     Instructs the compiler to perform basic loop unrolling.
                yes
                     Instructs the compiler to search for more opportunities for loop unrolling than that performed with auto. In general, this suboption is more likely to increase
                     compile time or program size than auto processing, but it may also improve your application's performance.
                n
                     Instructs the compiler to unroll loops by a factor of n. In other words, the body of a loop is replicated to create n copies and the number of iterations is
                     reduced by a factor of 1/n.  The value of n must be a positive integer.

                Default:
                     -qunroll=auto if -qunroll is not specified on the command line.

         -qunwind | -qnounwind
                Informs the compiler that the stack can be unwound while a routine in the compilation is active. Specifying -qnounwind can improve the optimization of nonvolatile
                register saves and restores.

                Default: -qunwind

         -qvisibility[=<suboption>]
                Specifies the visibility attributes for external linkage symbols in object files. <suboption> is one of the following options:

                default
                     Indicates that the affected external linkage symbols have the default visibility attribute.
                protected
                     Indicates that the affected external linkage symbols have the protected visibility attribute.
                hidden
                     Indicates that the affected external linkage symbols have the hidden visibility attribute.
                internal
                     Indicates that the affected external linkage symbols have the internal visibility attribute.

                Default: -qvisibility=default

         -qzerosize | -qnozerosize
                Improves performance of some programs by preventing checking for zero-sized character strings and arrays.
                Default:
                     The default is to search only the standard directories.

         -l <key>
                Searches the file lib<key>.so and then lib<key>.a for dynamic linking, or only lib<key>.a for static linking.

                Default:
                     The default is to search only some of the compiler runtime libraries.

         -qstaticlink[=libgcc|xllibs] | -qnostaticlink[=libgcc|xllibs]
                Controls whether static or shared libraries are linked into the application, where:

                -qstaticlink
                     Build a static object and prevent linking with shared libraries.
                -qstaticlink=libgcc
                     Links in libgcc statically.
                -qstaticlink=xllibs
                     Links in the XL compiler libraries statically.
                -qnostaticlink
                     Links shared libraries with the object file named in the invocation.
                -qnostaticlink=libgcc
                     Links to the shared version of libgcc.
                -qnostaticlink=xllibs
                     Links to the shared version of the XL compiler libraries.

                Default: -qnostaticlink

  Portability and migration options
         -qalign=<suboption>
                Specifies the alignment of data objects in storage to avoid performance problems with misaligned data. Suboptions include:

                4k | no4k
                     Specifies whether to align large data objects on page (4 KB) boundaries, for improved performance with data-striped I/O.
                bindc=<suboption>
                     Specifies that the alignment and padding for an XL Fortran derived type with the BIND(C) attribute is compatible with a C struct type that is compiled with the
                     corresponding XL C alignment option. The compatible alignment options are:
                       o -qalign=bindc=bit_packed
                       (The corresponding XL C option is -qalign=bit_packed.)
                       o -qalign=bindc=linuxppc
                       (The corresponding XL C option is -qalign=linuxppc.)
                struct=natural
                     Objects of a derived type declared using a STRUCTURE declaration are stored such that each component of each element is stored on its natural alignment boundary,
                     unless storage association requires otherwise.
                struct=packed
                     Objects of a derived type declared using a STRUCTURE declaration are stored with no space between components, other than any padding represented by %FILL
                     components.
                struct=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.

                Default: -qalign=no4k:struct=natural:bindc=linuxppc
                     argument, it is passed to the procedure as if it were an integer actual argument.
                noarg
                     This suboption provides the same behavior as the -qctyplss option with no suboptions.

                Default: -qnoctyplss

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

                Default: -qnoddim

         -qdescriptor[={v1|v2}]
                Specifies which descriptor format the compiler will use for non-object-oriented compiler entities. The possible choices are:

                v1
                     All object code will use the version 1 descriptor format, where possible.
                v2
                     All object code will use the version 2 descriptor format for all relevant code constructs.

                Default: -qdescriptor=v1

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

                Default: -qescape

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

         -qextname[=<names>] | -qnoextname
                Adds a trailing underscore to the names of the global entities (external names) specified by <names>, a colon-separated list of one or more names of global entities.
                If no names are specified, -qextname adds an underscore to the names of all global entities, except for main program names.

                Default: -qnoextname

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

                Default: -qnolog4

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

                clogicals | noclogicals
                     If you specify this option, the compiler treats all non-zero integers that are used in logical expressions as TRUE. You must specify -qintlog for -qport=clogicals
                     to take effect.
                     Default: noclogicals
                hexint | nohexint
                     If you specify this option, typeless constant hexadecimal strings are converted to integers when passed as actual arguments to the int intrinsic function.
                     Typeless constant hexadecimal strings not passed as actual arguments to INT remain unaffected.
                     The TYPE statement, which behaves in a manner similar to the PRINT statement, is supported whenever this option is specified.
                     Default: 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 noninteger type remain unaffected by this option.
                     Default: notyplssarg

                Default: -qnoport

         -qswapomp | -qnoswapomp
                Specifies that the compiler should reorganize and substitute OpenMP routines in XL Fortran programs.

                Default: -qswapomp

         -qufmt=<suboption>
                Sets the byte order for I/O operations on unformatted data files. <suboption> must be one of the following suboptions:

                be
                     Specifies that I/O operations on unformatted data files use big-endian byte order.
                le
                     Specifies that I/O operations on unformatted data files use little-endian byte order.

                Default: -qufmt=le

         -qxflag=oldtab
                For fixed source form programs, interprets a tab in columns 1 to 5 as a single character.

  Compiler customization options
         -B [<prefix>]
                Specifies substitute path names for compiler components, such as the assembler, linker, and preprocessor, where <prefix> can be the path of any program name recognized
                by the -t compiler option. The optional <prefix> defines part of a path name to the new programs. The -t parameter, <program>, specifies the program to which the
                <prefix> is to be appended. When specifying <prefix>, there must be a slash (/) after the directory name.

         -F [<config_file>][:<stanza>]
                Names an alternative configuration file (.cfg) for the compiler. <config_file> is the name of a compiler configuration file. <stanza> is the name of the command used
                to invoke the compiler. This directs the compiler to use the entries under <stanza> in the <config_file> to set up the compiler environment. At least one of the
                arguments must be supplied.

         -qoptfile=<filename>
                Specifies a file containing a list of additional command line options to be used for the compilation. <filename> specifies the name of the file that contains a list of
                additional command line options. It can contain a relative path or absolute path, or it can contain no path. It is a plain text file with one or more command line
                options per line.

         -NS <bytes>
                Specifies the size of internal program storage areas, in bytes.

                Default: -NS512

         -qspillsize=<bytes>
                This is the long form of the -NS option. Refer to -NS for more information.

         -t <programs_list>
                Gives the specified option(s) to the compiler program, <program>. <options_list> is a comma-separated list of one or more options. <program> can be one of the
                following programs:

                a = Assembler
                b = Low-level optimizer
                c = Compiler front end
                d = Disassembler
                F = C preprocessor
                h = Array language optimizer
                I = High-level optimizer
                l = Linker
                z = Binder



  SEE ALSO
         showpdf(1), mergepdf(1), cleanpdf(1).

         For more information, refer to the following Web sites:
         http://www.ibm.com/software/awdtools/fortran/xlfortran/linux/library/
         http://www.ibm.com/software/products/en/fortcompfami


  COPYRIGHT
         Licensed Materials - Property of IBM.

         IBM XL Fortran for Linux, V15.1.3

         5765-J10; 5725-C75

         Copyright IBM Corp. 1996, 2015.

         IBM, the IBM logo, ibm.com, Power, POWER, POWER8, PowerPC and OpenPower are trademarks or registered trademarks of International Business Machines Corp., registered in many
         jurisdictions worldwide. Other product and service names might be trademarks of IBM or other companies. A current list of IBM trademarks is available on the Web at "Copyright
         and trademark information" at www.ibm.com/legal/copytrade.shtml.

         Linux is a registered trademark of Linus Torvalds in the United States, other countries, or both.

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



  IBM                                                                                      2015                                                                                  xlf(1)

Man(1) output converted with man2html