xlc(1)                   IBM XL C Enterprise Edition                   xlc(1)



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

  SYNTAX
  DESCRIPTION
         xlc and related commands compile 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 = C source file
          .i = preprocessed C source file
          .a = archive file
          .o = object file for ld command
          .s = assembler source file

  OPTIONS
         Options can be flag options or keyword options:

  Flag options
         -#     Displays language processing commands but does not invoke them;
                output goes to standard output.

         -B<prefix>
                When used together with -t, constructs alternate
                compiler/assembler/link editor/preprocessor program names.
                <prefix> specifies a direcory path (including the trailing '/')
                to be combined together with the standard program name
                specified by -t.

         -b{dynamic|shared|static}
                Controls how shared objects are processed by the linkage
                editor.  Where options 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.  The default is -bmaxdata=0.

         -brtl  Enables run-time linking for the output file.  DCE thread
                libraries and heap debug libraries are not compatible with run-
                time linking. 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.

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

         -c     Instructs the compiler to pass source files to the compiler
                only.  By specifying this option, the object files are compiled
                but are not sent to the linkage editor.

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

         -E     Instructs the compiler to preprocess the source files, but does
                not compile. Output goes to stdout.

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

         -F[<config_file>][:<stanza>]
                Names an alternative configuration file (.cfg) for the
                compiler.  Where suboptions are:
                config_file
                     Specifies the name of a compiler configuration file.
                stanza
                     Specifies 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.
                You can use -F[<config_file>] to invoke the compiler using the
                defaults specified in a different compiler configuration file.
                You can use -F[:<stanza>] to invoke the compiler using the
                specified stanza.
                You can combine the two to invoke the compiler using a specific
                stanza in an alternate compiler configuration file. But unlike
                the implications of the description, you do not need to specify
                both. It can be any one or both.

         -f<filename>
                Passes to the link editor the name of a file that contains a
                list of input files to be processed.

         -G     Tells the link editor to create a shared object enabled for
                run-time linking.

         -g     Generates information for debugging tools such as the IBM
                Distributed Debugger.

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

         -L<dir>
                At link time, searches the path directory for library files
                specified by the -lkey 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.

         -M     Generates information to be included in a "make" description
                file.  The -M and -qmakedep options are equivalent.

         -ma    Generates inline calls to the "alloca" function as if "#pragma
                alloca" directives were in the source file.

         -O     Optimizes code at a choice of levels during compilation.

         -O2    Same as -O.

         -O3    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
                user's program.  The compiler guards against these
                optimizations at -O2 and the option -qstrict is provided at -O3
                to turn off these aggressive optimizations.

         -O4    This option is the same as -O3, except that it 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 -qhot option.
                Sets the -qipa option.

         -O5    Equivalent to -O4 -qipa=level=2.

         -o<name>
                Names the executable file <name> instead of a.out.  When used
                with the -c option and one source file, names the object file
                <name> instead of filename.o.  If <name> is the name of a
                directory, files generated by the compiler will be placed into
                that directory.

         -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 with a valid C or C++
                filename extension.

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

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

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

         -Q<x>  In (C++) language applications, this option 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.
                In (C) language applications, this option specifies which
                specific functions the compiler should attempt to inline.
                (C++) In the C++ language, the following -Q options apply:
                -Q
                     Compiler inlines all functions that it can.
                -Q!
                     Compiler does not inline any functions.
                (C) In the C language, the following -Q options apply:
                -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>
                     Does not inline functions listed by names. Separate each
                     function name in names with a colon (:). All other
                     appropriate functions are inlined.  The option implies -Q.
                -Q+<names>
                     Attempts to inline the functions listed by names and any
                     other appropriate functions. Each function name in <names>
                     must be separated by a colon (:).  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.

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

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

         -t<x>  Applies the prefix from the -B option to the specified program
                <x>, where <x> can be one or more of the following:

                a = assembler
                b = compiler back end
                c = compiler front end
                I = inter-procedural analysis tool - compile phase
                L = inter-procedural analysis tool - link phase
                l = linkage editor
                p = compiler preprocessor

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

         -V     Instructs the compiler to report information on the progress of
                the compilation, 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<x>,<option1>,<option2>,...
                Gives the specified options to the compiler program <x> where
                <x> can be one of the following:

                a = assembler
                b = compiler back end
                c = compiler front end
                I = inter-procedural analysis tool - compile phase
                L = inter-procedural analysis tool - link phase
                l = linkage editor
                p = compiler preprocessor

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

         -y<x>  Specifies the compile-time rounding of constant floating-point
                expressions, where <x> can be one of the following:

                m = round toward minus infinity
                n = round to the nearest representable number
                p = round toward positive infinity
                z = round toward zero.
                The default is -yn.

         -Z<string>
                Specifies a prefix for the library search path.

  Keyword options
         Keyword options are specified in one of the following ways:

         -q<option>
         -q<option>=<parameter>
         -q<option>=<parameter>:<parameter>

         where <option> is an option name and <parameter> is a parameter value.

         Keyword options with no parameters represent switches that may be
         either on or off. The keyword by itself turns the switch on, and the
         keyword preceded by the letters NO turns the switch off. For example,
         -qLIST tells the compiler to produce a listing and -qNOLIST tells the
         compiler not to produce a listing. If an option that represents a
         switch is set more than once, the compiler uses the last setting.

         Keyword option and parameter names may appear in either UPPER CASE or
         lower case letters in the invocation command.

         -q32   Selects 32-bit compiler mode. This is the default.

         -q64   Selects 64-bit compiler mode.

         -qaggrcopy={overlap|nooverlap}
                Asserts whether source and destination of aggregate assignments
                overlap.  When compiling to the stdc89, extc89, stdc99, extc99,
                saa, and saal2 language levels the default is
                -qaggrcopy=nooverlap.  When compiling to the EXTENDED and
                CLASSIC language levels the default is -qaggrcopy=overlap.

         -qalias=<option>
                Specifies the aliasing assertion to be applied to your
                compilation unit.  The available options are:

                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, pointers can only point to an object
                     of the same type. ansi is the default for the xlc, xlC,
                     and c89 compilers.  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.

         -qalign=<option>
                Specifies what aggregate alignment rules the compiler uses for
                file compilation.  Where available 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.  This is the default.
                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.

         -qalloca
                Treats calls to the function alloca as inline.

         -qansialias | -qnoansialias
                Specifies whether type-based aliasing is to be used during
                optimization. Type-based aliasing restricts the lvalues that
                can be used to access a data object safely.  The default is
                -qansialias.  This option is obsolete. Use -qalias= in your new
                applications.  The default with xlc, xlC, c99 and c89 is
                ansialias.  The optimizer assumes pointers can only point to an
                object of the same type. The default with cc is noansialias.
                This option has no effect unless you also specify the -O
                option.

         -qarch=<option>
                Specifies the general processor architecture for which the code
                (instructions) should be generated.  The available options 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.
                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 platforms
                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 implies -qarch=ppc64.
                ppcgr
                     In 32-bit mode, produces object code for PowerPC
                     processors that support optional graphics instructions.
                ppc64
                     Generates instructions that will run on any of the 64-bit
                     PowerPC hardware platform.
                ppc970
                     Generates instructions that will run on the PPC970 harware
                     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 a pwr2s chip.
                p2sc
                     Generates instructions that will run on a p2sc 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 rs64a chip.
                rs64b
                     Generates instructions that will run on a RS64II chip.
                rs64c
                     Generates instructions that will run on a RS64III chip.

         -qasm=gcc | -qnoasm
                Instructs the compiler to accept assembler language extensions.
                The default is -qnoasm.

         -qasm_as=<invocation_string>
                Specifies the path and flags used to invoke the assembler where
                <invocation_string> is the path and flags used to invoke the
                assembler.

         -qassert=<option> | -qnoassert
                Specifies the aliasing assertion to be applied to your
                compilation unit.  The available options 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.

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

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

         -bmaxdata=<num>
                Sets the maximum size of the area shared by the static data
                (both initialized and uninitialized) and the heap to <num>
                bytes.  The default is -bmaxdata=0.

         -qc_stdinc=<path1>[:<path2>[:...:<pathN>]]

         -qcache=<suboption>[:<suboption>...]
                Describes the cache configuration for a specific target
                execution machine, where available cache optons are:
                assoc=<number>
                     Specifies the set associativity of the cache, where
                     <number> is one of the following:
                          0    Direct-mapped cache
                          1    Fully associative cache
                          N>1  n-way set associative cache
                auto
                     Automatically detects the specific cache configuration of
                     the compiling machine. This assumes that the execution
                     environment will be the same as the compilation
                     environment.
                cost=<cycles>
                     Specifies the performance penalty resulting from a cache
                     miss.
                level=<level>
                     Specifies 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

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

         -qcheck[=<option1>[:<option2>]... ] | -qnocheck
                Generates code that performs certain types of run-time
                checking.  If a violation is encountered, a run-time exception
                is raised by sending a SIGTRAP signal to the process.  Where
                options can be one or more of the following:

                bounds | nobounds
                     Performs run-time checking of addresses when subscripting
                     within an object of known size.
                divzero | nodivzero
                     performs run-time checking of integer division.  A trap
                     will occur if an attempt is made to divide by zero.
                nullptr | nonullptr
                     Performs run-time checking of addresses contained in
                     pointer variables used to reference storage.
                all
                     Switches on all the above suboptions.

                The default is -qnocheck.

         -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 -O or higher is also used.  The default is -qnocompact.

         -qcpluscmt | -qnocpluscmt
                Permits "//" to introduce a comment that lasts until the end of
                the current source line, as in C++.
                -qcpluscmt is implicitly selected when you invoke the compiler
                with xlc, xlc_r.

         -qdataimported[=<name1>[:<name2>] ...]
                Specifies which data items are imported.  If no names are
                specified, all data items are assumed to be imported.  This
                option applies only to 64-bit compilations.

         -qdatalocal[=<name1>[:<name2>] ...]
                User must specify which data items are local.  If no names are
                specified, the linker might fail to link.  Specifying
                -qdatalocal=<name> marks the named variables as local, where
                <name> is a list of identifiers separated by colons (:).
                Variables not explicitly named are not affected.  This option
                applies only to 64-bit compilation.

         -qdbcs | -qnodbcs
                String literals and comments can contain multibyte characters.
                The -qdbcs option is equivalent to -qmbcs.  The default is
                -qnodbcs.

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

         -qdigraph | -qnodigraph
                Allows usage of digraph key combinations or keywords to
                represent characters not found on some keyboards.
                (C) The default is -qnodigraph when -qlanglvl is set to other
                than extc99 or stdc99 and -qdigraph when -qlanglvl is set to
                extc99 or stdc99.
                (C++) The default is -qdigraph.

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

         -qdollar | -qnodollar
                Allows the '$' symbol to be used in the names of identifiers.
                The default is -qnodollar.

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

                small
                     1, 2, 4, or 8 bytes of storage will be allocated for enum
                     variables based on the range of the enum constants.
                     Signage is unsigned, unless the range of values includes
                     negative values.
                int
                     Enumerations occupy 4 bytes and are represented by int.
                intlong
                     Enumerations occupy 8 bytes of storage and are represented
                     by long long if the range of the enum constants exceed the
                     limit for int.  Otherwise, the enumerations occupy 4 bytes
                     of storage and are represented by int.  This is the
                     default.
                1
                     Enumerations occupy 1 byte.  Type is signed or unsigned
                     char.
                2
                     Enumerations occupy 2 bytes.  Type is signed or unsigned
                     short.
                4
                     Enumerations occupy 4 bytes.  Type is signed or unsigned
                     int.
                8
                     Enumerations occupy 8 bytes.  Type is signed or unsigned
                     long long in 32 bit mode, and signed or unsigned long in
                     64-bit mode.
                (C) The default is int.
                (C++) The default is intlong.

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

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

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

         -qflag={i|w|e|s|u}:{i|w|e|s|u}
                Specifies the minimum severity level of diagnostic messages to
                be reported in a listing and displayed on a terminal. The
                diagnostic messages display with their associated sub-messages.
                where message severity levels are: i=information, w=warning,
                e=error, s=severe error, u=unrecoverable error.  The default is
                -qflag=i:i.

         -qfloat=<opt1>[:<opt2>[:...:<optN>]]
                Specifies various floating-point options. These options provide
                different strategies for speeding up or improving the accuracy
                of floating-point calculations.  The available options are:

                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 this
                     suboption with any of the following:
                      * -qarch=pwr, -qarch=pwr2, -qarch=pwrx
                      * -qlongdouble, -qldbl128
                      * xlC128 or xlc128 compiler invocation commands
                     The default is noemulate.
                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.
                     Default at -O2: -qfloat=nofltint is the implied setting.
                     Default at -O3 and greater in effect: -qfloat=fltint.
                     The default is float=nofltint, which 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.  The
                     default is fold.
                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. The default is
                     nohsflt.
                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 run-
                     time performance and is safer than using -qfloat=hsflt.
                     The default is nohssngl.
                maf | nomaf
                     Makes floating-point calculations faster and more accurate
                     by using floating-point multiply-add instructions where
                     appropriate.  The default is maf.
                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.  The default is nonans.
                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.  The default is norndsngl.
                rrm | norrm
                     Specifies run-time rounding mode. Prevents floating-point
                     optimizations that are incompatible with run-time rounding
                     to plus and minus infinity modes.  The default is norrm.
                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.
                     Default at -O2: -qfloat=norsqrt.
                     Default at -O3: -qfloat=rsqrt. Use -qfloat=norsqrt to
                     override this default.
                     -qfloat=rsqrt has no effect unless -qignerrno is also
                     specified.
                spnans | nospnans
                     Detects signalling NaN on conversion from single-precision
                     to double-precision.  The default is nospnans.

         -qflttrap[=<opt1>:...:<optN>] | -qnoflttrap
                Generates instructions to detect and trap run-time floating-
                point exceptions.  The available options are:  overflow,
                underflow, zerodivide, invalid, inexact, enable, imprecise,
                nanq and nonanq.

         -qformat=<option> | -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, where suboptions are:

                all
                     Turns on all format diagnostic messages.
                exarg
                     Warns if excess arguments appear in printf and scanf style
                     function calls.
                nlt
                     Warns if a format string is not a string literal, unless
                     the format function takes its format arguments as a
                     va_list.
                sec
                     Warns of possible security problems in use of format
                     functions.
                y2k
                     Warns of strftime formats that produce a 2-digit year.
                zln
                     Warns of zero-length formats.
                Specifying no in front of any of the above suboptions disables
                that group of diagnostic messages.
                If -qformat is not specified on the command line, the compiler
                assumes a default setting of -qnoformat, which is equivalent to
                -qformat=noall.
                If -qformat is specified on the command line without any
                suboptions, the compiler assumes a default setting of
                -qformat=all.

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

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

         -qgenproto[=<parmnames>] | -qnogenproto
                Produces ANSI prototypes from K&R function definitions.  The
                default is -qnogenproto.

         -qhalt={i|w|e|s|u}
                Stops the compiler after the first phase if the severity of
                errors detected equals or exceeds the specified level.  The
                severity levels in order of increasing severity are:
                i=information, w=warning, e=error, s=sever error,
                u=unrecoverable error.
                Default for C++ compilations is -qhalt=s.
                Default for C compilations is -qhalt=e.
                -qhalt=u and -qhalt=e apply only to C compilations.

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

         -qhot[=<suboption>] | -qnohot
                Specifies whether or not to perform high-order transformations
                on loops and array language during optimization, and whether or
                not to pad array dimensions and data objects to avoid cache
                misses. Suboptions include:

                arraypad
                     The compiler will pad any arrays where it infers there may
                     be a benefit.  Make sure that you have not used
                     equivalence association for any arrays in files compiled
                     with this option as the compiler does not perform any
                     checking before padding arrays.
                arraypad=<n>
                     The compiler will pad every array in the code.  The pad
                     amount must be a positive integer value.
                novector
                     The compiler will avoid replacing code by calls to vector
                     library routines.
                vector
                     Allows the compiler to optimize by replacing code with
                     calls to vector library routines.

                The default is -qnohot.

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

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

         -qignprag=<option>
                Instructs the compiler to ignore certain pragma statements.
                The available 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 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 pragmas.

          -qinfo[={all|noall|private|reduction|<group>}] | -qnoinfo

                Produces informational messages.  The default for (C) is
                -qnoinfo.  The default for (C++) is -qinfo=lan.  Available
                forms of the -qinfo option are:

                all
                     Turns on all diagnostic messages for all groups.
                lan
                     Enables diagnostic messages informing of language level
                     effects.  This is the default for C++ compilations.
                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.

                <group>
                     Turns on or off specific groups of messages, where <group>
                     can be one or more of the following options:

                     c99|noc99
                          C code that might behave differently between C89 and
                          C99 language levels
                     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
                          Nonportable 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
                          Hexadecimal floating point constants rounding
                     uni|nouni
                          Unitialized variables
                     upg|noupg
                          Upgrade issues from one release to the next release
                     use|nouse
                          Unused auto and static variables
                zea|nozea
                     Zero-extent arrays

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

         -qinlglue | -qnoinlglue
                Generates fast external linkage by inlining the code (pointer
                glue code) necessary at calls via a function pointer and calls
                to external procedures.  The default is -qnoinlglue.

         -qinline[=<value>] | -qnoinline
                Attempts to inline functions instead of generating calls to a
                function.

                The following -qinline options apply in the the C++ language:
                -qinline
                     Turns on inlining.
                -qnoinline
                     Turns off inlining.
                The following -qinline options apply in the the C language:
                -qinline
                     Turns on inlining.
                -qnoinline
                     Turns off inlining.
                -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=limit=<num>
                     Specifies the maximum size (in bytes of generated code) to
                     which a function can grow due to inlining.
                -qinline-<names>
                     Does not inline the functions listed in <names>.  Separate
                     each name with a colon (:).
                -qinline+<names>
                     Attempts to inline the functions listed in <names> and any
                     other appropriate functions.  Each name must be separated
                     by a colon (:).
                If you optimize your program using one of the -O compiler
                options, by default the compiler attempts to inline all
                functions declared as inline. Otherwise, the compiler attempts
                to inline only some of the simpler functions declared as
                inline.

         -qipa=<subopt1>[=<val1>][...:<suboptN>[=<valN>]] | -qnoipa
                Turns on or customizes a class of optimizations known as
                interprocedural analysis (IPA).
                Enhances optimization by doing detailed analysis across
                procedures.

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

                Suboptions include:

                exits=<procedure_names>
                     Specifies names of functions which represent program
                     exits.
                      <procedure_names> is a comma-separated list of names.
                inline=<inline-options>
                     The "ipa=inline=" command can take a comma-separated list
                     of inline options, which are as follows:

                     inline={auto|noauto}
                          Specifies whether or not to automatically inline
                          procedures.
                     inline=<procedure_names>
                          Specifies a comma-separated list of procedures to try
                          to inline.
                     inline=limit=<num>
                          Changes the size limits that determine how much
                          inline expansion to do.  <num> is the optimizer's
                          approximation of the number of bytes of code which
                          will be generated.
                     inline=threshold=<num>
                          Specifies the upper size limit on procedures to
                          inline.  <num> is defined as for inline=limit.
                     inline=<suboption>
                          The same as specifying -qinline=<suboption>.
                          Specifies a comma-separated list of functions to try
                          to inline, where functions are identified by name.
                noinline=<procedure_names>
                     Specifies a comma-separated list of procedures which are
                     not to be inlined.
                infrequentlabel=<names>
                     Specifies a comma-separated list of user-defined labels
                     that are likely to be called infrequently during a program
                     run.
                isolated=<procedure_names>
                     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 =
                          Does only minimal interprocedural analysis and
                          optimization.
                     1 =
                          Turns on inlining, limited alias analysis, and
                          limited call-site tailoring.
                     2 =
                          Full interprocedural data flow and alias analysis.
                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". The long and
                     short suboptions can be used to request more or less
                     information in the listing file to determine which listing
                     sections will be included. Short suboption is the default.
                lowfreq=<procedure_names>
                     Specifies a comma-separated list of procedures that are
                     likely to be called infrequently during the course of a
                     typical program run.
                missing={unknown|safe|isolated|pure}
                     Specifies the default assumption for procedures not
                     compiled with -qipa.
                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>
                     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>
                     Specifies a comma-separated list of procedures not
                     compiled with -qipa and that do not call any other part of
                     the program.
                nothreads
                     Single threaded invocation of the compiler backend.
                threads
                     The compiler decides the number of threads to use.
                threads=<n>
                     Up to 'n' threads can be used to invoke the compiler
                     backend.
                unknown=<procedure_names>
                     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=<name1>[:<name2>[:...:<nameN>]]
                Specifies functions in the source file that have no side
                effects.

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

         -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=<suboption>
                Specifies the language level and language-related feature for
                the compilation.  Where values for suboptions can be any of the
                following:

                (C) For C programs, you can use the following -qlanglvl
                suboptions for <suboption>:
                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.
                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++
                     v7.0 for AIX.  This option can be used for all C language
                     levels. The default is -qlanglvl=nocompatzea.  Specifying
                     -qlanglvl=compatzea has effect only if
                     -qlanglvl=zeroextarray is also in effect.
                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.
                zeroextarray | nozeroextarray
                     This option enables support for flexible array members and
                     zero extent arrays.  The default is
                     -qlanglvl=nozeroextarray.

                (C++) For C++ programs, you can specify one or more of the
                following -qlanglvl suboptions for suboption:
                ansi
                     Compilation supports the ANSI/ISO 1998 standard which
                     activates the _cplusplus macro to "199711L".  The 2003
                     standard only adds minor defect changes. We conform to the
                     2003 standard.
                compat366
                     Compilation conforms to some, but not all, IBM C and C++
                     Compilers V 3.6 features.
                strict98
                     Compilation supports the ANSI/ISO 1998 standard which
                     activates the _cplusplus macro to "199711L". The 2003
                     standard only adds minor defect changes. We conform to the
                     2003 standard.
                extended
                     Compilation is based on the ISO C++ Standard, with some
                     differences to accomodate extended language features.
                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 option works in the same way as g++ -fuse-cxa-atexit
                     and is required for fully standards-compliant handling of
                     static destructors.
                c99__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++
                     v7.0 for AIX.  The default is -qlanglvl=nocompatzea.
                     Specifying -qlanglvl=compatzea has effect only if
                     -qlanglvl=zeroextarray is also in effect.
                gnu_assert | nognu_assert
                     GNU C portability option allows you to enable or disable
                     support for the following GNU C system identification
                     assertions:
                gnu_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
                     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 language level varies according to the command you
                use to invoke the compiler:
                Invocation      Default language level
                xlC/xlc++       extended
                xlc             extc89
                cc              extended
                c89             stdc89
                c99             stdc99

         -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

         -qldbl128 | -qnoldbl128
                Increases long double size from 64 to 128 bits.  The default is
                -qnoldbl128.

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

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

         -qlist | -qnolist
                Produces a compiler listing that includes an object listing.
                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.

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

         -qlonglong | -qnolonglong
                Allows long long integers.  The default is -qlonglong.

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

         -qmakedep
                Creates an output file that contains information to be included
                in a "make" description file.  The -qmakedep option is
                functionally identical to the -M option.

         -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 severity is reached.  Where num
                must be an integer. Choices for severity level can be one of
                the following: i=Informational, w=Warning, e=Error(C only),
                s=Severe error.  The default is -qnomaxerr.

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

         -qmbcs | -qnombcs
                String literals and comments can contain multibyte
                characters.The -qmbcs option is equivalent to -qdbcs.  The
                default is -qnombcs.

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

         -qoptimize[=<level>] | -qnooptimize
                Enables different levels of optimization.

                0
                     Same as -qnooptimize.  This is the default.
                2
                     Same as -O and -qoptimize. Considered as the best
                     optimization option for combination of compilation speed
                     and run-time performance.
                3
                     Same as -O3. Aggressive optimization.
                4
                     Same as -O4.  Equivalent to -O3, -qipa=auto, -qhot=auto,
                     -qarch=auto, -qtune=auto and -qcache=auto.
                5
                     Same as -O5.  Equivalent to -O4 -qipa=level=2.

         -qpascal | -qnopascal
                Accepts and ignores the keyword 'pascal' as a type modifier.
                The default is -qnopascal.

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

                a = assembler
                b = compiler backend
                c = compiler frontend
                E = CreateExportList utility
                I = interprocedural analysis - compile phase
                L = interprocedural analysis - link phase
                l = link editor
                p = preprocessor

         -qpdf1 | -qnopdf1
                Produces an object that is instrumented to collect run-time
                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.  Reports the time taken in each compilation phase.
                Phase information is sent to standard output.  The default is
                -qnophsinfo.

         -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
                Table of content 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 the -G or -qmkshrobj
                compiler option is specified.  The default is -qpic=small.

         -qprefetch | -qnoprefetch
                Enables generation of prefetching instructions in compiled
                code.  The default is -qprefetch.

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

         -qprocimported=[<name1>:<name2>: ...] | -qnoprocimported
                Specifies which functions are imported in 64-bit compilations.
                If no filenames are specified, all invoked functions are
                assumed to be defined outside the current file.  The last
                explicit specification for a function takes precedence.

         -qproclocal=[<name1>:<name2>: ...] | -qnoproclocal
                Specifies which functions are local in 64-bit compilations.  If
                no filenames are specified, all invoked functions are assumed
                to be defined within the current file.  The last explicit
                specification for a function takes precedence.

         -qprocunknown=[<name1>:<name2>: ...] | -qnoprocunknown
                Specifies which functions are unknown to be local or imported
                in 64-bit compilations. If no filenames are specified, all
                functions called are assumed to be unknown. This is the default
                when no user options are specified. The last explicit
                specification for a function takes precedence.

         -qproto | -qnoproto
                If set, the compiler 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.

         -qreport | -qnoreport
                Adds information to the listing file on the loop
                transformations that have been carried out.  This option
                requires either -qhot or -qsmp in order to have effect.  The
                default is -qnoreport.

         -qro | -qnoro
                Specifies the storage type for string literals.  Puts string
                literals in read-only storage.  The default for all compiler
                invocations except cc and its derivatives is -qro.  The default
                for the cc compiler invocation is -qnoro.

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

         -qroptr | -qnoroptr
                Specifies the storage location for constant pointers.  The
                default is -qnoroptrs.

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

         -qshowinc[=<types>] | -qnoshowinc
                Used with -qsource to selectively show user header files
                (includes using " ") or system header files (includes using <
                >) in the program source listing.  You can specify the
                following types:

                usr
                     Shows user include files
                nousr
                     Does not show user include files
                sys
                     Shows system include files
                nosys
                     Does not show system include files
                all
                     Shows both user and system include files

                The default is -qnoshowinc.

         -qshowpdf | -qnoshowpdf
                Used together with -qpdf1 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, allowing better use of a
                limited stack size.  This option is only valid when used
                together with IPA (-qipa, -O4, -O5 compiler options).  The
                default is -qnosmallstack.

         -qsmp[=suboption[:suboption] [ ... ]] | -qnosmp
                Controls acceptance of OpenMP directives and automatic
                parallelization. The auto and omp suboptions are opposites.
                i.e. -qsmp=omp means strict adherance to the OpenMP standard
                with no automatic parallelization.

                auto | noauto
                     Enables or disables automatic parallelization and
                     optimization.
                explicit | noexplicit
                     Enables or disables explicit parallelization of loops.
                nested_par | nonested_par
                     Enables or disables parallization of nested parallel
                     constructs.
                omp | noomp
                     Enables or disables strict OpenMP compliance.
                opt | noopt
                     opt is the same as auto.  Enables automatic
                     parallelization but disables optimization of parallelized
                     program code.
                rec_locks | norec_locks
                     Specifies whether recursive or regular locks should be
                     used to implement critical sections.
                schedule=<sched_type>[=<num>]
                     Specifies what kind of scheduling algorithms and chunking
                     are used for loops to which no other scheduling algorithm
                     has been explicitly assigned in the source code.

                     Valid options for <sched_type> are:
                     * dynamic[=<num>]
                     * guided[=<num>]
                     * static[=<num>]
                     * affinity[=<num>]
                     * runtime
                If nothing is specified, the default is -qnosmp.  Specifying
                -qsmp without suboptions is equivalent to specifying:
                -qsmp=auto:explicit:noomp:norec_locks:
                      nonested_par:schedule=runtime
                or
                -qsmp=opt:explicit:noomp:norec_locks:
                      nonested_par:schedule=runtime.

         -qsource | -qnosource
                Produces a compiler listing and includes source code.  Output
                goes to a .lst file.  The default is -qnosource.

         -qsourcetype={default|c|c++|assembler}
                Treats all source files as if they are the source type
                specified by this option, regardless of actual source filename
                suffix or uses the filename suffix to determine the programming
                language. Where: 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.

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

         -qsrcmsg | -qnosrcmsg
                Reconstructs source lines in error along with the diagnostic
                messages in the stderr file.  The default is -qnosrcmsg.

         -qstatsym | -qnostatsym
                Adds user-defined, nonexternal names that have a persistent
                storage class, such as initialized and uninitialized static
                variables, to the name list.  Same as -qsymtab=static.  The
                default is -qnostatsym.

         -qstdinc | -qnostdinc
                Specifies which files are included with the #include
                <file_name> and #include "file_name" directives.  The default
                is -qstdinc.  If -qnostdinc is specified, standard include
                directories are not searched.

         -qstrict | -qnostrict
                Turns off aggressive optimizations which have the potential to
                alter the semantics of a user's 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 a user's program.  The
                default is -qnostrict_induction at -O3 or higher and
                -qstrict_induction otherwise.

         -qsuppress[=<msg_num>:<msg_num>...] | -qnosuppress
                Prevents the specified compiler or driver informational or
                warning messages from being displayed or added to the listings.

         -qsymtab={unref|static}
                Settings for this option determine what information appears in
                the symbol table.  The available options are:

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

         -qsyntaxonly
                Performs syntax checking without generating an object file.

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

         -qtbtable=<option>
                Generates a traceback table for each function and places it in
                the text segment at the end of the function code.

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

         -qthreaded | -qnothreaded
                The program will execute in a multi-threaded environment.  This
                option ensures that all optimizations are thread-safe.  The
                default is -qthreaded when compiling with _r invocation modes,
                and -qnothreaded when compiling with other invocation modes.

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

         -qtrigraph | -qnotrigraph
                Allows trigraph key combinations to represent characters not
                found on some keyboards.  For xlc, xlc_r, cc, cc_r, xlc++,
                xlc++_r, xlC, and xlC_r, the default is -qnotrigraph.  For c89,
                c89_r, c99, and c99_r, the default is -qtrigraph.

         -qtune=<option>
                Specifies the architecture system for which the executable
                program is optimized.  The available options 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.  Use -qfloat=emulate to emulate the floating-
                     point instructions omitted by the 403 processor.
                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 p2sc
                     processors.
                ppc
                     Generates object code optimized for 32-bits POWERPC
                     hardware platform.
                ppc970
                     Generates instructions specific to PowerPC 970 processors.
                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.
                rs64a
                     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.

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

                yes
                     Is a suggestion to the compiler to unroll loops.
                no
                     Instructs the compiler to not unroll loops.
                auto
                     Leaves the decision to unroll loops to the compiler.
                If -qunroll is not specified, the compiler assumes
                -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.

         -qupconv | -qnoupconv
                Preserves the unsigned specification when performing integral
                promotions.  The default is -qnoupconv.

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

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

         -qweaksymbol | -qnoweaksymbol
                Instructs the compiler to generate weak symbols.  The default
                is -qnoweaksymbol.

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

         -qxref[=full] | -qnoxref
                Produces a compiler listing that includes a cross-reference
                listing of all identifiers.  Where: noxref
                     Do not report identifiers in the program.
                xref
                     Reports only those identifiers that are used.
                xref=full
                     Reports all identifiers in the program.
                The default is -qnoxref.

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

         not set
                32-bit compiler mode.

         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.

         any other
                Fatal error and stop, unless an explicit configuration file or
                command-line compiler-mode setting exists.

  SEE ALSO
         vacndi(1), gxlc(1), showpdf(1), mergepdf(1), resetpdf(1) cleanpdf(1)

         You can refer to the following Web sites for more information:
         www.ibm.com/software/awdtools/caix/library/
         www.ibm.com/software/awdtools/caix/support/

  COPYRIGHT
         IBM(R) XL C Enterprise Edition V7.0

         Licensed Materials - Property of IBM

         (C) Copyright IBM Corp. 1991, 2004.   All Rights Reserved.

         IBM is a trademark or registered trademark 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.



  IBM                             September 2004                         xlc(1)