xlc(1)                  IBM XL C/C++ for Linux, V13.1.2                 xlc(1)



  NAME
         xlc, xlc++, xlC, cc, c89, c99 and related commands - invoke the IBM XL
         C/C++ on little endian Linux distributions.


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


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

         Invocations                   Usage (supported standards)
         _________________________________________________________

         xlc, xlc_r                    Compile C source files.
                                       (ANSI C89, ISO C99,
                                       IBM language extensions)

         xlc++, xlc++_r, xlC,          Compile C++ source files.
         xlC_r

         cc, cc_r                      Compile legacy code that
                                       does not conform to Standard
                                       C. (pre-ANSI C)

         c89, c89_r                    Compile C source files with
                                       strict conformance to the
                                       C89 standard. (ANSI C89)

         c99, c99_r                    Compile C source files with
                                       strict conformance to the
                                       C99 standard. (ISO 99)


         The main difference between these commands is that they use different
         default options (which are set in the configuration file
         /opt/ibm/xlC/13.1.2/etc/xlc.cfg.${OSRelease}.gcc${gccVersion}).
         See the XL C/C++ 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 or
         shared library, unless you specify the compiler options that prevent
         object files from being linked.

         The input file may have any of the following suffixes:

          .C, .cpp, .cxx,    C++ source file
          .cc, .cp, .c++

          .c                 C source file

          .i                 Preprocessed C source file

          .ii                Preprocessed C++ source file

          .a                 Archive file

          .o                 Object file for ld command

          .s                 Assembler source file

          .S                 Assembler source file that
                             requires preprocessing

          .so                Shared object file


  OPTIONS
         Compiler options are categorized by their functions and may be used to
         set the compiler behavior. Options can be flag options or keyword
         options.

         Most of the keyword options are specified in one of the following ways:
         -f<option>[=<suboption>]
         -m<option>[=<suboption>]
         -q<option>[=<suboption>]

         Keyword options with no suboptions represent switches that may be
         either enabled or disabled.  -qx enables the option, and -qnox disables
         it.

         In addition to the options described below, IBM XL C/C++ for Linux,
         V13.1.2 supports many GCC options as it leverages the Clang
         infrastructure from the open source community for a portion of its
         compiler front end. You can find a complete list of those options in
         the XL C/C++ Compiler Reference. The online version of that page is
         available at: http://www.ibm.com/support/knowledgecenter/
         SSXVZZ_13.1.2/com.ibm.xlcpp1312.lelinux.doc/compiler_ref/clangopt.html

  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.

         -C | -C!
                Preserves or removes comments in preprocessed output.
                When -C is used with the -E option, comments are written to
                standard output; with the -P option, comments are written to an
                output file.
                When -C! is in effect, comments are removed.

         -E     Preprocesses the source files named in the compiler invocation,
                without compiling.

         -M     Generates a rule suitable for the make tool that describes the
                dependencies of the input file.

         -MD

         -qmakedep[=gcc]
                Produces the dependency files that are used by the make tool for
                each source file. The dependency output file is named with a .d
                suffix. 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 main source file’s dependencies. This
                     suboption is equivalent to -MD.

         -MF <file>
                Specifies the file to write the dependencies to. The -MF option
                must be specified with option -M or -MM.

         -MG    Assumes that missing header files are generated files and adds
                them to the dependency list without raising an error. The -MG
                option must be used with option -M, -MD, -MM, or -MMD.

         -MM    Generates a rule suitable for the make tool that describes the
                dependencies of the input file, but does not mention header
                files that are found in system header directories nor header
                files that are included from such a header.

         -MMD   Compiles the source files, generates the object file, and
                generates a rule suitable for the make tool that describes the
                dependencies of the input file in a .d file with the name of the
                input file.  However, the dependencies do not include header
                files that are found in system header directories nor header
                files that are included from such a header.

         -MP    Instructs the C preprocessor to add a phony target for each
                dependency other than the input file.

         -MQ <target>
                Changes the target of the rule emitted by dependency generation
                and quotes any characters that are special to the make tool.

         -MT <target>
                Changes the target of the rule emitted by dependency generation.

         -shared (-qmkshrobj)
                Creates a shared object from the generated object files.
                Specifying -shared implies -qpic.
                See related options,  -e <name> and -o <path>.

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

                Default: -o a.out

         -P     Preprocesses the C or C++ source files named in the compiler
                invocation and creates an output preprocessed source file for
                each input source file. The preprocessed output file has the
                same name as the input file, with a .i suffix.

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

         -dM (-qshowmacros)

         -qshowmacros | -qnoshowmacros
                Emits macro definitions to preprocessed output.

                This option has no effect unless preprocessed output is
                generated.  If a macro is defined and subsequently undefined
                before compilation ends, this macro will not be included in the
                preprocessed output.

                Default: -qnoshowmacros

         -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
         -+     (C++) Compiles any file, <file_name.nnn>, as a C++ language
                file, where <nnn> is any suffix other than .a, .o, .so, .s, or
                .S.  This option is equivalent to the -x c++ option and should
                not be used together with the -x or -qsourcetype option.

         -I<directory_path>
                Specifies an additional search path for include file names that
                do not specify an absolute path.

         -include <file>

         -qinclude <file>
                Specifies additional header files to be included in a
                compilation unit, as though the files were named in an #include
                statement in the source file. <file> is the header file to be
                included in the compilation units being compiled.

                The usage of the -include option is similar to that of the
                #include directive.

                Default: None.

         -x <type>

         -qsourcetype=<type>
                Determines whether to treat all recognized source files as if
                they are of the source type specified by <type> (regardless of
                file name suffix), or whether to use the file name suffix to
                determine the programming language.
                Note that the option only affects files that are specified on
                the command line following the option, but not those that
                precede the option.  The -x option should not be used together
                with the -+ option.  The suboptions are:

                assembler
                     The compiler compiles all source files following this
                     option as if they are assembler language source files.
                assembler-with-cpp
                     The compiler compiles all source files following this
                     option as if they are assembler language source files that
                     need preprocessing.
                c
                     The compiler compiles all source files following this
                     option as if they are C language source files.
                c++
                     The compiler compiles all source files following this
                     option as if they are C++ language source files.
                default (-qsourcetype only)
                     The compiler assumes that the programming language of a
                     source file will be implied by its file name suffix.
                none (-x only)
                     The programming language of a source file is implied by its
                     file name suffix.

                Default: -x none or -qsourcetype=default

         -nostdinc | -nostdinc++ (-qnostdinc)

         -qstdinc | -qnostdinc
                Specifies whether the standard directories are searched for
                files included by the #include <file_name> and #include
                "file_name" directives. The -qnostdinc option excludes the
                standard include directories from the search path.

                Default: -qstdinc

  Language element control options
         -qaltivec[=le|be] | -qnoaltivec

         -maltivec | -mno-altivec
                Enables the compiler support for vector data types and
                operators.
                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: By default, -mno-altivec is effective. Specifying
                -maltivec is equivalent to specifying -qaltivec=le.

         -fasm | -fno-asm

         -qasm[=gcc] | -qnoasm
                Controls the interpretation of, and subsequent generation of
                code for, asm statements.
                gcc
                     Interprets asm statements using GCC syntax.

                Default: -qasm=gcc or -fasm

         -D<name>[=[<def>]]
                Defines <name> as in the #define directive. <def> is an optional
                definition or value assigned to <name>. Specifying -D<name>=
                (with no <def>) is equivalent to #define <name>; specifying
                -D<name> is equivalent to #define <name> 1.

         -fdollars-in-identifiers | -fno-dollars-in-identifiers

         -qdollar | -qnodollar
                Allows the ’$’ symbol to be used in the names of identifiers.
                When -fdollars-in-identifiers or -qdollar is in effect, the
                dollar symbol ’$’ in an identifier is treated as a base
                character.  If nodollar and the ucs language level are both in
                effect, the dollar symbol is treated as an extended character
                and translated into 0024.

                Default: -fdollars-in-identifiers or qdollar

         -std[=<suboption>]

         -qlanglvl[=<qlanglvl_suboptions_list>]
                Determines whether source code and compiler options should be
                checked for conformance to a specific language standard, or
                subset or superset of a standard.

                (C) For C language programs, the suboptions of -std include:
                c89 | c90 | iso9899:1990
                     Compilation conforms strictly to the ANSI C89 standard,
                     also known as ISO C90.
                iso9899:199409
                     Compilation conforms strictly to the ISO C95 standard.
                c99 | c9x | iso9899:1999 | iso9899:199x
                     Compilation conforms strictly to the ISO C99 standard, also
                     known as ISO C99.
                c11 | c1x | iso9899:2011
                     Compilation conforms strictly to the ISO C11 standard.
                gnu89 | gnu90
                     Compilation conforms to the ANSI C89 standard and accepts
                     implementation-specific language extensions, also known as
                     GNU C90.
                gnu99 | gnu9x
                     Compilation conforms to the ISO C99 standard and accepts
                     implementation-specific language extensions, also known as
                     GNU C99.

                (C) For C language programs, <qlanglvl_suboptions_list> is a
                colon-separated list of one or more of the following suboptions:
                extc1x
                     Compilation is based on the C11 standard, invoking all the
                     currently supported C11 features and other implementation-
                     specific language extensions.

                     Note: IBM supports selected features of C11, known as C1X
                     before its ratification. IBM will continue to develop and
                     implement the features of this standard. The implementation
                     of the language level is based on IBM’s interpretation of
                     the standard. Until IBM’s implementation of all the C11
                     features is complete, including the support of a new C11
                     standard library, the implementation may change from
                     release to release. IBM makes no attempt to maintain
                     compatibility, in source, binary, or listings and other
                     compiler interfaces, with earlier releases of IBM’s
                     implementation of the new C11 features.
                extc89
                     Compilation conforms to the ANSI C89 standard and accepts
                     implementation-specific language extensions.
                extc99
                     Compilation conforms to the ISO C99 standard and accepts
                     implementation-specific language extensions.
                extended
                     Provides compatibility with the RT compiler. This language
                     level is based on C89.
                stdc89
                     Compilation conforms strictly to the ANSI C89 standard,
                     also known as ISO C90.
                stdc99
                     Compilation conforms strictly to the ISO C99 standard.
                stdc11
                     Compilation conforms strictly to the ISO C11 standard.

                (C++) For C++ language programs, the suboptions of -std include:
                c++98 | c++03
                     Compilation conforms strictly to the ISO C++ standard, also
                     known as ISO C++98.
                gnu++98 | gnu++03
                     Compilation is based on the ISO C++98 standard, with some
                     differences to accommodate extended language features.
                c++11 | c++0x
                     Compilation conforms strictly to the ISO C++ standard plus
                     amendments, also known as ISO C++11.
                gnu++11 | gnu++0x
                     Compilation is based on the ISO C++ standard, with some
                     differences to accommodate extended language features.

                (C++) For C++ language programs are, <qlanglvl_suboptions_list>
                is a colon-separated list of one or more of the following
                suboptions:
                extended
                     Compilation is based on the ISO C++ standard, with some
                     differences to accommodate extended language features.
                extended0x
                     Compilation is based on the C++11 standard, invoking most
                     of the C++ features and all the currently-supported C++11
                     features.

                     Note: IBM supports selected features of C++11, known as
                     C++0x before its ratification. IBM will continue to develop
                     and implement the features of this standard. The
                     implementation of the language level is based on IBM’s
                     interpretation of the standard. Until IBM’s implementation
                     of all the C++11 features is complete, including the
                     support of a new C++11 standard library, the implementation
                     may change from release to release.  IBM makes no attempt
                     to maintain compatibility, in source, binary, or listings
                     and other compiler interfaces, with earlier releases of
                     IBM’s implementation of the new C++11 features.
                extended1y
                     Compilation is based on the C++14 standard, invoking most
                     of the C++ features and all the currently-supported C++14
                     features.

                     Note: IBM supports selected features of C++14 standard. IBM
                     will continue to develop and implement the features of this
                     standard. The implementation of the language level is based
                     on IBM’s interpretation of the standard. Until IBM’s
                     implementation of all the C++14 features is complete,
                     including the support of a new C++14 standard library, the
                     implementation might change from release to release. IBM
                     makes no attempt to maintain compatibility, in source,
                     binary, or listings and other compiler interfaces, with
                     earlier releases of IBM’s implementation of the C++
                     standard.

                The default for std is:
                o (C) -std=gnu99 or -std=gnu9x
                o (C++) -std=gnu++98

                The default for -qlanglvl depends on the invocation command
                used:

                Command                       Default
                _____________________________________________

                xlC/xlc++                     extended
                xlc                           extc99
                cc                            extended
                c89                           stdc89
                c99                           stdc99

         -qstaticinline | -qnostaticinline
                (C++)
                Controls whether inline functions are treated as static or
                extern. Specifying -qnostaticinline means the inline
                functions are treated as having extern linkage.

                Default:
                -qnostaticinline

         -U<name>
                Undefines the identifier <name> defined by the compiler or
                by the -D<name> option.

         -fexec-charset=<charset>
                Specifies the execution character set that is used for string
                and character constants. <charset> can be any encoding that is
                supported by the iconv library routine.

                Default:
                -fexec-charset=UTF-8

  Template control options (C++ only)
         -ftemplate-depth=<number>

         -qtemplatedepth=<number>
                (C++) Specifies the maximum number of recursively instantiated
                template specializations that will be processed by the compiler.
                <number> can be a value between 1 and INT_MAX.

                Default: -ftemplate-depth=256 or -qtemplatedepth=256

         -qtmplinst=none
                Instantiates only the inline functions.

  Floating-point and integer control options
         -f{signed | unsigned | no-signed | no-unsigned}-bitfields

         -qbitfields={signed|unsigned}
                Specifies whether bit fields will be signed or unsigned.

                Default: -fsigned-bitfields or -qbitfields=signed

         -f{signed | unsigned | no-signed | no-unsighed}-char

         -qchars={signed|unsigned}
                Specifies whether the data type char will be signed or unsigned.

                Default: -funsigned-char or -qchars=unsigned

         -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
                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
                relax | norelax
                     Relaxes the strict IEEE-conformance slightly for greater
                     speed, typically by removing some trivial, floating-point
                     arithmetic operations, such as adds and subtracts involving
                     a zero on the right. Specifying -qstrict=noieeefp also
                     relaxes IEEE conformance.
                     Default: norelax
                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
                spnans | nospnans
                     Detects signaling NaN on conversion from single-precision
                     to double-precision.
                     Default: nospnans
                subnormals | nosubnormals
                     Specifies whether the code uses denormalized floating point
                     values. If the code uses denormalized floating point
                     values, specify -qfloat=subnormals; otherwise, specify
                     -qfloat=nosubnormals.
                     Note: To use this suboption, you must also specify the
                     -qarch=pwr8 and -qtune=pwr8 options.
                     Default: nosubnormals

         -y<rounding_mode>
                Specifies the compile-time rounding mode of constant floating-
                point expressions.

                For binary floating-point types, <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
         -fcommon | -fno-common

         -qcommon | -qnocommon
                Controls whether uninitialized global variables are allocated in
                the common or data section of the object file.

                Default:
                     (C) -fcommon (-qcommon), except when -shared (-qmkshrobj)
                     is specified; -fno-common (-qnocommon) when -shared
                     (-qmkshrobj) is specified.
                     (C++) -fno-common (-qnocommon)

         -qeh | -qnoeh
                (C++) Controls whether exception handling is enabled in the
                module being compiled.

                Default: -qeh

         -qfuncsect | -qnofuncsect
                Places instructions for each function in a separate section.
                Placing each function in its own section might reduce the size
                of your program because the linker can collect garbage per
                function rather than per object file.

                Default: -qnofuncsect

         -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

         -fPIC | -fno-pic | -fno-PIC

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

                Default: -fno-pic, -fno-PIC, or -qnopic

         -qpriority=<num>
                (C++) Specifies the priority level for the initialization of
                static objects, where <num> is the initialization priority level
                assigned to the static objects within a file, or the priority
                level of a shared or non-shared file or library.
                You can specify a priority level from 101 (highest priority) to
                65535 (lowest priority).

                Default: -qpriority=65535

         -r     Produces a relocatable object. This permits the output file to
                be produced even though it contains unresolved symbols.

         -qreserved_reg=<registers_list>
                Indicates that the specified register(s) cannot be used during
                the compilation, except as a stack pointer, frame pointer or in
                a  different fixed role. <registers_list> is a colon-separated
                list of registers.

         -qrtti | -qnortti

         -fno-rtti (-qnortti)
                (C++) Generates runtime type identification (RTTI) information
                for the typeid and dynamic_cast operators.

                Default: -qnortti

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

         -qsaveopt | -qnosaveopt
                Saves the command-line options used for compiling a source file,
                the user’s configuration file name and the options specified in
                the configuration files, the version and level of each compiler
                component invoked during compilation, and other information to
                the corresponding object file.
                This option must be used with the -c option.

                Default: -qnosaveopt

         -qtbtable=<suboption>
                Generates a traceback table that contains information about each
                function, including the type of function as well as stack frame
                and register information. The traceback table is placed in the
                text segment at the end of its code.  This option applies only
                to 64-bit compilations.  It is ignored if specified for a 32-bit
                compilation.  Suboptions include:

                none
                     No traceback table is generated.
                small
                     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

         -ftls-model[=<model>] | -fno-tls-model

         -qtls[=<model>] | -qnotls
                Specifies the thread-local storage model to be used by the
                application, where <model> can be:

                global-dynamic
                     This model is the most general, and can be used for all
                     thread-local variables.
                local-dynamic
                     This model provides better performance than the global-
                     dynamic model, and can be used for thread-local variables
                     defined in dynamically-loaded modules.
                initial-exec
                     This model provides better performance than the global-
                     dynamic or local-dynamic models, and can be used for
                     thread-local variables defined in dynamically-loaded
                     modules, provided that those modules are loaded at the same
                     time as the executable.
                local-exec
                     This model provides the best performance of all of the
                     models, but can only be used when all thread-local
                     variables are defined and referenced by the main
                     executable.
                default (-qtls only)
                     Uses the appropriate model depending on the setting of the
                     -fPIC (-qpic) option, which determines whether position-
                     independent code is generated or not. When -fPIC (-qpic) is
                     in effect, this suboption results in -qtls=global-dynamic.
                     When -fno-pic (-fno-PIC, -qnopic) is in effect, this
                     suboption results in -qtls=initial-exec.

                Default:
                     o qtls=default
                     o Specifying -qtls with no suboption is equivalent to
                     specifying -qtls=default.
                     o The default setting for -ftls-model is the same as the
                     default setting for -qtls.

  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.

         -qcheck[=<suboptions_list>] | -qnocheck
                Generates code that performs certain types of runtime checking.
                If a violation is encountered, a runtime exception is raised by
                sending a SIGTRAP signal to the process.

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

                all
                     Enables all suboptions.
                bounds | nobounds
                     Performs runtime checking of addresses when subscripting
                     within an object of known size.
                divzero | nodivzero
                     Performs runtime checking of integer division. A trap will
                     occur if an attempt is made to divide by zero.
                nullptr | nonullptr
                     Performs runtime checking of addresses contained in pointer
                     variables used to reference storage.
                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.
                unset | nounset
                     Checks for automatic variables that are used before they
                     are set at run time.

                Specifying -qcheck with no suboptions is equivalent to
                -qcheck=all.

                Default: -qnocheck

         -ftrapping-math | -fnotrapping-math

         -qflttrap[=<suboptions_list>] | -qnoflttrap
                Determines what types of floating-point exceptions to detect at
                run time.  <suboptions_list> is a colon-separated list of one or
                more of the following suboptions. You can specify the following
                suboptions with -qflttrap only.

                enable, en
                     Enables trapping of the specified exceptions.
                inexact, inex
                     Detects floating-point inexact exceptions.
                invalid, inv
                     Detects floating-point invalid operation exceptions.
                nanq
                     Generates code to detect and trap on NaNQ (Quiet Not-a-
                     Number) exceptions handled or generated by floating-point
                     operations.
                overflow, ov
                     Detects floating-point overflow.
                underflow, und
                     Detects floating-point underflow.
                zerodivide, zero
                     Detects floating-point division by zero.

                Default: -fnotrapping-math or -qnoflttrap

         -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 function parameter values are available to
                     the debugger at the beginning of each function.
                -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, function
                     definitions, and function calls, and function parameter
                     values are available to the debugger at the beginning of
                     each function.
                -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 function parameter values are available to
                     the debugger at the beginning of each function.
                -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 function
                     parameter values are available to the debugger at the
                     beginning of each function.

                Default:
                o -g0
                o When no optimization is enabled (-qnoopt), -g is equivalent to
                -g9
                o When the -O2 optimization level is in effect, -g is equivalent
                to -g2

         -Werror

         -qhalt=w
                Stops compilation before producing any object, executable, or
                assembler source files if the maximum severity of compile-time
                messages equals or exceeds the severity you specify.

                w = warning messages

                Default: -Werror (-qhalt=w) is not enabled.

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

                Default: -qnoinitauto

         -qkeepparm | -qnokeepparm
                Ensures that function parameters are stored on the stack even if
                the application is optimized. As a result, parameters remain in
                the expected memory location, providing access to the values of
                these incoming parameters to tools such as debuggers.

                Default: -qnokeepparm

         -qlinedebug | -qnolinedebug
                Generates only abbreviated line number and source file name
                information for the debugger.

                Default: -qnolinedebug

         -fsyntax-only (-qsyntaxonly)
                (C) Performs syntax checking without generating an object file.

                Default:
                     By default, source files are compiled and linked to
                     generate an executable file.

         -Wunsupported-xl-macro
                Checks whether any unsupported macro is used. If an unsupported
                macro is used, the compiler issues a warning message.

  Listing and messages options
         -fdump-class-hierarchy (-qdump_class_hierarchy)
                (C++) For each class object, this option dumps a representation
                of its hierarchy and virtual function table layout to a file.
                The file name is created by appending ".class" to the source
                file name.

         --help (-qhelp)
                Displays the man page of the compiler.
                If you specify the --help (-qhelp) option, regardless of whether
                you provide input files, the compiler man page is displayed and
                the compilation stops.

         -qlist[={offset|nooffset}] | -qnolist
                Produces a compiler listing file that includes object and
                constant area sections.

                offset | nooffset
                     Changes the offset of the PDEF header from 00000 to the
                     offset of the start of the procedure in the text area.

                Specifying -qlist without the suboption is equivalent to
                list=nooffset.

                Default: -qnolist

         -qlistfmt={xml|html}[=<suboptions_list>]
                Creates a report in XML or HTML format to help find optimization
                opportunities.

                xml
                     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 name of the report to be
                     generated. If you have written a tool that requires a
                     certain version of this report, you need to 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 -qsimd=auto
                o -O5
                o -qipa=level=2

                To generate a parallel transformation listing or parallel
                performance messages, you must also specify one of the following
                options on the command line:
                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, specifying
                -qlistfmt=xml is equivalent to -qlistfmt=xml=all.

         -qphsinfo | -qnophsinfo
                Reports the time taken in each compilation phase. Phase
                information is sent to standard output. 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.

                Default: -qnophsinfo

         -qreport | -qnoreport
                Instructs the compiler to produce transformation reports that
                show how program loops are optimized. The compiler also reports
                the number of streams created for a given loop.  The
                transformation reports are included as part of the compiler
                listing.  This option requires -qhot in order to have effect.
                A listing file is generated with a .lst suffix for each source
                file named on the command line.
                To generate data reorganization information, specify the
                optimization level -qipa=level=2 or -O5 together with -qreport.
                To generate information about data prefetch insertion locations,
                use the optimization level of -qhot, or any other option that
                implies -qhot together with -qreport.

                Default: -qnoreport

         -v, -V Reports the progress of compilation, by naming the programs
                being invoked and the options being specified to each program.

                When the -v option is in effect, information is displayed in a
                comma-separated list. When the -V option is in effect,
                information is displayed in a space-separated list.

         -qversion[=verbose]
                Displays the version and release of the compiler being invoked.

                verbose
                     Additionally displays information about the version,
                     release, and level of each compiler component installed.

         -w     Suppresses informational, language-level and warning messages.

  Optimization and tuning options
         -finline-functions (-qinline)

         -qinline[=auto] | -qnoinline
                Attempts to inline functions instead of generating calls to
                those functions, for improved performance.

                Default: Enabled at -O2.

         -qaggrcopy={overlap|nooverlap}
                Enables destructive copy operations for structures and unions.

                overlap | nooverlap
                     Enables or disables optimizations for structure and union
                     assignments. nooverlap assumes that the source and
                     destination for structure and union assignments do not
                     overlap, allowing the compiler to generate faster code.
                     overlap inhibits these optimizations.

                Default: -qaggrcopy=nooverlap

         -fstrict-aliasing (-qalias=ansi)

         -qalias[=<suboptions_list>]
                Indicates whether a program contains certain categories of
                aliasing or does not conform to C/C++ standard aliasing rules.
                <suboptions_list> is a colon-separated list of the following
                options:

                addrtaken | noaddrtaken
                     When addrtaken is in effect, the reference of any variable
                     whose address is taken may alias to any pointer type. Any
                     class of variable for which an address has not been
                     recorded in the compilation unit is considered disjoint
                     from indirect access through pointers. When noaddrtaken is
                     specified, the compiler generates aliasing based on the
                     aliasing rules that are in effect.
                ansi | noansi
                     If ansi is specified, type-based aliasing is used during
                     optimization, which restricts the lvalues that can be
                     safely used to access a data object. This option has no
                     effect unless you also specify the -O option.
                     Specifying -qalias=noansi turns off type-based aliasing
                     completely.
                restrict | norestrict
                     When restrict is in effect, optimizations for pointers
                     qualified with the restrict keyword are enabled. Specifying
                     norestrict disables optimizations for restrict-qualified
                     pointers.
                     -qalias=restrict is independent from other -qalias
                     suboptions.

                Default:
                     o (C/C++) -qalias=noaddrtaken:ansi:restrict
                     o (C)-qalias=noaddrtaken:ansi:restrict for all invocation
                     commands except cc. -qalias=noaddrtaken:noansi:restrict for
                     the cc invocation command.

         -mcpu[={pwr8|power8}]

         -qarch[={pwr8|auto}]
                Specifies the processor architecture for which the code
                (instructions) should be generated.

                auto
                     Automatically detects the specific architecture of the
                     compiling machine. It assumes that the execution
                     environment will be the same as the compilation
                     environment.
                pwr8
                     Produces object code containing instructions that run on
                     the POWER8 hardware platforms.
                power8
                     Produces object code containing instructions that run on
                     the POWER8 hardware platforms. You can specify this
                     suboption with -march only.

                Default:
                     o -mcpu=pwr8, -mcpu=power8, or -qarch=pwr8
                     o -qarch=auto when -O4 or -O5 is in effect

         -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:
                     Automatically determined by the setting of the -mtune
                     (-qtune) option.

         -qhot[=<suboption>] | -qnohot
                Specifies whether or not to perform high-order transformations
                during optimization. The suboptions are:

                arraypad[=<number>] | noarraypad
                     When <number> is specified, the compiler will pad every
                     array in the code. The pad amount must be a positive
                     integer value. Otherwise, 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.
                     0
                          The compiler performs a subset of the high-order
                          transformations. Some of these include early
                          distribution, loop interchange, and loop tiling, as
                          examples.  Optimization level -O3 implies
                          -qhot=level=0.
                     1
                          At level=1, full high-order transformation is
                          performed. -qhot=level=1 is equivalent to -qhot and
                          the compiler options that imply -qhot also imply
                          -qhot=level=1, unless -qhot=level=0 is explicitly
                          specified.
                vector | novector
                     When specified with -qnostrict and -qignerrno, 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.
                     You must use this suboption together with -qignerrno,
                     unless -qignerrno is already enabled by other options.
                     -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
                     -O4 or -O5 is in effect.
                     o Specifying -qhot without suboptions is equivalent to
                     -qhot=noarraypad:level=1:vector:fastmath.

         -qignerrno | -qnoignerrno
                Allows the compiler to perform optimizations that assume errno
                is not modified by system calls.

                Default: -qnoignerrno

         -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=<function_names>
                     Specifies names of functions which represent program exits.
                     <function_names> is a comma-separated list of function
                     names.
                infrequentlabel=<function_names>
                     Specifies a comma-separated list of user-defined labels
                     that are likely to be called infrequently during a program
                     run.
                isolated=<functions>
                     Specifies a comma-separated list of functions 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=<functions>
                     Specifies a comma-separated list of functions 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 functions not compiled
                     with -qipa.
                     unknown
                          Greatly restricts the amount of interprocedural
                          optimization for calls to unknown functions.
                     safe
                          Functions which do not indirectly call a visible (not
                          missing) function either through direct call or
                          function pointer.
                     isolated
                          Functions which do not directly reference global
                          variables accessible to visible functions.
                     pure
                          Functions which are safe and isolated and which do not
                          indirectly alter storage accessible to functions.
                     Default: missing=unknown
                object | noobject
                     Specifies whether to include standard object code in the
                     object files. Specifying ’noobject’ can substantially
                     reduce overall compile time by not generating object code
                     during the first IPA phase.
                partition={small|medium|large}
                     Specifies the size of program sections that are analyzed
                     together. Larger partitions may produce better analysis but
                     require more storage.
                     Default: partition=medium
                pure=<functions>
                     Specifies a comma-separated list of functions not compiled
                     with -qipa and that are "isolated", "safe", and do not
                     modify any data objects that are visible to the caller.
                safe=<functions>
                     Specifies a comma-separated list of functions not compiled
                     with -qipa and that do not call any other part of the
                     program.
                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=<functions>
                     Specifies a comma-separated list of functions 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 function names
                for these suboptions:
                exits, isolated, lowfreq, pure, safe, unknown.
                (C++) Function names must be specified using their mangled
                names.

                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.

         -qisolated_call=<procedures>
                Informs the compiler that specific functions do not have or rely
                on side effects, other than those implied by their parameters.
                <procedures> is a colon-separated list of function names.

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

                Default: -qnolibansi

         -qmaxmem=<size>
                Limits the amount of memory used by certain memory-intensive
                optimizations to <size> kilobytes. When <size> is -1, the
                optimizer will use as much memory as needed.

                Default:

                     o -qmaxmem=8192 when -O2 level optimization is set.
                     o -qmaxmem=-1 when -O3 level or greater optimization is
                     set.

         -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
                     This option is the same as -O3, but also:
                       o sets the -qarch and -qtune options to the architecture
                       of the compiling machine.
                       o sets the -qcache option most appropriate to the
                       characteristics of the compiling machine.
                       o sets the -qipa option.
                       o sets the -qhot option to level=1.
                5
                     Equivalent to -O4 -qipa=level=2.

                Specifying -O with no <level> is equivalent to specifying -O2.

                Default: -O0

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

                Default: -qnooptimize

         -p, -pg, -qprofile={-p|-pg}
                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:

                assistthread | noassistthread
                     Use this supoption to work with applications that generate
                     a high cache-miss rate. When you run
                     -qprefetch=assistthread, the compiler uses the delinquent
                     load information to perform analysis and generates
                     prefetching assist threads.
                     You can specify system architectures when using
                     -qprefetch=assistthread:
                     CMP
                          For systems based on the chip multi-processor
                          architecture (CMP), use -qprefetch=assistthread=cmp.
                     SMT
                          For systems based on the simultaneous multi-threading
                          architecture (SMT), use -qprefetch=assistthread=smt.
                aggressive | noaggressive
                     When you run this supoption, the system guides the compiler
                     to generate aggressive data prefetching at optimization
                     level -O3 -qhot or higher.
                     Default: noaggressive
                dscr
                     You can specify a value for the dscr suboption to improve
                     the runtime performance of your applications. For POWER8
                     processors, the value is valid only when the optimization
                     level is -O2 or greater; for POWER5, POWER6, and POWER7
                     processors, the value is valid only when the optimization
                     level is -O3 or greater and the 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

         -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: -qsimd=noauto

         -qsmallstack | -qnosmallstack
                Disables the optimizations that increase the size of the stack
                frame. This option is only valid when used together with IPA
                (-qipa, -O4, or -O5 compiler options).

                Default: -qnosmallstack

         -qsmp[=<suboptions_list>] | -qnosmp
                Enables parallelization of program code. <suboptions_list> is a
                colon-separated list of one or more of the following suboptions:

                auto | noauto
                     Enables automatic parallelization and optimization. If
                     noauto is specified, automatic parallelization of program
                     code is disabled; only program code explicitly parallelized
                     with OpenMP directives is optimized.
                     Default: auto
                omp | noomp
                     Enables strict OpenMP compliance. Only OpenMP
                     parallelization pragmas 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
                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:opt:noomp:norec_locks:
                schedule=auto:nostackcheck:threshold=100

                Default: -qnosmp

         -qstrict[=<suboptions_list>] | -qnostrict
                Ensures that the optimizations that are done by default at the
                -O3 and higher optimization levels, and, optionally at -O2, do
                not alter the semantics of a program.

                Note: -qstrict affects the option default changes that are made
                by the optimization levels.

                The -qstrict=all, -qstrict=precision, -qstrict=exceptions,
                -qstrict=ieeefp, and -qstrict=order suboptions and their
                negative forms are group suboptions that affect multiple,
                individual suboptions. Group suboptions act as if either the
                positive or the no form of every suboption of the group is
                specified.

                Default:

                     o Always -qstrict or -qstrict=all when the -qnoopt or -O0
                     optimization level is in effect
                     o -qstrict or -qstrict=all is the default when the -O2 or
                     -O optimization level is in effect
                     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
                     (formerly known as denorms). 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
                     If you specify -qstrict=guards, the compiler does not move
                     operations past guards, which control whether the
                     operations are executed. The compiler also does not
                     evaluate the if expressions that contain pointer wraparound
                     checks at compile time so that the compiler does not remove
                     the enclosed operations. If you specify qstrict=noguards,
                     the compiler moves operations past guards and evaluates the
                     if expressions according to language standards at compile
                     time, in which pointer wraparounds are undefined.
                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:
                     -qnostrict_induction at -O2 or higher.
                     -qstrict_induction otherwise.

         -mtune[={pwr8|power8}]

         -qtune[=<suboption>][:<smt_option>]
                Tunes instruction selection, scheduling, and other architecture-
                dependent performance enhancements to run best on a specific
                hardware architecture. Allows specification of a target SMT mode
                to direct optimizations for best performance in that mode.
                <suboption> must be one of the following suboptions:

                auto
                     Optimizations are tuned for the platform on which the
                     application is compiled.
                balanced
                     Optimizations are tuned across a selected range of recent
                     hardware.
                pwr8
                     Optimizations are tuned for the POWER8 hardware platforms.
                power8
                     Optimizations are tuned for the POWER8 hardware platforms.
                     You can specify this suboption with -mtune only.

                <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: -mtune=pwr8, -mtune=power8, or -qtune=pwr8:st

         -funroll-loops (-qunroll)

         -funroll-all-loops (-qunroll=yes)
                Controls loop unrolling, for improved performance.

                -funroll-loops
                     Instructs the compiler to perform basic loop unrolling.
                -funroll-all-loops
                     Instructs the compiler to search for more opportunities for
                     loop unrolling than that performed with -funroll-loops.  In
                     general, -funroll-all-loops has more chances to increase
                     compile time or program size than -funroll-loops
                     processing, but it might also improve your application’s
                     performance.

                Default: -funroll-loops

         -qunroll[=<suboption>] | -qnounroll
                Unrolls inner loops in the program. This can help improve
                program performance.  The suboptions are:

                auto
                     This suboption is equivalent to -funroll-loops.
                yes
                     This suboption is equivalent to -funroll-all-loops.
                no
                     Instructs the compiler to not unroll loops.
                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 -qunroll=n option specifies a global unroll
                     factor that affects all loops that do not have an unroll
                     pragma already.  The value of n must be a positive integer.

                Default: -qunroll=auto

                If -qunroll is specified with no suboptions, the compiler
                assumes -qunroll=yes. -qnounroll is equivalent to -qunroll=no.

         -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

         -fvisibility=<suboption>

         -qvisibility=<suboption>
                Specifies the visibility attribute for external linkage entities
                in object files. <suboption> is one of the following options:

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

                Default: -fvisibility=default

  Linking options
         -nostartfiles (-qnocrt)

         -qcrt  When -qcrt is in effect, the system startup routines are
                automatically linked. When -nostartfiles is in effect, the
                system startup files are not used at link time; only the files
                specified on the command line with the -l flag are linked.

         -e <name>
                Specifies an entry point for a shared object when used together
                with the -shared(-qmkshrobj) option.

         -L<dir>
                Searches the path directory for library files specified by the
                -l<key> option.

                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.

         -qlib | -qnolib

         -nodefaultlibs (-qnolib)
                Specifies whether standard system libraries and XL C/C++
                libraries are to be linked. When -qlib is in effect, the
                standard system libraries and compiler libraries are
                automatically linked. When Start of change -nodefaultlibs
                (-qnolib) End of change is in effect, the standard system
                libraries and compiler libraries are not used at link time; only
                the libraries specified on the command line with the -l flag
                will be linked.

                Default: -qlib

         -R<search_path>
                Writes search paths for shared libraries into the executable at
                link time, so that these directories are searched at program run
                time for any required shared libraries.
                If the -R<search_path> option is specified both in the
                configuration file and on the command line, the paths specified
                in the configuration file are searched first at run time.

         -static (-qstaticlink)
                Controls whether static or shared libraries are linked into the
                application.

                Default: -qnostaticlink

  Portability and migration options
         -fpack-struct

         -qalign[=suboption]
                Specifies what aggregate alignment rules the compiler uses for
                file compilation, where the alignment suboptions are:

                bit_packed
                     Bit field data is packed on a bitwise basis without respect
                     to byte boundaries.
                linuxppc
                     Uses GNU C/C++ alignment rules to maintain binary
                     compatibility with GNU C/C++ objects.

                Default: -fpack-struct or -qalign=linuxppc

         -qxlcompatmacros | -qnoxlcompatmacros
                Determines whether the macros used by earlier versions of the
                compiler for indicating the XL C/C++ compiler product are
                defined. Use the -qxlcompatmacros option to keep macro
                definitions consistent with earlier versions of the XL C/C++
                compilers.

                Default: -qxlcompatmacros

  Compiler customization options
         -qasm_as[=<asm_path> [<flags_list>]] | -qnoasm_as
                Specifies the path and flags used to invoke the assembler in
                order to handle assembler code in an asm statement. <asm_path>
                is the full path to the assembler to be used, and <flags_list>
                is a series of one or more flags (and their arguments),
                separated by spaces. Single quotes (or double quotes) are
                required around the string of arguments if any spaces exist.

         -B[<prefix>]
                Specifies substitute path names for compiler componnets, 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.

         -isystem <dir>

         -qc_stdinc=<directory_path>
                (C) Changes the standard search location for the XL C headers.

                <dir> is the directory for the compiler to search for XL C
                header files. The search directories are after all directories
                specified by the -I option but before the standard system
                directories. <dir> can be a relative or absolute path.

                <directory_path> is a colon-separated list of paths to search.

         -isystem <dir>

         -qcpp_stdinc=<directory_path>
                (C++) Specifies the standard search directories for the XL C++
                headers.

                <dir> is the directory for the compiler to search for XL C++
                header files. The search directories are after all directories
                specified by the -I option but before the standard system
                directories. The dir can be a relative or absolute path.

                <directory_path> is the path for the directory where the
                compiler should search for the XL C++ header files. The
                directory_path can be a relative or absolute path. You can
                surround the path with quotation marks to ensure it is not split
                up by the command line.

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

         @<filename>

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

         -isystem <dir>

         -qgcc_c_stdinc=<paths_list>
                (C) Specifies the standard search directories for the GNU C
                system header files.

                <dir> is the directory for the compiler to search for GNU C
                header files. The search directories are after all directories
                specified by the -I option but before the standard system
                directories.  <dir> can be a relative or absolute path.

                <paths_list> is a list of one or more paths. This option is
                ignored if the -qnostdinc option is in effect.

         -isystem <dir>

         -qgcc_cpp_stdinc=<directory_path>
                (C++) Specifies the standard search directories for the XL C++
                headers.

                <dir> is the directory for the compiler to search for GNU C++
                header files. The search directories are after all directories
                specified by the -I option but before the standard system
                directories. The dir can be a relative or absolute path.

                <directory_path> is the path for the directory where the
                compiler should search for the GNU C++ header files. The
                directory_path can be a relative or absolute path. You can
                surround the path with quotation marks to ensure it is not split
                up by the command line.

         -qpath=<program>:<path>
                Constructs alternate program names for compiler components. The
                program and directory path specified are used in place of the
                regular program. <program> can be one of the following values:

                a = Assembler
                b = Low-level optimizer
                c = Compiler front end
                C = C++ compiler front end
                d = Disassembler
                I = High-level optimizer - compile step
                L = High-level optimizer - link step
                l = Linker

         -qspill=<size>
                Specifies the size of the register allocation spill area in
                bytes.

                Default: -qspill=512

         -t<programs_list>
                Applies the prefix from the -B option to the specified programs
                in <programs_list>. <programs_list> is a chain (i.e: -tbcI) of
                one or more of the following programs:

                a = Assembler
                b = Low-level optimizer
                c = Compiler front end
                C = C++ compiler front end
                d = Disassembler
                I = High-level optimizer  - compile step
                L = High-level optimizer - link step
                l = Linker


         -X{<X_program> <option>}

         -W<W_program>,<options_list>
                Gives the specified option(s) to the compiler program.

                <option> is any option that is valid for the component to which
                it is being passed.  <X_program> can be one of the following
                programs:

                o assembler
                o preprocessor
                o linker

                <options_list> is a comma-separated list of one or more options.
                <W_program> can be one of the following programs:

                a = Assembler
                b = Low-level optimizer
                c = Compiler front end
                C = C++ compiler front end
                d = Disassembler
                I = High-level optimizer  - compile step
                L = High-level optimizer - link step
                l = Linker
                p = Preprocessor


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

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


  COPYRIGHT
         Licensed Materials - Property of IBM.

         IBM XL C/C++ for Linux, V13.1.2

         5765-J08; 5725-C73

         Copyright IBM Corp. 1991, 2015

         IBM, the IBM logo, ibm.com, 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                               xlc(1)

Generation:

mantohtml xlc