xlc(1)                 IBM (October 2005)                  xlc(1)



  NAME
         xlc, xlc++, xlC, cc, c89, c99, xlCcore, xlc++core and
         related commands - invoke the IBM XL C/C++ compiler

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

         The invocation commands are:
         xlc, xlc++, xlC, cc, c89, c99, xlc++core, xlCcore, xlc128,
         xlc++128, xlC128, cc128, c89_128, c99_128, xlc++core128,
         xlCcore128, optionally followed by _r, _r4, or _r7.

  DESCRIPTION
         xlc and related commands compile C and C++ source files.
         They 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, .cc, .cp, .c++ = C++ source file
          .c = C source file
          .i = preprocessed C or C++ source file
          .a = archive file
          .o = object file for ld command
          .s = assembler source file
          .S = assembler source file that needs preprocessing

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

  Input Control Options
         -+     (C++) Compiles any file, <filename.nnn>, as a C++
                language file, where <nnn> is any suffix other than
                .a, .so, .o, .s, or .S.  This option should not be
                used together with the -qsourcetype option.

         -C     Preserves comments in preprocessed output if used
                with -E or -P. With the -E option, comments are
                written to standard output; with the -P option,
                comments are written to an output file.

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

         -I<dir>
                Specifies an additional search path for include
                filenames that do not specify an absolute path.

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

         -qaltivec | -qnoaltivec
                Enables compiler support for vector data types.
                Instructs the compiler to support vector data types
                and operators and is accepted when the architecture
                specified by -qarch option supports VMX
                instructions and -qenablevmx is in effect.  The
                default is -qnoaltivec.

         -qasm[=<sub>] | -qnoasm[=<sub>]
                Controls the interpretation of, and subsequent
                generation of code for, asm statements.
                (C) In C, <sub> can only be 'gcc'.
                (C++) In C++, <sub> can be:

                gcc
                     Interprets asm statements using gcc syntax.
                stdcpp
                     Interprets asm statements using stdcpp syntax.

                (C++) The default is -qnoasm=stdcpp in ansi,
                compat366 or strict98 modes, and -qasm=gcc
                otherwise.  (C) The default is -qasm=gcc.

         -qcinc=<prefix> | -qnocinc
                (C++) Instructs the compiler to place an extern "C"
                { } wrapper around the contents of an include file.
                The default is -qnocinc.

         -qcpluscmt | -qnocpluscmt
                (C) Permits the usage of "//" to introduce a
                comment that lasts until the end of the current
                source line, as in C++.  The default is -qcpluscmt
                when you invoke the compiler with xlc, xlc_r, cc,
                or cc_r, or when -qlanglvl is set to stdc99 or
                extc99.  Otherwise, the default setting is
                -qnocpluscmt.

         -qcpp_stdinc=<paths_list>
                (C++) Specifies the standard search directories for
                the C++ headers shipped with this product, where
                <paths_list> is a colon-separated list of paths.

         -qdbcs | -qnodbcs
                Specifies that string literals and comments can
                contain multi-byte characters. This is equivalent
                to -qmbcs.  The default is -qnodbcs.

         -qdigraph | -qnodigraph
                Allows usage of digraph key combinations or
                keywords to represent characters not found on some
                keyboards.
                (C) The default is -qdigraph when -qlanglvl is
                extc89, extended, extc99 or stdc99. Otherwise the
                default is -qnodigraph.
                (C++) The default is -qdigraph.

         -qdollar | -qnodollar
                Allows the '$' symbol to be used in the names of
                identifiers. When -qdollar is in effect, the dollar
                symbol '$' in an identifier is treated as a base
                character. If the options -qnodollar and
                -qlanglvl=ucs are both in effect, the dollar symbol
                is treated as an extended character.  The default
                is -qnodollar.

         -qidirfirst | -qnoidirfirst
                Specifies the search order for files included with
                the #include "<filename>" directive.  Use
                -qidirfirst with the -I option.  If -qidirfirst is
                specified, the directories specified by the
                -I<directory> option are searched before the
                directory in which the current file resides.  The
                default is -qnoidirfirst.

         -qignprag=<option>
                Instructs the compiler to ignore certain pragma
                statements.  The options are:

                disjoint
                     Ignores all #pragma disjoint directives in the
                     source file.
                isolated
                     Ignores all #pragma isolated_call directives
                     in the source file.
                all
                     Ignores all #pragma isolated_call directives
                     and #pragma disjoint directives in the source
                     file.
                omp
                     Ignores all OpenMP parallel processing
                     directives in the source file.
                ibm
                     (C) Ignores IBM parallel processing
                     directives.

         -qkeyword=<keyword> | -qnokeyword=<keyword>
                Controls whether the specified name is treated as a
                keyword or as an identifier whenever it appears in
                a program source.  By default all the built-in
                keywords defined in the C and C++ language
                standards are reserved as keywords. However, you
                can use -qnokeyword=<keyword> to disable built-in
                keywords, and use -qkeyword=<keyword> to reinstate
                those keywords.

         -qlanglvl=<suboptions_list>
                Selects the language level and language options for
                the compilation. <suboptions_list> is a colon-
                separated list of suboptions.  The suboptions are:

                (C) For C programs, the suboptions are:
                classic
                     Allows the compilation of non-stdc89 programs,
                     and conforms closely to the K&R level
                     preprocessor.
                extended
                     Provides compatibility with the RT compiler
                     and classic. This language level is based on
                     C89.
                saa
                     Compilation conforms to the current SAA(R) C
                     CPI language definition. This is currently SAA
                     C Level 2.
                saal2
                     Compilation conforms to the SAA C Level 2 CPI
                     language definition, with some exceptions.
                stdc89
                     Compilation conforms to the ANSI C89 standard,
                     also known as ISO C90.
                stdc99
                     Compilation conforms to the ISO C99 standard.
                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.
                ucs | noucs
                     This option controls whether Unicode
                     characters are allowed in identifiers, string
                     literals and character literals in program
                     source code.  Under language levels stdc99 and
                     extc99, the default is -qlanglvl=ucs.

                (C++) For C++ programs, the suboptions are:
                compat366
                     Compilation conforms to some, but not all, IBM
                     C and C++ Compilers V3.6 features.
                extended
                     Compilation is based on the strict98, with
                     some differences to accommodate extended
                     language features.
                strict98
                     Compilation conforms to the ISO C++ standard
                     for C++ programs.
                anonstruct | noanonstruct
                     This suboption controls whether anonymous
                     structs and anonymous classes are allowed in
                     your C++ source. By default, the compiler
                     allows anonymous structs.
                anonunion | noanonunion
                     This suboption controls what members are
                     allowed in anonymous unions. When this
                     suboption is set to anonunion, anonymous
                     unions can have members of all types that
                     standard C++ allows in non-anonymous unions.
                ansifor | noansifor
                     This suboption controls whether scope rules
                     defined in the C++ standard apply to names
                     declared in for-init statements. By default,
                     standard C++ rules are used.
                ansisinit | noansisinit
                     This suboption can be used to select between
                     old (v3.6 or earlier) and current (v5.0 or
                     later) compiler object compatibility.
                c99__func__ | noc99__func__
                     This suboption instructs the compiler to
                     recognize the C99 __func__ identifier.  The
                     c99__func__ suboption is enabled by default
                     when -qlanglvl=extended is in effect. It can
                     be enabled for any language level by
                     specifying -qlanglvl=c99__func__, or disabled
                     by specifying -qlanglvl=noc99__func__.
                c99complex | noc99complex
                     This suboption instructs the compiler to
                     recognize C99 complex data types and related
                     keywords.
                c99complexheader | noc99complexheader
                     This suboption instructs the compiler to use
                     the C99 complex.h header file.
                c99compoundliteral | noc99compoundliteral
                     This suboption instructs the compiler to
                     support the C99 compound literal feature.
                c99hexfloat | noc99hexfloat
                     This option enables support for C99-style
                     hexadecimal floating constants in C++
                     applications. This suboption is on by default
                     for -qlanglvl=extended.
                c99vla | noc99vla
                     When c99vla is in effect, the compiler will
                     support the use of C99-type variable length
                     arrays in your C++ applications.
                compatzea | nocompatzea
                     The -qlanglvl=compatzea option is a
                     compatibility option that lets you continue to
                     use a zero extent array with dimension of 1 in
                     AIX applications compiled with XL C/C++ v8.0
                     for AIX.  The default is
                     -qlanglvl=nocompatzea. Specifying
                     -qlanglvl=compatzea has effect only if
                     -qlanglvl=zeroextarray is also in effect.
                dependentbaselookup | nodependentbaselookup
                     Provides the ability to specify compilation in
                     conformance with issue 213 of TC1 of the C++
                     standard. The default is
                     -qlanglvl=dependentbaselookup.
                gnu_assert | nognu_assert
                     GNU C portability option allows you to enable
                     or disable support for the following GNU C
                     system identification assertions: '#assert',
                     '#unassert', '#cpu', '#machine', '#system'.
                gnu_complex | nognu_complex
                     This suboption instructs the compiler to
                     recognize GNU complex data types and related
                     keywords.
                gnu_computedgoto | nognu_computedgoto
                     GNU C portability option allows you to enable
                     support for computed gotos. This suboption is
                     enabled for -qlanglvl=extended, and defines
                     the macro __IBM_COMPUTED_GOTO.
                gnu_explicitregvar | nognu_explicitregvar
                     (C) GNU C portability option allows you to
                     control whether the compiler accepts and
                     ignores the specification of explicit
                     registers for variables.
                gnu_externtemplate | nognu_externtemplate
                     This suboption enables or disables extern
                     template instantiations. The default setting
                     is gnu_externtemplate when compiling to the
                     extended language level.
                gnu_include_next | nognu_include_next
                     GNU C portability option allows you to enable
                     or disable support for the GNU C #include_next
                     preprocessor directive.
                gnu_labelvalue | nognu_labelvalue
                     GNU C portability option to enable or disable
                     support for labels as values. This suboption
                     is on by default for -qlanglvl=extended, and
                     defines the macro __IBM_LABEL_VALUE.
                gnu_locallabel | nognu_locallabel
                     GNU C portability option allows you to enable
                     or disable support for locally-declared
                     labels.
                gnu_membernamereuse
                     GNU C++ portability option to enable reusing a
                     template name in a member list as a typedef.
                gnu_suffixij | nognu_suffixij
                     GNU C portability option allows you to enable
                     or disable support for GCC style complex
                     numbers. If gnu_suffixij is specified, a
                     complex number can be ended with suffix i/I or
                     j/J.
                gnu_varargmacros | nognu_varargmacros
                     This option is similar to
                     -qlanglvl=varargmacros. For the list of the
                     main differences, refer to the Compiler
                     Reference.
                gnu_warning | nognu_warning
                     GNU C portability option allows you to enable
                     or disable support for the GNU C #warning
                     preprocessor directive.
                illptom | noillptom
                     This suboption controls what expressions can
                     be used to form pointers to members. C/C++ can
                     accept some forms that are in common use, but
                     do not conform to the C++ standard. By
                     default, the compiler allows these forms.
                implicitint | noimplicitint
                     This suboption controls whether the compiler
                     will accept missing or partially specified
                     types as implicitly specifying 'int'. This is
                     no longer accepted in the standard but may
                     exist in legacy code. With the suboption set
                     to noimplicitint, all types must be fully
                     specified. With the suboption set to
                     implicitint, a function declaration at
                     namespace scope or in a member list will
                     implicitly be declared to return int.
                newexcp | nonewexcp
                     This suboption determines whether or not the
                     C++ new operator throws an exception. If the
                     -qlanglvl=newexcp option is specified, the
                     standard exception std::bad_alloc is thrown
                     when the requested memory allocation fails.
                     This option does not apply to the nothrow
                     versions of the new operator.  The standard
                     implementation of the new operators fully
                     support exceptions. For compatibility with
                     previous versions of VisualAge C++, these
                     operators return 0 by default.
                offsetnonpod | nooffsetnonpod
                     This suboption controls whether the offsetof
                     macro can be applied to classes that are not
                     data-only.  By default, the compiler allows
                     offsetof to be used with non-POD classes.
                olddigraph | noolddigraph
                     This option controls whether old-style
                     digraphs are allowed in your C++ source. It
                     applies only when -qdigraph is also set. By
                     default, the compiler supports only the
                     digraphs specified in the C++ standard.
                oldfriend | nooldfriend
                     This option controls whether friend
                     declarations that name classes without
                     elaborated class names are treated as C++
                     errors. By default, the compiler lets you
                     declare a friend class without elaborating the
                     name of the class with the keyword class.
                oldmath | nooldmath
                     This suboption controls which versions of math
                     function declarations in <math.h> are included
                     when you specify math.h as an included or
                     primary source file. By default, the new
                     standard math functions are used. Build with
                     -qlanglvl=nooldmath for strict compliance with
                     the C++ standard.  For compatibility with
                     modules that were built with earlier versions
                     of VisualAge C++ and predecessor products you
                     may need to build with -qlanglvl=oldmath.
                oldtempacc | nooldtempacc
                     This suboption controls whether access to a
                     copy constructor to create a temporary object
                     is always checked, even if creation of the
                     temporary object is avoided. By default, the
                     compiler suppresses the access checking.
                oldtmplalign | nooldtmplalign
                     This suboption specifies the alignment rules
                     implemented in versions of the compiler (xlC)
                     prior to version 5.0. These earlier versions
                     of the xlC compiler ignore alignment rules
                     specified for nested templates. By default,
                     these alignment rules are not ignored in
                     VisualAge C++ 4.0 or later.
                oldtmplspec | nooldtmplspec
                     This suboption controls whether template
                     specializations that do not conform to the C++
                     standard are allowed. By default, the compiler
                     allows these old specializations
                     (-qlanglvl=nooldtmplspec).
                redefmac | noredefmac
                     Specifies whether a macro can be redefined
                     without a prior #undef or undefine()
                     statement.
                trailenum | notrailenum
                     This suboption controls whether trailing
                     commas are allowed in enum declarations. By
                     default, the compiler allows one or more
                     trailing commas at the end of the enumerator
                     list.
                typedefclass | notypedefclass
                     This suboption provides backwards
                     compatibility with previous versions of
                     VisualAge C++ and predecessor products.
                ucs | noucs
                     This suboption controls whether Unicode
                     characters are allowed in identifiers, string
                     literals and character literals in C++
                     sources. The default setting is
                     -qlanglvl=noucs.
                varargmacros | novarargmacros
                     This C99 feature allows the use of a variable
                     argument list in function-like macros in your
                     C++ applications.
                zeroextarray | nozeroextarray
                     This suboption controls whether zero-extent
                     arrays are allowed as the last non-static data
                     member in a class definition. By default, the
                     compiler allows arrays with zero elements.

                The default depends on the invocation command used:

                COMMAND         DEFAULT
                xlC/xlc++       extended
                xlc             extc89
                cc              extended
                c89             stdc89
                c99             stdc99

         -qmacpstr | -qnomacpstr
                Converts Pascal string literals into null-
                terminated strings where the first byte contains
                the length of the string.  The default is
                -qnomacpstr.

         -qmbcs | -qnombcs
                Specifies that string literals and comments can
                contain multi-byte characters. This is equivalent
                to -qdbcs.  The default is -qnombcs.

         -qpascal | -qnopascal
                (C) Specifies whether to recognize and accept the
                keyword 'pascal' in type specifiers and function
                declarations.  The default is -qnopascal.

         -qsourcetype=<type>
                Determines whether to treat all recognized source
                files as if they are of the source type specified
                by <type> (regardless of filename suffix), or
                whether to use the filename suffix to determine the
                programming language. The options are:

                default
                     The compiler assumes that the programming
                     language of a source file will be implied by
                     its filename suffix.
                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.
                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.

                The default is -qsourcetype=default.

         -qstdinc | -qnostdinc
                Specifies which directories are used 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.  The default is -qstdinc.

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

         -qtrigraph | -qnotrigraph
                Allows trigraph key combinations to represent
                characters not found on some keyboards.
                The default is qtrigraph, however if
                -qlanglvl=classic is in effect or implied, the
                trigraphs are not recognized by default.

         -qutf | -qnoutf
                Enables recognition of UTF literal syntax.  The
                default is -qnoutf.

  Output Control Options
         -#     Traces the compilation and generates information on
                the progress of the compilation without invoking
                the preprocessor, compiler, or linkage editor.

         -c     Instructs the compiler to pass source files to the
                compiler only. Compiled source files are not sent
                to the linkage editor.

         -E     Instructs the compiler to preprocess the source
                files and send preprocessed source to standard
                output.

         -M     Creates an output file that contains information to
                be included in a "make" description file. This is
                equivalent to specifying -qmakedep without a
                suboption.

         -MF<file>
                Specifies the target for the output generated by
                the -qmakedep or -M options, where <file> is the
                target output filepath. Note that "-MF <file>"
                (with a space before the argument) is also
                acceptable. This option only has effect when
                specified with -qmakedep or -M.

         -ma    (C) Substitutes inline code for calls to function
                alloca.

         -o <filespec>
                Specifies an output location for the object,
                assembler, or executable files created by the
                compiler. When the -o option is used during
                compiler invocation, <filespec> can be the name of
                either a file or a directory.  The default name is
                a.out.

         -P     Preprocesses the C or C++ source files named in the
                compiler invocation and creates an output
                preprocessed source file, <filename.i> for each
                input source file.  The default is to compile and
                link-edit C or C++ source files to produce an
                executable file.

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

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

         -q32,-q64
                Selects either 32-bit or 64-bit compilation mode.
                Use the -q32 and -q64 options, along with the
                -qarch and -qtune compiler options, to optimize the
                output of the compiler to the architecture on which
                that output will be used. The default is -q32.

         -qalign=<option>
                Specifies what aggregate alignment rules the
                compiler uses for file compilation, where the
                alignment options are:

                bit_packed
                     The compiler uses the bit_packed alignment
                     rules.
                full
                     The compiler uses the RISC System/6000
                     alignment rules. This is the same as power.
                mac68k
                     The compiler uses the Macintosh alignment
                     rules.  This suboption is valid only for 32-
                     bit compilations.
                natural
                     The compiler maps structure members to their
                     natural boundaries.
                packed
                     The compiler uses the packed alignment rules.
                power
                     The compiler uses the RISC System/6000
                     alignment rules.
                twobyte
                     The compiler uses the Macintosh alignment
                     rules.  This suboption is valid only for 32-
                     bit compilations.  The mac68k option is the
                     same as twobyte.

                The default is -qalign=full.

         -qalloca
                (C) Substitutes inline code for calls to function
                alloca, as if #pragma alloca directives were in the
                source code.

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

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

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

         -qenum=<option>
                Specifies the amount of storage occupied by
                enumerations, where <option> is:

                small
                     Specifies that enumerations occupy the
                     smallest amount of space (1, 2, 4, or 8 bytes)
                     that can accurately represent the range of
                     values in the enumeration.  Signage is
                     unsigned, unless the range of values includes
                     negative values.
                int
                     Specifies that enumerations occupy 4 bytes and
                     are represented by int.
                intlong
                     Specifies that enumerations occupy 8 bytes of
                     storage if the range of values in the
                     enumeration exceeds the limit for int.
                     Otherwise, the enumerations occupy 4 bytes of
                     storage and are represented by int.
                1
                     Specifies that enumerations occupy 1 byte.
                     Type is signed or unsigned char.
                2
                     Specifies that enumerations occupy 2 bytes.
                     Type is signed or unsigned short.
                4
                     Specifies that enumerations occupy 4 bytes.
                     Type is signed or unsigned int.
                8
                     Specifies that enumerations occupy 8 bytes.
                     Type is signed or unsigned long long in 32-bit
                     mode, and signed or unsigned long in 64-bit
                     mode.

         -qfuncsect | -qnofuncsect
                Places instructions for each function in a separate
                object file control section or csect.  The default
                is -qfuncsect.

         -qmakedep[=gcc]
                Creates an output file that contains targets
                suitable for inclusion in a description file for
                the make command that describes the dependencies of
                the main source file in the compilation.
                Specifying 'gcc' changes the format of the
                generated dependency file. Specifying -qmakedep
                without 'gcc' is equivalent to specifying -M.

         -qnamemangling=<scheme>
                (C++) Chooses the name mangling scheme for external
                symbol names generated from C++ source code. The
                <scheme> can be:

                ansi
                     Fully supports the standard C++ language
                     features.
                v6
                     Is compatible with VisualAge C++ V6.0.
                v5
                     The scheme for VisualAge C++ V5.0.
                v4
                     The scheme for VisualAge C++ V4.0.
                v3
                     The scheme for VisualAge C++ releases before
                     V4.0.
                compat
                     Same as v3.

                The default is -qnamemangling=ansi.

         -qobjmodel={classic|ibm}
                (C++) Specifies the object model:

                classic
                     This object model is compatible with version
                     3.6 of the IBM C and C++ compilers.
                ibm
                     Uses the object model introduced with version
                     5.0 of VisualAge C++ for AIX. Objects compiled
                     with this object model will use less memory
                     and have better performance for deep
                     inheritance with virtual bases.

                The default is -qobjmodel=classic.

         -qpic[={small|large}]
                Instructs the compiler to generate position-
                independent code suitable for use in shared
                libraries.

                small
                     Instructs the compiler to assume that the size
                     of the global offset table is no larger than
                     64 Kb.
                large
                     Allows the global offset table to be larger
                     than 64 Kb in size, allowing more addresses to
                     be stored in the table.

                The -qpic option is implied if either of the -G or
                -qmkshrobj compiler options is specified.  The
                default is -qpic=small.

         -qppline | -qnoppline
                Enables generation of #line directive in the
                preprocessed output.  If the -P option is enabled,
                the default is -qnoppline. Otherwise, the default
                is -qppline.

         -qreserved_reg=<registers_list>
                (C) 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. You should use this option in modules
                that are required to work with other modules that
                use global register variables or hand-written
                assembler code.

         -qro | -qnoro
                Specifies the storage type for string literals and
                puts string literals in read-only storage.  The
                default with cc and its derivatives is -qnoro,
                otherwise the default is -qro.

         -qroconst | -qnoroconst
                Specifies the storage location for constant values.
                Puts constant values in read-only storage.  The
                default with xlc, xlc++, xlC, and c89 compiler
                invocations is -qroconst, and the default with cc
                is -qnoroconst.

         -qroptr | -qnoroptr
                Specifies the storage location for constant
                pointers. This options requires AIX V5.2 or
                greater.  The default is -qnoroptr.

         -qrtti=<option> | -qnortti
                (C++) Generates runtime type identification (RTTI)
                information for the typeid and dynamic_cast
                operators. The suboptions are:

                all
                     Generates the information needed for the RTTI
                     typeid and dynamic_cast operators.
                type | typeinfo
                     Generates the information needed for the RTTI
                     typeid operator only.
                dyna | dynamiccast
                     Generates the information needed for the RTTI
                     dynamic_cast operator only.

                The default is -qnortti.

         -qsaveopt | -qnosaveopt
                Saves command line options in the corresponding
                object files.  The default is -qnosaveopt.

         -qstaticinline | -qnostaticinline
                (C++) Controls whether inline functions are treated
                as static or extern.  The default is
                -qnostaticinline, meaning the inline functions are
                treated as having extern linkage.

         -qstatsym | -qnostatsym
                Adds user-defined, non-external names that have a
                persistent storage class (such as initialized and
                uninitialized static variables) to the name list.
                The default is -qnostatsym.

         -qthreaded | -qnothreaded
                Ensures that all optimizations will be thread-safe
                for executing in a multi-threaded environment.  The
                default is -qthreaded when compiling invocation
                commands ending in "_r", and -qnothreaded
                otherwise.

         -qunique | -qnounique
                (C++) Generates unique names for static
                constructor/destructor file compilation units. The
                default is -qnounique.

         -qupconv | -qnoupconv
                (C) Preserves the unsigned specification when
                performing integral promotions.  The default is
                -qupconv when -qlanglvl=extc89, and -qnoupconv
                otherwise.

         -qvftable | -qnovftable
                (C++) Controls the generation of virtual function
                tables for all classes with virtual functions that
                are defined in this compilation unit. The default
                is -qvftable, in which the compiler defines the
                virtual function table for a class where the first
                non-inline virtual member function is declared. If
                -qnovftable is specified, no virtual function
                tables are produced.

         -qweaksymbol | -qnoweaksymbol
                Instructs the compiler to generate weak symbols.
                The default is -qnoweaksymbol on AIX 5.1, and
                -qweaksymbol on AIX 5.2 and higher.

         -qxcall | -qnoxcall
                Generates code to treat static functions within a
                compilation unit as if they were external
                functions.  The default is -qnoxcall.

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

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

         -Q[<suboption>]
                (C++) Instructs the compiler to try to inline
                functions. Inlining is performed if possible but,
                depending on which optimizations are performed,
                some functions might not be inlined.
                (C) Specifies which specific functions the compiler
                should attempt to inline.

                (C++) In the C++ language, this option can take the
                form:

                     -Q
                          Compiler inlines all functions that it
                          can.
                     -Q!
                          Compiler does not inline any functions.

                (C) In the C language, this option can take the
                form:

                     -Q
                          Attempts to inline all appropriate
                          functions with 20 executable source
                          statements or fewer, subject to the
                          setting of any of the suboptions to the
                          -Q option. If -Q is specified last, all
                          functions are inlined.
                     -Q!
                          Does not inline any functions. If -Q! is
                          specified last, no functions are inlined.
                     -Q-<names_list>
                          Does not inline functions listed in
                          <names_list>, where <names_list> is a
                          colon-separated list. All other
                          appropriate functions are inlined. The
                          option implies -Q.
                     -Q+<names_list>
                          Attempts to inline the functions listed
                          in <names_list> and any other appropriate
                          functions. <names_list> is a colon-
                          separated list.  The option implies -Q.
                     -Q=<threshold>
                          Sets a size limit on the functions to be
                          inlined. The number of executable
                          statements must be less than or equal to
                          <threshold> for the function to be
                          inlined. <threshold> must be a positive
                          integer. The default value is 20.
                          Specifying a threshold value of 0 causes
                          no functions to be inlined except those
                          functions marked with the __inline,
                          _Inline, or _inline keywords.

                The default is to treat inline specifications as a
                hint to the compiler.

         -qaggrcopy={overlap|nooverlap}
                Enables destructive copy operations for structures
                and unions.  The default is -qaggrcopy=overlap when
                compiling to the EXTENDED and CLASSIC language
                levels, and -qaggrcopy=nooverlap otherwise.

         -qalias=<options_list>
                Specifies the aliasing assertions to be applied to
                your compilation unit. <options_list> is a colon-
                separated list of the following options:

                addrtaken | noaddrtaken
                     Variables are disjoint from pointers unless
                     their address is taken.
                allptrs | noallptrs
                     If noallptrs is specified, pointers are never
                     aliased.
                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. The default is ansi for the xlc,
                     xlC, and c89 commands. This option has no
                     effect unless you also specify the -O option.
                typeptr | notypeptr
                     If notypeptr is specified, pointers to
                     different types are never aliased.

                The default is
                -qalias=noaddrtaken:noallptrs:typeptr:ansi.

         -qansialias | -qnoansialias
                This option is obsolete. Use -qalias=ansi in your
                new applications. See the -qalias=ansi suboption.
                The default is -qansialias with xlc, c99, and c89,
                and -qnoansialias with cc.

         -qarch=<option>
                Specifies the general processor architecture for
                which the code (instructions) should be generated.
                In general, the -qarch option allows you to target
                a specific architecture for the compilation. For
                any given -qarch setting, the compiler defaults to
                a specific, matching -qtune setting, which can
                provide additional performance improvements.  The
                suboptions are:

                auto
                     Generates instructions that will run on the
                     hardware platform on which the program is
                     compiled.
                com
                     In 32-bit mode, generates instructions that
                     will run on all the POWER and PowerPC hardware
                     platforms.  In 64-bit mode, these instructions
                     will run on 64-bit PowerPC processors but not
                     on 32-bit PowerPC processors.  This is the
                     default unless -q64, -O4, or -O5 are
                     specified.
                pwr
                     Generates instructions that will run on the
                     POWER, POWER2, and 601 hardware platforms.
                pwr2
                     Generates instructions that will run on the
                     POWER2 hardware platform.
                pwr3
                     Generates instructions that will run on a
                     POWER3, POWER4, POWER5, and POWERPC970 chip.
                pwr4
                     Generates instructions that will run on a
                     POWER4, POWER5, and POWERPC970 chip.
                pwr5
                     Generates object code containing instructions
                     that will run on the POWER5 hardware platform.
                pwr5x
                     Generates instructions that will run on any
                     POWER5+ hardware platform.
                ppc
                     In 32-bit mode, produces object code
                     containing instructions that will run on any
                     of the 32-bit PowerPC hardware platforms. This
                     suboption will cause the compiler to produce
                     single-precision instructions to be used with
                     single-precision data.  Specifying -qarch=ppc
                     together with -q64 quietly upgrades the -qarch
                     setting to -qarch=ppc64.
                ppcgr
                     In 32-bit mode, produces object code for
                     PowerPC processors that support optional
                     graphics instructions. Note that specifying
                     -q64 with -qarch=ppcgr will quietly upgrade
                     the -qarch setting to -qarch=ppc64gr.
                ppc64
                     Generates instructions that will run on any of
                     the 64-bit PowerPC hardware platform.
                ppc64v
                     Generates instructions for the 64-bit PowerPC
                     processor with VMX.
                ppc970
                     Generates instructions that will run on the
                     PPC970 hardware platform.
                ppc64gr
                     Generates instructions for any 64-bit PowerPC
                     hardware platform that supports optional
                     graphics instructions.
                ppc64grsq
                     Generates instructions for any 64-bit PowerPC
                     hardware platform that supports optional
                     graphics and square root instructions.
                pwr2s
                     Generates instructions that will run on POWER2
                     Chip desktop implementations.
                p2sc
                     Generates instructions that will run on a
                     POWER2 Super Chip.
                601
                     Generates instructions that will run on a 601
                     chip.
                602
                     Generates instructions that will run on a 602
                     chip.
                603
                     Generates instructions that will run on a 603
                     chip.
                604
                     Generates instructions that will run on a 604
                     chip.
                403
                     Generates instructions that will run on a 403
                     chip.
                rs64a
                     Generates instructions that will run on a
                     rs64I chip.
                rs64b
                     Generates instructions that will run on a
                     RS64II chip.
                rs64c
                     Generates instructions that will run on a
                     RS64III chip.

         -qassert=<suboption> | -qnoassert
                (C) This option is obsolete. Use -qalias in your
                new applications. This option specifies the
                aliasing assertion to be applied to your
                compilation unit.  The suboptions are:

                typeptr
                     Pointers to different types are never aliased.
                allptrs
                     Pointers are never aliased.
                addrtaken
                     Variables are disjoint from pointers unless
                     their address are taken.

                The default is -qnoassert.

         -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:
                          0    Direct-mapped cache
                          1    Fully associative cache
                          (number > 1)   n-way set associative
                          cache
                auto
                     Automatically detects the specific cache
                     configuration of the compiling machine. This
                     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 the level of cache affected, where
                     level is one of the following:
                          1     Basic cache
                          2     Level-2 cache or, if there is no
                                level-2 cache, the table lookaside
                                buffer (TLB)
                          3     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:
                     C or c = Combined data and instruction cache
                     D or d = Data cache
                     I or i = Instruction cache

                The -qtune setting determines the optimal default
                -qcache settings for most typical compilations.

         -qcompact | -qnocompact
                Reduces code size where possible, at the expense of
                execution speed. Code size is reduced by inhibiting
                optimizations that replicate or expand code inline.
                This option takes effect only if -O2 or higher is
                also used.  The default is -qnocompact.

         -qdataimported[=<names_list>]
                Specifies which data items are imported. If no
                names are specified, all data items are assumed to
                be imported.  <names_list> is a colon-separated
                list of data items.

         -qdatalocal[=<names_list>]
                Specifying -qdatalocal=<names_list> marks the named
                variables as local, where <names_list> is a colon-
                separated list of identifiers. Specifying
                -qdatalocal with no variables instructs the
                compiler to assume that all variables are local.
                (C++) Variable names must be specified using their
                mangled names.

         -qdirectstorage | -qnodirectstorage
                Informs the compiler that write-through-enabled or
                cache-inhibited storage may be referenced.  The
                default is -qnodirectstorage.

         -qeh[={v5|v6}] | -qnoeh
                (C++) Controls whether exception handling is
                enabled in the module being compiled.

                v5
                     Instructs the compiler to generate exception-
                     handling code that is compatible with
                     VisualAge C++ V5.0.
                v6
                     Instructs the compiler to generate new
                     exception-handling code, compatible with
                     VisualAge C++ V6.0, that correctly handles
                     try-catch blocks nested within other catch
                     blocks.

                The default is -qeh. Specifying -qeh without a
                suboption is the same as -qeh=v5.

         -qfdpr | -qnofdpr
                Collects information about programs for use with
                the AIX fdpr (Feedback Directed Program
                Restructuring) performance-tuning utility.  The
                default is -qnofdpr.

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

                arraypad[=<n>]
                     When <n> is specified, the compiler will pad
                     every array in the code. The pad amount must
                     be a positive integer value.  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.
                     At level=1, full high-order transformation is
                     performed, but at level=0 only a subset of the
                     high-order transformations are performed,
                     which reduces compile time. -qhot=level=1 will
                     be equivalent to -qhot and the compiler
                     options that imply -qhot also imply
                     -qhot=level=1 unless -qhot=level=0 is
                     explicitly specified. See the Compiler
                     Reference for more information.
                simd | nosimd
                     The compiler converts certain operations that
                     are performed in a loop on successive elements
                     of an array into a call to a VMX (Vector
                     Multimedia Extension) instruction. This
                     suboption has effect only when the effective
                     architecture supports VMX instructions and you
                     specify -qenablevmx.
                vector | novector
                     When specified with -qnostrict and -qignerrno,
                     or an optimization level of -O3 or higher, the
                     compiler converts certain operations that are
                     performed in a loop on successive elements of
                     an array (for example, square root, reciprocal
                     square root) into a call to a Mathematical
                     Acceleration Subsystem (MASS) library vector
                     routine. This call will calculate several
                     results at one time, which is faster than
                     calculating each result sequentially.

                The default is -qnohot.

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

         -qinline[<suboption>] | -qnoinline
                Specifies whether to attempt to inline functions
                instead of generating calls to a function.

                (C++) For C++, you cannot specify any suboptions.
                -qinline specifies that all appropriate functions
                should be inlined, and -qnoinline specifies that no
                functions should be inlined.

                (C) In C, this option can take the following forms:

                -qinline
                     The compiler attempts to inline all
                     appropriate functions with 20 executable
                     source statements or fewer, subject to any
                     other settings of the suboptions to the
                     -qinline option.
                -qinline=threshold=<num>
                     Sets a size limit on the functions to be
                     inlined. The number of executable statements
                     must be less than or equal to <num> for the
                     function to be inlined. <num> must be a
                     positive integer.
                -qinline+<names_list>
                     Attempts to inline the functions listed in
                     <names_list> and any other appropriate
                     functions, where <names_list> is a colon-
                     separated list.
                -qinline-<names_list>
                     Specifies that functions listed in
                     <names_list> do not get inlined, where
                     <names_list> is a colon-separated list.
                -qnoinline
                     Does not inline any functions.

                The default is to treat inline specifications as a
                hint to the compiler, and the result depends on
                other options that you select:  If you specify the
                -g option (to generate debug information), inlining
                may be affected.

         -qipa[=<suboptions_list>] | -qnoipa
                Turns on or customizes a class of optimizations
                known as interprocedural analysis (IPA).  Regular
                expressions are supported when specifying procedure
                names for these suboptions:  cloneproc,
                nocloneproc, exits, inline, noinline, isolated,
                lowfreq, pure, safe, unknown. (C++) Please note
                that procedure names must be given in mangled form.
                <suboptions_list> is a colon-separated list of one
                or more of the following suboptions:

                clonearch=<architecture_list> | noclonearch
                     Allows you to specify a group of architectures
                     in case you want to compile your application
                     for multiple architectures with a single
                     binary file. <architecture_list> is a comma-
                     separated list of one or more of the following
                     architectures: pwr4, pwr5, and ppc970. When
                     -qcompact is in effect, -qarch=clonearch is
                     disabled. This must be specified during link
                     time.  The default is -qipa=noclonearch.
                cloneproc=<names_list> | nocloneproc=<names_list>
                     Allows you to explicitly declare which
                     procedures the compiler should attempt to
                     clone. <names_list> is a comma-separated list
                     of functions that you wish to clone (or not
                     clone). Please note that this suboption has no
                     effect unless -qipa=clonearch=<arch> is
                     specified.
                exits=<procedure_names_list>
                     Specifies names of functions which represent
                     program exits.  <procedure_names_list> is a
                     comma-separated list of procedures.
                infrequentlabel=<names_list>
                     Specifies a comma-separated list of user-
                     defined labels that are likely to be called
                     infrequently during a program run.
                inline[=<suboption>]
                     Specifying 'inline' with no suboption asserts
                     that all appropriate procedures will be
                     inlined. <suboption> can be one of the
                     following:
                     auto | noauto
                          Specifies whether or not to automatically
                          inline procedures.
                     <procedure_names_list>
                          Specifies a comma-separated list of
                          procedures to attempt to inline.
                     threshold=<num>
                          Specifies the upper size limit on
                          procedures to inline. This only takes
                          effect when inline=auto is on.
                     <options_list>
                          The same as specifying
                          -qinline=<options_list>. <options_list>
                          is a comma-separated list of any
                          suboptions that belong to the -qinline
                          compiler option.
                noinline=<procedures_list>
                     Specifies a comma-separated list of procedures
                     which are not to be inlined.
                isolated=<procedure_names_list>
                     Specifies a comma-separated list of procedures
                     that are not compiled with -qipa and that 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 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.
                     The default is 1.
                list[={<filename>|short|long}]
                     Specifies an output listing file name during
                     the link phase, if an object listing has been
                     requested using the -qlist option. 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. The
                     default is 'short'.
                lowfreq=<procedure_names_list>
                     Specifies a comma-separated list of procedures
                     that are likely to be called infrequently
                     during the course of a typical program run.
                malloc16 | nomalloc16
                     Instructs the compiler to assume that the
                     dynamic memory allocation routines (such as
                     malloc/calloc/realloc/new) will return 16-byte
                     aligned memory addresses. The compiler will
                     optimize based on this assumption. Note that
                     if the assertion is false, incorrect results
                     may be generated.  The default is 'malloc16'
                     in 64-bit mode, and 'nomalloc16' otherwise.
                missing={unknown|safe|isolated|pure}
                     Specifies the default assumption for
                     procedures 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.
                object | noobject
                     This is a compile-time option. It 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.
                pdfname[=<filename>] | nopdfname
                     Specifies the name of the profile data file
                     containing the PDF profiling information.  If
                     you do not specify <filename>, the default
                     file name is ._pdf.
                pure=<procedure_names_list>
                     Specifies a comma-separated list of procedures
                     not compiled with -qipa and that are
                     "isolated", "safe", and do not modify any data
                     objects that are visible to the caller.
                safe=<procedure_names_list>
                     Specifies a comma-separated list of procedures
                     not compiled with -qipa and that do not call
                     any other part of the program.
                threads[=<n>] | nothreads
                     Specifies the number of threads for the
                     compiler to use. When <n> is not specified,
                     the compiler decides the number of threads.
                     Otherwise, up to <n> threads are used to
                     invoke the compiler backend. Specifying
                     'nothreads' is equivalent to running one
                     serial process.
                unknown=<procedure_names_list>
                     Specifies a comma-separated list of procedures
                     that are not compiled with -qipa and that may
                     update global variables and dummy arguments
                     and call other parts of the program compiled
                     with -qipa.
                <filename>
                     Specifies the name of a file that contains
                     suboption information in a special format.

                The default is -qnoipa.

         -qisolated_call=<function_names_list>
                Specifies functions in the source file that have no
                side effects, where <function_names> is a colon-
                separated list of function names.

         -qkeepinlines | -qnokeepinlines
                (C++) Instructs the compiler to keep or discard
                definitions for unreferenced extern inline
                functions. Discarding these definitions can reduce
                the size of the object files. The -qkeepinlines
                setting keeps the definitions of unreferenced
                extern inline functions.  The default is
                -qnokeepinlines.

         -qlargepage | -qnolargepage
                Exploits large page heaps that are available on
                Power 4 and Power 5 systems running AIX v5.1D or
                later.  The default is -qnolargepage.

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

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

         -qpdf1 | -qnopdf1
                Produces an object that is instrumented to collect
                runtime execution information. This is phase 1 of
                the profile-directed feedback optimization process.
                The default is -qnopdf1.

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

         -qprefetch | -qnoprefetch
                Enables generation of prefetching instructions such
                as dcbt and dcbz in compiled code.  The default is
                -qprefetch.

         -qprocimported[=<names_list>] | -qnoprocimported
                If no <names_list> is specified, it asserts that
                all functions are imported. Otherwise, only the
                named functions are marked as imported.
                <names_list> is a colon-separated list of function
                identifiers.  (C++) In C++ programs, function names
                must be specified using their mangled names.

         -qproclocal[=<names_list>] | -qnoproclocal
                If no <names_list> is specified, it asserts that
                all functions are local. Otherwise, only the named
                functions are marked as local. <names_list> is a
                colon-separated list of function identifiers.
                (C++) In C++ programs, function names must be
                specified using their mangled names.

         -qprocunknown[=<names_list>] | -qnoprocunknown
                If no <names_list> is specified, it asserts that
                all functions are unknown. Otherwise, only the
                named functions are marked as unknown. <names_list>
                is a colon-separated list of function identifiers.
                (C++) In C++ programs, function names must be
                specified using their mangled names.

         -qshowpdf | -qnoshowpdf
                Used with -qpdf1 and a minimum optimization level
                of -O to add additional call and block count
                profiling information to an executable.  The
                default is -qnoshowpdf.

         -qsmallstack | -qnosmallstack
                Reduces the size of the stack frame.  This option
                is only valid when used together with IPA (-qipa,
                -O4, -O5 compiler options).  The default is
                -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 IBM SMP or OpenMP directives
                     is optimized.
                explicit | noexplicit
                     Enables explicit parallelization of loops.
                nested_par | nonested_par
                     Enables parallelization of nested parallel
                     constructs.
                omp | noomp
                     Enables strict OpenMP compliance. Only OpenMP
                     parallelization pragmas are recognized.
                opt | noopt
                     Enables automatic parallelization but disables
                     optimization of parallelized program code. If
                     noopt is specified, optimization of
                     parallelized program code is disabled.
                rec_locks | norec_locks
                     Specifies whether to use recursive 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:
                     dynamic[=<num>]
                     guided[=<num>]
                     static[=<num>]
                     affinity[=<num>]
                     runtime

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

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

         -qstrict | -qnostrict
                Turns off aggressive optimizations which have the
                potential to alter the semantics of your program.
                -qstrict sets -qfloat=nofltint:norsqrt. -qnostrict
                sets -qfloat=rsqrt. This option is only valid with
                -O2 or higher optimization levels. The default is
                -qnostrict at -O3 or higher, and -qstrict
                otherwise.

         -qstrict_induction | -qnostrict_induction
                Turns off loop induction variable optimizations
                that have the potential to alter the semantics of
                your program.  The default is -qnostrict_induction
                at -O2 or higher and -qstrict_induction otherwise.

         -qtocdata | -qnotocdata
                Marks data as local.  The default is -qnotocdata.

         -qtocmerge | -qnotocmerge
                Reads from the file specified in -bImportfile
                linker option and merges the address information to
                access ranges of external addresses using a single
                table of contents entry.  The default is
                -qnotocmerge.

         -qtune=<suboption>
                Specifies the architecture system for which the
                executable program is optimized.  The suboptions
                are:

                auto
                     Generates object code optimized for the
                     hardware platform on which the program is
                     compiled.
                403
                     Generates object code optimized for all the
                     PowerPC 403 processors.
                601
                     Generates object code optimized for all the
                     PowerPC 601 processors.
                602
                     Generates object code optimized for all the
                     PowerPC 602 processors.
                603
                     Generates object code optimized for all the
                     PowerPC 603 processors.
                604
                     Generates object code optimized for all the
                     PowerPC 604 processors.
                p2sc
                     Generates object code optimized for all the
                     PowerPC P2SC processors.
                ppc
                     Generates object code optimized for 32-bit
                     POWERPC hardware platform.
                ppc970
                     Generates instructions specific to PowerPC 970
                     processors.
                pwr
                     Generates object code optimized for the POWER
                     hardware platforms.
                pwr2
                     Generates object code optimized for the POWER2
                     hardware platform.
                pwr2s
                     Generates object code optimized for the POWER2
                     hardware platform, avoiding certain
                     quadruple-precision instructions that would
                     slow program performance.
                pwr3
                     Generates object code optimized for the POWER3
                     processor.
                pwr4
                     Generates object code optimized for the POWER4
                     processor.
                pwr5
                     Generates object code optimized for the POWER5
                     hardware platforms.
                rs64I
                     Generates object code optimized for the rs64a
                     processor.
                rs64b
                     Generates object code optimized for the RS64II
                     processor.
                rs64c
                     Generates object code optimized for the
                     RS64III processor.

                The default setting is determined by the setting of
                -qarch.

         -qunroll[={yes|no|auto}] | -qnounroll
                Unrolls inner loops in the program. This can help
                improve program performance.  The options are:

                yes
                     Is a suggestion to the compiler to unroll
                     loops.
                no
                     Instructs the compiler not to unroll loops.
                auto
                     Leaves the decision to unroll loops to the
                     compiler.

                The default is -qunroll=auto.  If -qunroll is
                specified with no suboptions, the compiler assumes
                -qunroll=yes.

         -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 non-volatile register saves and restores.  The
                default is -qunwind.

         -qvecnvol | -qnovecnvol
                Specifies whether to use volatile or non-volatile
                vector registers. Volatile vector registers are
                registers whose value is not preserved across
                function calls or in the context of save, jump or
                switch system library functions. If -qnoenablevmx
                is in effect, this option is ignored.  The default
                is -qnovecnvol.

  Error Checking and Debugging Options
         -g     Generates information for debugging tools such as
                the IBM Debugger for AIX, Version 3.1.

         -p     Sets up the object files produced by the compiler
                for profiling.

         -pg    Sets up the object files for profiling, but
                provides more information than is provided by the
                -p option.

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

                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.
                all
                     Switches on all the above suboptions.

                The default is -qnocheck.

         -qdbxextra | -qnodbxextra
                (C) Specifies that all typedef declarations,
                struct, union, and enum type definitions are
                included for debugging.  Use this option with the
                -g option to produce additional debugging
                information for use with a debugger.  The default
                is -qnodbxextra.

         -qdpcl | -qnodpcl
                Generates symbols that can be used by tools based
                on the Dynamic Probe Class Library (DPCL) to see
                the structure of an executable file.  The default
                is -qnodpcl.

         -qextchk | -qnoextchk
                Generates bind-time type-checking information and
                checks for compile-time consistency.  The default
                is -qnoextchk.

         -qfullpath | -qnofullpath
                Specifies the path information stored for files
                when you use the -g compiler option.  The default
                is -qnofullpath.

         -qgenproto[=parmnames] | -qnogenproto
                (C) Produces ANSI prototypes from K&R function
                definitions.  Specifying -qgenproto without
                '=parmnames' will cause prototypes to be generated
                without parameter names.  The default is
                -qnogenproto.

         -qheapdebug | -qnoheapdebug
                Enables debug versions of memory management
                functions.  The default is -qnoheapdebug.

         -qinitauto=<hex_value> | -qnoinitauto
                Initializes automatic variables to the two-digit
                hexadecimal byte value <hex_value>. This generates
                extra code and should only be used for error
                determination.  The default is -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. The
                default is -qnokeepparm.

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

         -qmaxerr=<num>[:<sev>] | -qnomaxerr
                Instructs the compiler to halt compilation when the
                specified number of errors of the specified
                severity (by default, the value of -qhalt) or
                greater is reached.  <num> must be an integer. The
                severity levels, <sev>, are:

                i = informational
                w = warning
                e = error (C only)
                s = severe error

                The default is -qnomaxerr.

         -qproto | -qnoproto
                (C) Assumes that all functions are prototyped.
                Asserts that procedure call points agree with their
                declarations even if the procedure has not been
                prototyped. This allows the caller to pass
                floating-point arguments in floating-point
                registers instead of general-purpose registers.
                The default is -qnoproto.

         -qspnans | -qnospnans
                This option is obsolete. Use -qfloat=nans in your
                new applications. Generates extra instructions to
                detect signalling NaN on conversion from single
                precision to double precision. The -qnospnans
                option specifies that this conversion need not be
                detected. The default is -qnospnans.

         -qsymtab={unref|static}
                (C) Determines what types of information appear in
                the symbol table.  The suboptions are:

                unref
                     Specifies that all typedef declarations,
                     struct, union, and enum type definitions are
                     included for processing by the debugger.
                static
                     Adds user-defined, non-external names that
                     have a persistent storage class (such as
                     initialized and uninitialized static
                     variables) to the name list.

                The default is to not add static variables to the
                symbol table.

         -qtbtable=<option>
                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.  The options
                are:

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

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

  Listing and Message Options
         -V     Instructs the compiler to report information on the
                progress of the compilation, and names the programs
                being invoked within the compiler and the options
                being specified to each program. Information is
                displayed in a space-separated list.

         -v     Instructs the compiler to report information on the
                progress of the compilation, and names the programs
                being invoked within the compiler and the options
                being specified to each program. Information is
                displayed in a comma-separated list.

         -w     Suppresses warnings and lower-level messages.
                Specifying this option is equivalent to specifying
                -qflag=e:e.

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

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

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

                i = information
                w = warning
                e = error
                s = severe error
                u = unrecoverable error

                The default is -qflag=i:i.

         -qformat=<options_list> | -qnoformat
                Warns of possible problems with string input and
                output format specifications. Functions diagnosed
                are printf, scanf, strftime, strfmon family
                functions and functions marked with format
                attributes. <options_list> is a comma-separated
                list of one or more of the following suboptions:

                all | noall
                     Turns on all format diagnostic messages.
                exarg | noexarg
                     Warns if excess arguments appear in printf and
                     scanf style function calls.
                nlt | nonlt
                     Warns if a format string is not a string
                     literal, unless the format function takes its
                     format arguments as a va_list.
                sec | nosec
                     Warns of possible security problems in use of
                     format functions.
                y2k | noy2k
                     Warns of strftime formats that produce a 2-
                     digit year.
                zln | nozln
                     Warns of zero-length formats.

                The default is -qnoformat, which is equivalent to
                -qformat=noall. If -qformat is specified without
                any suboptions, the default is -qformat=all.

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

                i = information
                w = warning
                e = error
                s = severe error
                u = unrecoverable error

                -qhalt=u and -qhalt=e apply only to C compilations.
                (C) The default is -qhalt=e.
                (C++) The default is -qhalt=s.

         -qhaltonmsg=<msgnum_list>
                (C++) Stops the compiler after the compilation
                phase where it encounters the specified message
                number(s), where <msgnum_list> is a comma-separated
                list of message numbers.

         -qinfo[=[<suboption>][<groups_list>]] | -qnoinfo
                Produces informational messages. <groups_list> is a
                colon-separated list. If a <groups_list> is
                specified along with a <suboption>, a colon must
                separate them. The suboptions are:

                all | noall
                     Specifying 'all' in (C) turns on all
                     diagnostic messages for all groups, and in
                     (C++) turns on all diagnostic messages for all
                     groups except ppt.  Specifying 'noall' turns
                     off all diagnostic messages for specific
                     portions of your program.
                private
                     Lists shared variables that are made private
                     to a parallel loop.
                reduction
                     Lists variables that are recognized as
                     reduction variables inside a parallel loop.

                Also:
                <groups_list>
                     Turns on or off specific groups of messages,
                     where <groups_list> is a colon-separated list
                     of one or more of the following:

                     c99 | noc99
                          C code that might behave differently
                          between C89 and C99 language levels
                     cls | nocls
                          C++ classes
                     cmp | nocmp
                          Possible redundancies in unsigned
                          comparisons
                     cnd | nocnd
                          Possible redundancies or problems in
                          conditional expressions
                     cns | nocns
                          Operations involving constants
                     cnv | nocnv
                          Conversions
                     dcl | nodcl
                          Consistency of declarations
                     eff | noeff
                          Statements and pragmas with no effect
                     enu | noenu
                          Consistency of enum variables
                     ext | noext
                          Unused external definitions
                     gen | nogen
                          General diagnostic messages
                     gnr | nognr
                          Generation of temporary variables
                     got | nogot
                          Use of goto statements
                     ini | noini
                          Possible problems with initialization
                     inl | noinl
                          Functions not inlined
                     lan | nolan
                          Language level effects
                     obs | noobs
                          Obsolete features
                     ord | noord
                          Unspecified order of evaluation
                     par | nopar
                          Unused parameters
                     por | nopor
                          Non-portable language constructs
                     ppc | noppc
                          Possible problems with using the
                          preprocessor
                     ppt | noppt
                          Trace of preprocessor actions
                     pro | nopro
                          Missing function prototypes
                     rea | norea
                          Code that cannot be reached
                     ret | noret
                          Consistency of return statements
                     trd | notrd
                          Possible truncation or loss of data or
                          precision
                     tru | notru
                          Variable names truncated by the compiler
                     trx | notrx
                          Rounding of hexadecimal floating-point
                          constants
                     uni | nouni
                          Uninitialized variables
                     upg | noupg
                          Upgrade issues from one release to the
                          next release
                     use | nouse
                          Unused auto and static variables
                     vft | novft
                          (C++) Generation of virtual function
                          tables in C++ programs
                     zea | nozea
                          Zero-extent arrays

                (C) The default is -qnoinfo.
                (C++) The default is -qinfo=lan:trx.
                If -qinfo is specified with no suboptions, the
                defaults are:
                (C) -qinfo=all
                (C++) -qinfo=all:noppt

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

         -qlistopt | -qnolistopt
                Produces a compiler listing that displays all the
                options that were in effect when the compiler was
                invoked.  The default is -qnolistopt.

         -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.  The default is
                -qnophsinfo.

         -qprint | -qnoprint
                Enables or suppresses listings. Specifying
                -qnoprint overrides all listing-producing options,
                regardless of where they are specified, to suppress
                listings.  The default is -qprint.

         -qreport | -qnoreport
                Instructs the compiler to produce transformation
                reports that show how program loops are
                parallelized and/or optimized. The transformation
                reports are included as part of the compiler
                listing.  This option requires either -qhot, -qsmp,
                or -qipa=clonearch in order to have effect.  The
                default is -qnoreport.

         -qshowinc[=<types_list>] | -qnoshowinc
                Used with -qsource to selectively show user header
                files (includes using " ") or system header files
                (includes using < >) in the program source listing.
                <types_list> is a colon-separated list of one or
                more of the following types:

                usr | nousr
                     Specifies whether to show user include files
                sys | nosys
                     Specifies whether to show system include files
                all
                     Shows both user and system include files

                The default is -qnoshowinc.

         -qsource | -qnosource
                Produces a compiler listing and includes source
                code.  The default is -qnosource.

         -qsrcmsg | -qnosrcmsg
                (C) Adds the corresponding source code lines to the
                diagnostic messages in the stderr file.  The
                default is -qnosrcmsg.

         -qsuppress[=<msg_list>] | -qnosuppress=<msg_list>*
                Prevents the specified compiler or driver
                informational or warning messages from being
                displayed or added to the listings, where
                <msg_list> is a colon-separated list of message
                numbers to suppress or display.

                NOTE: In (C++), -qnosuppress requires that you
                supply message number(s), and in (C), -qnosuppress
                does not allow you to supply any.  The default is
                -qnosuppress.

         -qtabsize=<size>
                Changes the length of tabs as perceived by the
                compiler, where <size> is the number of character
                spaces representing a tab in the source program.
                The default is -qtabsize=8.

         -qversion
                Displays information on the compiler version. It
                will output (to STDOUT) the official compiler
                product name and the compiler version found on the
                system. You can specify -qversion outside of a
                compilation (xlC -qversion) or as part of a
                compilation, but compilation will not occur.

         -qwarnfourcharconsts | -qnowarnfourcharconsts
                Issues diagnostic messages when the compiler finds
                four-character constants in the program source.
                The default is -qnowarnfourcharconsts.

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

  Compatibility Options
         -qoldpassbyvalue | -qnooldpassbyvalue
                (C++) Specifies how classes containing const or
                reference members are passed in function arguments.
                All classes in the compilation unit are affected by
                this option. When -qoldpassbyvalue is specified,
                the compiler mimics the IBM C/C++ compilers v3.6
                compiler in that when a class containing a const or
                reference member is passed as a function argument,
                it is not passed by value. All such classes in the
                compilation unit are affected.  The default is
                -qnooldpassbyvalue.

  Linking Options
         -b{dynamic|shared|static}
                Controls how shared objects are processed by the
                linkage editor.  The suboptions are:

                dynamic, shared
                     Causes the linker to process subsequent shared
                     objects in dynamic mode. This is the default.
                     In dynamic mode, shared objects are not
                     statically included in the output file.
                     Instead, the shared objects are listed in the
                     loader section of the output file.
                static
                     Causes the linker to process subsequent shared
                     objects in static mode. In static mode, shared
                     objects are statically linked in the output
                     file.

         -bmaxdata=<num>
                Sets the maximum size of the area shared by the
                static data (both initialized and uninitialized)
                and the heap to <num> bytes. This value is used by
                the system loader to set the soft ulimit. The
                default is -bmaxdata=0.

         -brtl  Enables runtime linking for the output file. Do not
                specify the -brtl compiler option if you are
                invoking the compiler with xlc_r4 or xlC_r4, or if
                the -qheapdebug compiler option is specified.

         -e <name>
                Sets the entry name for a shared executable.  This
                option is only used together with -qmkshrobj.

         -f<filename>
                Names a file to store a list of object files for
                the compiler to pass to the linker. The <filename>
                file should contain only the names of object files.
                There should be one object file per line.

         -G     Tells the linkage editor to create a shared object
                enabled for runtime linking.

         -L<dir>
                Searches the path directory for library files
                specified by the -l<key> option.  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. The default is to search only some of the
                compiler runtime libraries.

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

         -Z<prefix>
                This linker option specifies a prefix for the
                library search path. This is useful when developing
                a new version of a library.

         -qinlglue | -qnoinlglue
                Generates fast external linkage by inlining the
                pointer glue code necessary to make a call to an
                external function or a call through a function
                pointer.  The default is -qnoinlglue.

         -qmkshrobj[=<num>]
                Creates a shared object from the generated object
                files.  The optional number specifies the priority
                level for initialization of all static objects in
                the file. <num> may be any number from -214782623
                (highest priority-initialized first) to 214783647
                (lowest priority-initialized last). If no priority
                is specified the default priority of 0 is used. The
                priority is not used when linking shared objects
                (using the xlc command) written in C.

         -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 -2147482623
                (highest priority) to 2147483647 (lowest priority).
                The default is -qpriority=0.

         -qtwolink | -qnotwolink
                (C++) Links twice in order to minimize the number
                of static constructors included from libraries and
                object files.  The default is -qnotwolink.

  Compiler Customization Options
         -B[<prefix>]
                Determines substitute path names for programs used
                during compilation, such as the compiler,
                assembler, linkage editor, and preprocessor, where
                <prefix> can be 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 folder name.

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

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

                a = assembler
                b = compiler back end
                c = compiler front end
                I = interprocedural analysis tool - compile phase
                L = interprocedural analysis tool - link phase
                l = linkage editor
                E = CreateExportList utility
                m = (C++) linkage helper
                p = compiler preprocessor

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

                a = assembler
                b = compiler back end
                c = compiler front end
                I = interprocedural analysis tool - compile phase
                L = interprocedural analysis tool - link phase
                l = linkage editor
                m = (C++) linkage helper
                p = compiler preprocessor

         -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. Please note that single quotes
                (or double quotes) are required around the string
                of arguments if any spaces exist.

         -qexpfile=<filename>
                Saves the exported symbols in the specified file.
                This option is used only together with the
                -qmkshrobj compiler option.  For more information,
                see -qmkshrobj.

         -qmaxmem=<num>
                Limits the amount of memory used by certain
                memory-intensive optimizations to <num> kilobytes.
                When <num> is -1, the optimizer will use as much
                memory as needed.  By default -qmaxmem=8192 when
                -O2 level optimization is in effect and -qmaxmem=-1
                when -O3 level or greater optimization is in
                effect.

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

                a = assembler
                b = compiler backend
                c = compiler frontend
                E = (C++) CreateExportList utility
                I = interprocedural analysis - compile phase
                L = interprocedural analysis - link phase
                l = linkage editor
                m = (C++) linkage helper
                p = compiler preprocessor

         -qtempinc[=<directory>] | -qnotempinc
                (C++) Generates separate template include files for
                template functions and class declarations, and
                places these files in a directory which can be
                optionally specified.  The default is -qtempinc.

         -qtemplaterecompile | -qnotemplaterecompile
                (C++) Helps manage dependencies between compilation
                units that have been compiled using the
                -qtemplateregistry compiler option.  The default is
                -qtemplaterecompile.

         -qtemplateregistry[=<filename>] | -qnotemplateregistry
                (C++) Maintains records of all templates as they
                are encountered in the source and ensures that only
                one instantiation of each template is made.  The
                default is -qnotemplateregistry.

         -qtempmax=<number>
                (C++) Specifies the maximum number of template
                include files to be generated by the -qtempinc
                option for each header file.  The default is
                -qtempmax=1.

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

                global-dynamic
                initial-exec
                local-exec
                local-dynamic

                If the -qnopic compiler option is in effect, the
                default is initial_exec.  If the -qpic compiler
                option is in effect, the default is global_dynamic.

         -qtmplinst=<suboption>
                Allows you to manage implicit template
                instantiations. <suboption> is one of the
                following:

                none
                     Instantiate only the inline functions. If this
                     is specified, -qtempinc and -qtemplateregistry
                     are ignored.
                noinline
                     Dont perform any implicit instantiations.
                auto
                     Handle the implicit instantiations according
                     to the -qtempinc and -qtemplateregistry
                     options. If both options are off, then
                     implicit instantiations are always performed.
                always
                     Always perform implicit instantiations. This
                     will ignore the -qtempinc and
                     -qtemplateregistry options.

                The default is -qtmplinst=auto.

         -qtmplparse=<option>
                (C++) Controls whether parsing and semantic
                checking are applied to template definition
                implementations or only to template instantiations.
                The compiler has the option to produce warning or
                error messages. The suboptions are:

                no
                     Does not parse, to reduce the number of errors
                     issued in code written for previous versions
                     of the compiler.
                warn
                     Parses template definitions and issues warning
                     messages for semantic errors.
                error
                     Treats problems in template definitions as
                     errors, even if the template is not
                     instantiated.

                The default is -qtmplparse=no.

  Integer and Floating-Point Options
         -y<rounding_mode>
                Specifies the compile-time rounding mode of
                constant floating-point expressions, where
                <rounding_mode> is one of the following:

                m = round toward minus infinity
                n = round to the nearest representable number
                p = round toward plus infinity
                z = round toward zero.

                The default is -yn.

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

                emulate | noemulate
                     Emulates the floating-point instructions
                     omitted by the PowerPC 403(TM) processor.
                     Function calls are emitted in place of PowerPC
                     floating-point instructions.  Use this option
                     only in a single-threaded stand-alone
                     environment, targeting the PowerPC 403
                     processor.  Do not use -qfloat=emulate with
                     any of the following invocation commands:
                      * -qarch=pwr, -qarch=pwr2, -qarch=pwrx
                      * -qlongdouble, -qldbl128
                      * xlc128 and xlC128
                fltint | nofltint
                     Speeds up floating-point-to-integer
                     conversions by using faster inline code that
                     does not check for overflows. This suboption
                     must only be used with an optimization option.
                     -qfloat=nofltint checks floating-point-to-
                     integer conversions for out-of-range values.
                fold | nofold
                     Specifies that constant floating-point
                     expressions are to be evaluated at compile
                     time rather than at run time.
                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.
                hssngl | nohssngl
                     The hssngl option specifies that single-
                     precision expressions are rounded only when
                     the results are stored into float memory
                     locations. The nohssngl option specifies that
                     single-precision expressions are rounded after
                     expression evaluation. Using hssngl can
                     improve runtime performance and is safer than
                     using -qfloat=hsflt.
                maf | nomaf
                     Makes floating-point calculations faster and
                     more accurate by using floating-point
                     multiply-add instructions where appropriate.
                nans | nonans
                     Generates extra instructions to detect
                     signalling NaN when converting from single-
                     precision to double-precision at run time. The
                     option nonans specifies that this conversion
                     need not be detected.
                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.
                rndsngl | norndsngl
                     Specifies that the result of each single-
                     precision (float) operation is to be rounded
                     to single precision. -qfloat=norndsngl
                     specifies that rounding to single-precision
                     happens only after full expressions have been
                     evaluated.
                rrm | norrm
                     Prevents floating-point optimizations that are
                     incompatible with runtime rounding to plus and
                     minus infinity modes.
                rsqrt | norsqrt
                     Specifies whether a division by the result of
                     a square root can be replaced with a multiply
                     by the reciprocal of the square root.
                     -qfloat=rsqrt has no effect unless -qignerrno
                     and -qarch=pwr2 are also specified.
                spnans | nospnans
                     Detects signalling NaN on conversion from
                     single-precision to double-precision.

                The default suboptions are: nospnans, norsqrt (at
                -O2 optimization), rsqrt (at -O3 optimization),
                norrm, norndsngl, norelax, nonans, maf, nohssngl,
                nohsflt, fold, nofltint (at -O2 optimization),
                fltint (at -O3 or greater optimization), and
                noemulate.

         -qflttrap[=<suboptions_list>] | -qnoflttrap
                Generates instructions to detect and trap runtime
                floating-point exceptions.  <suboptions_list> is a
                colon-separated list of one or more of the
                following suboptions:

                overflow
                     Generates code to detect and trap floating-
                     point overflow.
                underflow
                     Generates code to detect and trap floating-
                     point underflow.
                zerodivide
                     Generates code to detect and trap floating-
                     point division by zero.
                invalid
                     Generates code to detect and trap floating-
                     point invalid operation exceptions.
                inexact
                     Generates code to detect and trap floating-
                     point inexact exceptions.
                enable
                     Enables the specified exceptions in the
                     prologue of the main program.
                imprecise
                     Generates code for imprecise detection of the
                     specified exceptions. If an exception occurs,
                     it is detected, but the exact location of the
                     exception is not determined.
                nanq | nonanq
                     Generates code to detect and trap NaNQ (Not a
                     Number Quiet) exceptions handled or generated
                     by floating-point operations.


         -qfold | -qnofold
                This option is obsolete. Use -qfloat=fold in your
                new applications. Specifies that constant
                floating-point expressions are to be evaluated at
                compile time.  The default is -qfold.

         -qhsflt | -qnohsflt
                This option is obsolete. Use -qfloat=hsflt in your
                new applications. Speeds up calculations by
                removing range-checking on single-precision float
                results, and on conversions from floating-point to
                integer. -qnohsflt 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.  The default is -qnohsflt.

         -qhssngl | -qnohssngl
                This option is obsolete. Use -qfloat=hssngl in your
                new applications. Specifies that single-precision
                expressions are rounded only when the results are
                stored into float memory locations. -qnohssngl
                specifies that single-precision expressions are
                rounded after expression evaluation.  The default
                is -qnohssngl.

         -qldbl128 | -qnoldbl128
                Specifies whether to increase the long double size
                from 64 to 128 bits. This is equivalent to
                -qlongdouble.  The default is -qnoldbl128.

         -qlongdouble | -qnolongdouble
                Specifies whether to increase the long double size
                from 64 to 128 bits. This is equivalent to
                -qldbl128.  The default is -qnolongdouble.

         -qlonglit | -qnolonglit
                Makes unsuffixed literals into the long type in
                64-bit mode.  The default is -qnolonglit.

         -qlonglong | -qnolonglong
                Allows long long integers.  When compiling with
                xlc, xlc++, xlC or cc the default is -qlonglong.
                When compiling with c89, the default -qnolonglong.

         -qmaf | -qnomaf
                This option affects the precision of floating-point
                intermediate results. This option is obsolete. Use
                -qfloat=maf in your new applications. -qmaf
                specifies whether floating-point multiply-add
                instructions are to be generated. The default is
                -qmaf.

         -qrrm | -qnorrm
                This option is obsolete. Use -qfloat=rrm in your
                new applications. Prevents floating-point
                optimizations that are not compatible with runtime
                rounding to plus and minus infinity modes. The
                default is -qnorrm.

  ENVIRONMENT VARIABLES
         OBJECT_MODE
                Changes the compilation mode behavior, unless
                overridden by configuration file or command-line
                options.

                32
                     32-bit compiler mode.
                64
                     64-bit compiler mode.
                32_64
                     Fatal error and stop, unless an explicit
                     configuration file or command-line compiler-
                     mode setting exists.
                (not set)
                     32-bit compiler mode.
                (anything else)
                     Fatal error and stop, unless an explicit
                     configuration file or command-line compiler-
                     mode setting exists.

         PATH   Specifies the directory search path for the
                executable files of the compiler.

         MANPATH
                Specifies the directory search path for finding
                manual pages.

         OBJECT_MODE
                Specifies the default compilation mode to 32-bit or
                64-bit.

         LANG   Specifies the national language for message and
                help files.

         NLSPATH
                Specifies the path of the message and help files.

         PDFDIR Specifies the directory in which the profile data
                file is created.

         TMPDIR Specifies the directory in which temporary files
                are created. The default is /tmp.

         XLNOCLONEARCH
                Instructs the program to only execute the generic
                code (code that is not versioned for a particular
                architecture).

         XLSMPOPTS
                Sets options for programs using loop
                parallelization.
                e.g. XLSMPOPTS=PARTHDS=4:SCHEDULE=DYNAMIC=5

  SEE ALSO
         c++filt(1), CreateExportList(1), linkxlC(1),
         makeC++SharedLib(1), vacndi(1), vacppndi(1), gxlc(1),
         gxlc++(1), showpdf(1), mergepdf(1), resetpdf(1)
         cleanpdf(1)

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

  COPYRIGHT
         Licensed Materials - Property of IBM

         IBM(R) XL C/C++ Enterprise Edition V8.0 for AIX(R)

         5724-M12

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

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

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