  ppuxlc(1)   IBM XL C/C++ for Multicore Acceleration for Linux, V9.0  ppuxlc(1)



  NAME
         ppuxlc, ppuxlc_r, ppuxlc++, ppuxlc++_r, ppuxlC, ppuxlC_r, ppucc,
         ppucc_r, ppuc89, ppuc89_r, ppuc99, ppuc99_r, ppugxlc, ppugxlc++ and
         ppugxlC commands - Multicore Acceleration for Linux compiler.


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


  DESCRIPTION
         The invocation commands compile C and C++ source files and create
         executables that will run on the PowerPC Processor Unit (PPU).
         The commands and their recommended uses are described below.

         Invocations                   Usage (supported standards)
         _________________________________________________________

         ppuxlc, ppuxlc_r              Compile C source files
                                       (ANSI C89, ISO C99,
                                       IBM language extensions)

         ppuxlc++, ppuxlc++_r,         Compile C++ source files
         ppuxlC, ppuxlC_r

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

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

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

         ppugxlc                       Accepts GNU C options, maps
                                       them to their equivalent XL
                                       C option, then invokes ppuxlc.

         ppugxlc++, ppugxlC            Accepts GNU C/C++ options, maps
                                       them to their equivalent XL
                                       C++ option,then invokes ppuxlc++.

         The main difference between these commands is that they use different
         default options (which are set in the configuration file
         /opt/ibmcmp/xlc/cbe/9.0/etc/vac.cfg).
         See the Compiler Reference for more information on these invocation
         commands.

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

         These commands also process assembler source files and object files.
         The compiler calls the link editor to produce a single executable or
         shared library (available only on the PPU), unless you specify the
         compiler options that prevent object files from being linked.

         The input file may have any of the following suffixes:

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

          .c                 C source file

          .i                 Preprocessed C or C++ source file

          .a                 Archive file

          .o                 Object file for ld command

          .s                 Assembler source file

          .S                 Assembler source file that
                             needs preprocessing

          .so                Shared object file


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

         Keyword options are specified in one of the following ways:
         -q<option>
         -q<option>=<suboption>
         -q<option>=<suboption>:<suboption>

         Keyword options with no suboptions represent switches that may be
         either on or off. -qx turns the switch on, and -qnox turns the switch
         off. For example, -qsource tells the compiler to produce a source
         listing and -qnosource tells the compiler not to produce a source
         listing.

  Output control options
         -c     Instructs the compiler to pass source files to the compiler
                only. The compiled source files are not sent to the linker. This
                option produces an object file, file_name.o, for each valid
                source file.

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

         -E     Instructs the compiler to preprocess the source files, without
                compiling, and write the output to the display.

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

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

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

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

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

                Default: -o a.out

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

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

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

         -qcinc=<directory_path> | -qnocinc
                (C++) Instructs the compiler to place an extern "C" { } wrapper
                around the contents of an include file, where <directory_path>
                is the location of that include file.

                Default: -qnocinc

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

                Default:
                     The following directories are searched, in the following
                     order, after any paths that are specified by the -I option:
                     1) The current directory.
                     2) The directory where the source file is located.
                     3) /usr/include.

         -qidirfirst | -qnoidirfirst
                Specifies the search order for files included with the -I
                option. If -qidirfirst is specified, the directories specified
                by the -I<directory_path> option are searched before the
                directory in which the current file resides.

                Default: -qnoidirfirst

         -qinclude=<file_path>
                Specifies additional header files that are included before the
                first line of a source file in a compilation unit and ahead of
                any headers which may be specified by an #include statement on
                the first line of the source file.

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

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

                Default: -qsourcetype=default

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

                Default: -qstdinc

  Language element control options
         -qaltivec | -qnoaltivec
                Instructs the compiler to support vector data types and
                operators.

                Default: -qaltivec

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

                Default: -qasm=gcc

         -qcpluscmt | -qnocpluscmt
                (C) Permits the usage of "//" to introduce a comment that lasts
                until the end of the current source line, as in C++.

                Default:
                     o -qcpluscmt when you invoke the compiler with ppuxlc,
                     ppuxlc99, ppucc or related commands, or when -qlanglvl is
                     set to stdc99 or extc99
                     o -qnocpluscmt otherwise

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

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

                Default: -qnodbcs

         -qdigraph | -qnodigraph
                Allows usage of digraph key combinations or keywords to
                represent characters not found on some keyboards.

                Default:
                     (C) -qdigraph when -qlanglvl is extc89, extended, extc99 or
                     stdc99, and -qnodigraph otherwise.
                     (C++) -qdigraph

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

                Default: -qnodollar

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

                disjoint
                     Ignores all #pragma disjoint directives in the source file.
                isolated_call
                     Ignores all #pragma isolated_call directives in the source
                     file.
                all
                     Ignores all #pragma isolated_call directives and #pragma
                     disjoint directives in the source file.
                ibm
                     (C) Ignores all #pragma ibm snapshot directives in the
                     source file.

         -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. You cannot add
                keywords to the language with this option. However, you can use
                -qnokeyword=<keyword> to disable built-in keywords, and use
                -qkeyword=<keyword> to reinstate those keywords.

                (C) This option can also be used with the following C keywords:
                restrict, typeof, asm and inline.
                (C++) This option can be used with all C++ built-in keywords.

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

                (C) For C language programs, <suboptions_list> is
                {classic|extended|saa|saa12|stdc89|stdc99|extc89|extc99}:
                {ucs|noucs}.

                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 C CPI language
                     definition. This is currently SAA C Level 2.
                saal2
                     Compilation conforms to the SAA C Level 2 CPI language
                     definition, with some exceptions.
                stdc89
                     Compilation conforms to the ANSI C89 standard, also known
                     as ISO C90.
                stdc99
                     Compilation conforms to the ISO C99 standard.
                extc89
                     Compilation conforms to the ANSI C89 standard, and accepts
                     implementation-specific language extensions.
                extc99
                     Compilation conforms to the ISO C99 standard, and accepts
                     implementation-specific language extensions.
                ucs | noucs
                     This suboption controls whether Unicode characters are
                     allowed in identifiers, string literals and character
                     literals in program source code.
                     Default:
                       o -qlanglvl=ucs under language levels stdc99 and extc99.
                       o -qlanglvl=noucs for all other language levels.

                (C++) The suboptions for C++ language programs are:
                extended
                     Compilation is based on strict98, with some differences to
                     accommodate 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 suboption can be used to select between old (v3.6 or
                     earlier) and current (v5.0 or later) compiler object
                     compatibility.
                c99__func__ | noc99__func__
                     This suboption instructs the compiler to recognize the C99
                     __func__ identifier.
                     The c99__func__ suboption is enabled by default when
                     -qlanglvl=extended is enabled. 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. It is set by
                     default for -qlanglvl=extended.
                c99compoundliteral | noc99compoundliteral
                     This suboption instructs the compiler to support the C99
                     compound literal feature. It is set by default for
                     -qlanglvl=extended.
                c99hexfloat | noc99hexfloat
                     This suboption enables support for C99-style hexadecimal
                     floating constants in C++ applications. It is on by default
                     for -qlanglvl=extended.
                c99vla | noc99vla
                     When c99vla is enabled, the compiler will support the use
                     of C99-type variable length arrays in your C++
                     applications. It is set by default for -qlanglvl=extended.
                dependentbaselookup | nodependentbaselookup
                     Provides the ability to specify compilation in conformance
                     with issue 213 of TC1 of the C++ standard.
                     Default: -qlanglvl=dependentbaselookup
                gnu_assert | nognu_assert
                     Enables or disables support for the following GNU C system
                     identification assertions: '#assert', '#unassert', '#cpu',
                gnu_complex | nognu_complex
                     This suboption instructs the compiler to recognize GNU
                     complex data types and related keywords.
                gnu_computedgoto | nognu_computedgoto
                     Enables support for computed gotos. This suboption is
                     enabled for -qlanglvl=extended.
                gnu_externtemplate | nognu_externtemplate
                     This suboption enables or disables extern template
                     instantiations.
                     Default:
                       gnu_externtemplate is enabled by default when compiling
                       to the extended language level.
                gnu_include_next | nognu_include_next
                     Enables or disables support for the GNU C #include_next
                     preprocessor directive.
                     Default:
                       gnu_include_next is enabled by default for
                       -qlanglvl=extended.
                gnu_labelvalue | nognu_labelvalue
                     Enables or disables support for labels as values.
                     Default:
                       gnu_labelvalue is enabled by default for
                       -qlanglvl=extended.
                gnu_locallabel | nognu_locallabel
                     Enables or disables support for locally-declared labels.
                gnu_membernamereuse | nognu_membernamereuse
                     Enables or disables reusing a template name in a member
                     list as a typedef.
                gnu_suffixij | nognu_suffixij
                     Enables or disables support for GCC style complex numbers.
                     If gnu_suffixij is specified, a complex number can be ended
                     with suffix i/I or j/J.
                     Default:
                       gnu_suffixij is enabled by default for
                       -qlanglvl=extended.
                gnu_varargmacros | nognu_varargmacros
                     This option is similar to -qlanglvl=varargmacros. For the
                     list of the main differences, refer to the Compiler
                     Reference.
                     Default:
                       gnu_varargmacros is set by default for
                       -qlanglvl=extended.
                gnu_warning | nognu_warning
                     Enables or disables 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.
                     The compiler allows these forms by default.
                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.
                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.
                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
                     Controls whether alignment rules specified for nested
                     templates are ignored.
                     When the default, -qlanglvl=nooldtmplalign, is in effect,
                     these alignment rules are not ignored.
                     Specify -qlanglvl=oldtmplalign for compatibility with
                     VisualAge C++ 4.0 and predecessor products.
                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
                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.
                     Default: -qlanglvl=noucs
                varargmacros | novarargmacros
                     This C99 feature allows the use of a variable argument list
                     in function-like macros in your C++ applications.
                zeroextarray | nozeroextarray
                     This suboption controls whether zero-extent arrays are
                     allowed as the last non-static data member in a class
                     definition.
                     By default, the compiler allows arrays with zero elements.

                The default depends on the invocation command used:

                Command                       Default
                _____________________________________________

                ppuxlC/ppuxlc++               extended
                ppuxlc                        extc99
                ppucc                         extended
                ppuc89                        stdc89
                ppuc99                        stdc99

         -qlonglong | -qnolonglong
                Allows IBM-style long long integers. This option cannot be used
                with -qlanglvl=stdc99 or -qlanglvl=extc99.

                Default:
                     o -qlonglong for all invocation commands except ppuxlc89
                     and ppuxlc99, and all language levels except stdc89, stdc99
                     and extc99
                     o -qnolonglong for ppuxlc89 and ppuxlc99 and for language
                     levels stdc89, stdc99 and extc99

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

                Default: -qnombcs

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

                Default: -qnostaticinline

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

                Default: -qtabsize=8

         -qtrigraph | -qnotrigraph
                Allows trigraph key combinations to represent characters not
                found on some keyboards.

                Default: -qtrigraph

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

         -qutf | -qnoutf
                Enables recognition of UTF literal syntax.

                Default:
                     o -qnoutf for C compilation
                     o -qutf for C++ compilation

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

                Default: -qnotempinc

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

                Default: -qtemplatedepth=300

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

                Default: -qnotemplaterecompile

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

                Default: -qnotemplateregistry

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

                Default: -qtempmax=1

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

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

                Default: -qtmplinst=auto

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

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

                Default: -qtmplparse=no

  Floating-point and integer control options
         -qbitfields={signed|unsigned}
                Specifies whether bit fields will be signed or unsigned.

                Default: -qbitfields=signed

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

                Default: -qchars=unsigned

         -qenum=<suboption>
                Specifies the amount of storage occupied by enumerations, where
                <suboption> can be:

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

                Default: -qenum=intlong

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

                complexgcc | nocomplexgcc
                     Enables compatibility with GCC passing and returning of
                     parameters of complex data type.
                     Default:
                       o complexgcc when compiling in 32-bit mode.
                       o nocomplexgcc when compiling in 64-bit mode.
                fltint | nofltint
                     Speeds up floating-point-to-integer conversions by using
                     faster inline code that does not check for overflows.
                     -qfloat=nofltint checks floating-point-to-integer
                     conversions for out-of-range values.
                     Default:
                       o nofltint at -O2 optimization.
                       o fltint when -qnostrict or -O3 or higher optimization
                       level is in effect.
                fold | nofold
                     Specifies that constant floating-point expressions are to
                     be evaluated at compile time rather than at run time.
                     Default: fold
                gcclongdouble | nogcclongdouble
                     Specifies whether the compiler should use GCC-supplied or
                     IBM-supplied library functions for 128-bit long double
                     operations. gcclongdouble ensures binary compatibility with
                     GCC for mathematical calculations but nogcclongdouble
                     produces better performance.
                     Default: gcclongdouble
                hsflt | nohsflt
                     The hsflt option speeds up calculations by truncating
                     instead of rounding computed values to single precision
                     before storing and on conversions from floating-point to
                     integer. The nohsflt suboption specifies that single-
                     precision expressions are rounded after expression
                     evaluation and that floating-point-to-integer conversions
                     are to be checked for out-of-range values.
                     Default: nohsflt
                maf | nomaf
                     Makes floating-point calculations faster and more accurate
                     by using floating-point multiply-add instructions where
                     appropriate.
                     Default: maf
                nans | nonans
                     Generates extra instructions to detect signaling NaN when
                     converting from single-precision to double-precision at run
                     time. The option nonans specifies that this conversion need
                     not be detected.
                     Default: nonans
                relax | norelax
                     Relaxes the strict IEEE-conformance slightly for greater
                     speed, typically by removing some trivial, floating-point
                     arithmetic operations, such as adds and subtracts involving
                     a zero on the right.
                     Default: norelax
                rrm | norrm
                     Prevents floating-point optimizations that are incompatible
                     with runtime rounding to plus and minus infinity modes.
                     Default: norrm
                rsqrt | norsqrt
                     Specifies whether a sequence of code that involves division
                     by the result of a square root can be replaced by
                     calculating the reciprocal of the square root and
                     multiplying. Allowing this replacement produces code that
                     runs faster. -qfloat=rsqrt has no effect unless -qignerrno
                     is also specified.
                     Default:
                       o norsqrt at -O2 optimization
                       o rsqrt when when -qnostrict or -O3 or higher
                       optimization level is in effect
                spnans | nospnans
                     Detects signaling NaN on conversion from single-precision
                     to double-precision.
                     Default: nospnans

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

                Default: -qnolonglit

         -y<rounding_mode>
                m = round towards minus infinity
                n = round to the nearest representable number, ties to even
                p = round towards plus infinity
                z = round towards zero

                Default: -yn

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

                Default: -q32

         -qalloca
                (C) Substitutes inline code for calls to function alloca, as if

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

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

                Default:
                     (C) -qcommon
                     (C++) -qnocommon

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

                Default: -qeh

         -qfuncsect[=[no]implicitstaticref] | -qnofuncsect
                Places instructions for each function in a separate object file
                control section or csect. -qfuncsect can take the following
                suboption:

                implicitstaticref | noimplicitstaticref
                     Specifies whether the compiler generates dummy references
                     to the static area. Specifying -qfuncsect with no suboption
                     implies implicitstaticref. Specifying noimplicitstaticref
                     removes unnecessary references to the static data area.

                Default: -qnofuncsect

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

                Default: -qnokeepinlines

         -qpic[={small|large}] | -qnopic
                Generates position-independent code (pic). Specify -qpic=small
                if the Global Offset Table in 32-bit mode or Table of Contents
                in 64-bit mode must be 64 Kb or smaller, or -qpic=large if it
                can be larger than 64 Kb.  When -qmkshrobj is specified,
                -qpic=small is automatically set.

                Default: o -qnopic in 32-bit compilation
                o -qpic=small in 64-bit compilation

         -qppline | -qnoppline
                When used in conjunction with the -E or -P options, enables or
                disables the generation of #line directives in the preprocessed
                output.

                Default:
                     o -qnoppline with -P
                     o -qppline with -E

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

                Default: -qpriority=65535

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

                Default: -qnoproto

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

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

         -qro | -qnoro
                Specifies the storage type for string literals and puts string
                literals in read-only storage.

                Default:
                     o -qro with the ppuxlc, ppuxlc++/ppuxlC, ppuc89 and ppuc99
                     invocation commands.
                     o -qnoro with ppucc.

         -qroconst | -qnoroconst
                Specifies the storage location for constant values.

                Default:
                     o -qroconst with ppuxlc, ppuxlc++, ppuxlC, ppuc89 and
                     ppuc99 invocations commands
                     o -qnoroconst with ppucc.

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

                Default: -qrtti

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

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

                Default: -qnosaveopt

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

                Default: -qnostatsym

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

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

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

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

                Default:
                     o -qthreaded when compiling invocation commands ending in
                     "_r"
                     o -qnothreaded otherwise.

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

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

                Default:
                     o -qtls=default
                     Specifying -qtls with no suboption is equivalent to
                     -qtls=default.
                     o -qtls=initial_exec if the -qnopic compiler option is
                     enabled.
                     o -qtls=global_dynamic if the -qpic compiler option is
                     enabled.

         -qvrsave | -qnovrsave
                Enables code in function prologs and epilogs to maintain the
                VRSAVE register.
                Use -qvrsave to indicate to the compiler that functions in the
                compilation unit include code needed to maintain the VRSAVE
                register.
                Use -qnovrsave to indicate to the compiler that functions in the
                compilation unit do not include code needed to maintain the
                VRSAVE register.

                Default: -qvrsave

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

                Default: -qnoxcall

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

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

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

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

                Default: -qnocheck

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

                enable
                     Enables trapping of the specified exceptions.  Enables the
                     bits in the Floating-Point Status and Control Register,
                     allowing possible trapping of specified exceptions.
                inexact
                     Detects floating-point inexact exceptions.
                invalid
                     Detects floating-point invalid operation exceptions.
                nanq
                     Generates code to detect and trap NaNQ (Quiet Not-a-Number)
                     exceptions handled or generated by floating-point
                     operations.
                overflow
                     Detects floating-point overflow.
                underflow
                     Detects floating-point underflow.
                zerodivide
                     Detects floating-point division by zero.

                Default: -qnoflttrap

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

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

                Default:
                     o -qnoformat, which is equivalent to -qformat=noall.
                     o -qformat=all if -qformat is specified without any
                     suboptions.

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

                Default: -qnofullpath

         -g     Generates debug information for debugging tools.
                -g implies the -Q! option.

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

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

                Default: -qhalt=s

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

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

                all
                     Enables all diagnostic messages for all groups.
                noall
                     Disables all diagnostic messages for all groups.
                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.

                <groups_list> turns on or off specific groups of messages and is
                a colon-separated list of one or more of the following:

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

                Default:
                     (C) -qnoinfo
                     (C++) -qinfo=lan:trx
                If -qinfo is specified without a suboption, the default is
                -qinfo=all for C and -qinfo=all:noppt for C++.

         -qinitauto=<hex_value> | -qnoinitauto
                Initializes each byte or word of storage for automatic variables
                to the specified hexadecimal value <hex_value>. This generates
                extra code and should only be used for error determination.

                Default: -qnoinitauto

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

                Default: -qnokeepparm

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

                Default: -qnolinedebug

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

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

                Default: -qnomaxerr

         -qnewcheck | -qnonewcheck
                (C++) Specifies whether the compiler inserts a check to
                determine whether a null pointer has been returned by a call to
                a version of operator new or operator new[] with a non-empty
                throw specification.

                Default: -qnonewcheck

         -qoptdebug | -qnooptdebug
                When used with high levels of optimization, -qoptdebug produces
                source files containing optimized pseudocode that can be read by
                a debugger.
                An output file with a .optdbg extension is created for each
                input file compiled with -qoptdebug. You can use the information
                contained in this file to help you understand how your code
                actually behaves under optimization.

                Default: -qnooptdebug

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

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

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

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

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

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

                Default: -qnowarn64

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

                Default: -qnoattr

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

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

                i = informational messages
                w = warning messages
                e = error, severe error and unrecoverable error messages (C
                only)
                s = severe error and unrecoverable error messages (C)
                s = severe error messages (C++)

                Default: -qflag=i:i

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

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

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

                Default: -qnolist

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

                Default: -qnolistopt

         -qphsinfo | -qnophsinfo
                Reports the time taken in each compilation phase. Phase
                information is sent to standard output. The output takes the
                form <number1>/<number2> for each phase where <number1>
                represents the CPU time used by the compiler and <number2>
                represents the total of the compiler time and the time that the
                CPU spends handling system calls.

                Default: -qnophsinfo

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

                Default: -qprint

         -qreport | -qnoreport
                Instructs the compiler to produce transformation reports that
                show how program loops are optimized. The transformation reports
                are included as part of the compiler listing. This option
                requires -qhot or -qsmp in order to have effect.
                When used with -qipa=clonearch, -qreport produces transformation
                reports on the procedures that are cloned for the architectures
                specified by the option.

                Default: -qnoreport

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

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

                Default: -qnoshowinc

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

                Default: -qnosource

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

                Default: -qnosrcmsg

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

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

                Default: -qnosuppress

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

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

         -qversion[=verbose]
                Displays the official compiler product name and the compiler
                version found on the system.

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

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

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

                Default: -qnoxref

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

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

                Default: -qaggrcopy=nooverlap

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

                addrtaken | noaddrtaken
                     Variables are disjoint from pointers unless their address
                     is taken.
                allptrs | noallptrs
                     Pointers are never aliased if allptrs is specified, but may
                     be aliased if noallptrs is specified. -qalias=allptrs
                     implies -qalias=typeptr.
                ansi | noansi
                     If ansi is specified, type-based aliasing is used during
                     optimization, which restricts the lvalues that can be
                     safely used to access a data object. This option has no
                     effect unless you also specify the -O option.
                     Specifying -qalias=noansi turns off type-based aliasing
                     completely.
                global | noglobal
                     When global is in effect, type-based aliasing rules are
                     enabled during IPA link-time optimization across
                     compilation units. Both -qipa and -qalias=ansi must be
                     enabled for -qalias=global to have an effect.
                     Specifying noglobal disables type-based aliasing rules
                     across compilation units.
                restrict | norestrict
                     When restrict is in effect, optimizations for pointers
                     qualified with the restrict keyword are enabled. Specifying
                     norestrict disables optimizations for restrict-qualified
                     pointers.
                     -qalias=restrict is independent from other -qalias
                     suboptions.
                typeptr | notypeptr
                     Pointers to different types are never aliased if typeptr is
                     specified, but may be aliased if notypeptr is specified.

                Default:
                     (C++) -qalias=noaddrtaken:noallptrs:ansi:global:
                     restrict:notypeptr
                     (C) -qalias=noaddrtaken:noallptrs:ansi:global:
                     restrict:notypeptr for all invocation commands
                     except ppucc.
                     -qalias=noaddrtaken:noallptrs:noansi:global:
                     restrict:notypeptr for the ppucc invocation
                     command.

         -qarch=cellppu
                Specifies the general processor architecture for which the code
                (instructions) should be generated.  For any given -qarch
                setting, the compiler defaults to a specific, matching -qtune
                setting, which can provide additional performance improvements.

                cellppu
                     Produces object code containing instructions that will run
                     on the CBE PowerPC Processor Unit, PPU.

                Default: -qarch=cellppu

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

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

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

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

                Default: -qnocompact

         -qdataimported[=<variable_names>]
                Specifies variables that the compiler can assume are imported.
                <variable_names> is a colon-separated list of variables.
                Specifying -qdataimported without <variable_names> instructs the
                compiler to assume that all variables are imported. This is
                equivalent to specifying -qnotocdata.
                (C++) Variable names must be specified using their mangled
                names.

         -qdatalocal[=<variable_names>]
                Specifies variables that the compiler can assume are local.
                <variable_names> is a colon-separated list of variables.
                Specifying -qdatalocal with no variables instructs the compiler
                to assume that all variables are local. This is equivalent to
                specifying -qtocdata.
                (C++) Variable names must be specified using their mangled
                names.

         -qtocdata | -qnotocdata
                Marks all data as local.

                Default: -qnotocdata (marks all data as imported)

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

                Default: -qnodirectstorage

         -qenablevmx | -qnoenablevmx
                Enables the generation of vector instructions for processors
                that support them. These instructions can offer higher
                performance when used with algorithmic-intensive tasks such as
                multimedia applications.

                Default: -qenablevmx

         -qfdpr | -qnofdpr
                Collects information about programs for use with the IBM
                Feedback Directed Program Restructuring (FDPR) performance-
                tuning utility.

                Default: -qnofdpr

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

                arraypad[=<number>] | noarraypad
                     When <number> is specified, the compiler will pad every
                     array in the code. The pad amount must be a positive
                     integer value. Otherwise, the compiler will pad any arrays
                     where it infers that there may be a benefit.
                level={0|1}
                     Specifies the level of high-order transformation to perform
                     during compilation.
                     0
                          The compiler performs a subset of the high-order
                          transformations. Some of these include early
                          distribution, loop interchange, and loop tiling, as
                          examples. Optimization level -O3 implies
                          -qhot=level=0.
                     1
                          At level=1, full high-order transformation is
                          performed. -qhot=level=1 is equivalent to -qhot and
                          the compiler options that imply -qhot also imply
                          -qhot=level=1, unless -qhot=level=0 is explicitly
                          specified.
                simd | nosimd
                     Converts certain operations in a loop that apply to
                     successive elements of an array into a vector instruction.
                     This call calculates several results at one time, which is
                     faster than calculating each result sequentially. If you
                     specify -qhot=nosimd, the compiler performs optimizations
                     on loops and arrays, but avoids replacing certain code with
                     vector instructions.
                vector | novector
                     When specified with -qnostrict and -qignerrno, or an
                     optimization level of -O3 or higher (otherwise -qhot=vector
                     has no effect), the compiler converts certain operations in
                     a loop that apply to successive elements of an array into a
                     call to a routine in the Mathematical Acceleration
                     Subsystem (MASS) library, part of the libxlopt.a library.
                     If you specify -qhot=novector, the compiler performs
                     optimizations on loops and arrays, but avoids replacing
                     certain code with calls to vector library routines.

                Specifying -qhot without suboptions implies -qhot=nosimd,
                -qhot=noarraypad, -qhot=vector and -qhot=level=1. The -qhot
                option is also implied by -O4 and -O5.

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

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

                Default: -qnoignerrno

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

                exits=<function_names>
                     Specifies names of functions which represent program exits.
                     <function_names> is a comma-separated list of function
                     names.
                infrequentlabel=<function_names>
                     Specifies a comma-separated list of user-defined labels
                     that are likely to be called infrequently during a program
                     run.
                inline[=<suboption>]
                     Specifying 'inline' with no suboption asserts that all
                     appropriate functions will be inlined. <suboption> can be
                     one of the following:
                     auto|noauto
                          Enables or disables automatic function inlining by the
                          high-level optimizer. When -qipa=inline=auto is in
                          effect, the compiler considers all functions that are
                          under the maximum size limit (see below) for inlining.
                          When -qipa=inline=noauto is in effect, only functions
                          listed in the <functions> suboption are considered for
                          inlining.
                     <functions>
                          Specifies a comma-separated list of functions to
                          attempt to inline.
                     limit=<num>
                          Specifies a limit on the size of a calling function
                          after inlining. This only takes effect when
                          inline=auto is on. If you do not specify a value for
                          <num>, <num> is 8192 by default.
                     threshold=<num>
                          Specifies the upper size limit on procedures to
                          inline. This only takes effect when inline=auto is on.
                          If you do not specify a value for <num>, <num> is 1024
                          by default.
                     Default: auto
                noinline[=<functions>]
                     Specifies a comma-separated list of functions which are not
                     to be inlined. Specifying noinline without <functions>
                     asserts that no functions are to be inlined.
                isolated=<functions>
                     Specifies a comma-separated list of functions that are not
                     compiled with -qipa and do not directly refer to any global
                     variable.
                level=<level>
                     Determines the amount of IPA analysis and optimization
                     performed, where <level> can be equal to:
                     0
                          Performs only minimal interprocedural analysis and
                          optimization.
                     1
                          Turns on inlining, limited alias analysis, and limited
                          call-site tailoring.
                     2
                          Full interprocedural data flow and alias analysis.
                     Default: 1
                list[={<file_name>|short|long}]
                     Specifies an output listing file name during the link
                     phase. The default name is "a.lst". Specifying 'long' or
                     the listing file to determine which listing sections will
                     be included.
                     Default: short
                lowfreq=<functions>
                     Specifies a comma-separated list of functions that are
                     likely to be called infrequently during the course of a
                     typical program run.
                missing={unknown|safe|isolated|pure}
                     Specifies the default assumption for functions not compiled
                     with -qipa.
                     unknown
                          Greatly restricts the amount of interprocedural
                          optimization for calls to unknown functions.
                     safe
                          Functions which do not indirectly call a visible (not
                          missing) function either through direct call or
                          function pointer.
                     isolated
                          Functions which do not directly reference global
                          variables accessible to visible functions.
                     pure
                          Functions which are safe and isolated and which do not
                          indirectly alter storage accessible to functions.
                     Default: missing=unknown
                object | noobject
                     Specifies whether to include standard object code in the
                     object files. Specifying 'noobject' can substantially
                     reduce overall compile time by not generating object code
                     during the first IPA phase.
                partition={small|medium|large}
                     Specifies the size of program sections that are analyzed
                     together. Larger partitions may produce better analysis but
                     require more storage.
                     Default: partition=medium
                pure=<functions>
                     Specifies a comma-separated list of functions not compiled
                     with -qipa and that are "isolated", "safe", and do not
                     modify any data objects that are visible to the caller.
                safe=<functions>
                     Specifies a comma-separated list of functions not compiled
                     with -qipa and that do not call any other part of the
                     program.
                threads[=<suboption>] | nothreads
                     Runs portions of the IPA optimization process during pass 2
                     in parallel threads, which can speed up the linking process
                     on multi-processor systems. <suboption> can be one of the
                     following:
                     auto | noauto
                          When auto is in effect, the compiler selects a number
                          of threads heuristically based on machine load. When
                          noauto is in effect, the compiler spawns one thread
                          per machine processor.
                     <number>
                          Instructs the compiler to use a specific number of
                          threads. <number> can be any integer value in the
                          range of 1 to 32767. However, <number> is effectively
                          limited to the number of processors available on your
                          system.
                     Specifying threads with no suboptions implies threads=auto.
                     Default: -qipa=threads
                unknown=<functions>
                     Specifies a comma-separated list of functions that are not
                     compiled with -qipa and that may update global variables
                     and dummy arguments and call other parts of the program
                     compiled with -qipa.
                <file_name>
                     Specifies the name of a file that contains suboption
                     information in a special format.

                Regular expressions are supported when specifying function names
                for these suboptions:
                exits, inline, noinline, isolated, lowfreq, pure, safe, unknown.
                (C++) Function names must be specified using their mangled
                names.

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

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

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

                Default: -qnolargepage

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

                Default: -qnolibansi

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

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

         -qminimaltoc | -qnominimaltoc
                Avoids Table of Contents (TOC) overflow conditions by placing
                TOC entries into a separate data section for each object file.
                By default, the compiler will allocate at least one TOC entry
                for each unique non-automatic variable reference in your
                program.

                Default: -qnominimaltoc

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

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

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

                Default: -O0

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

                Default: -qnooptimize

         -p, -pg, -qprofile={-p|-pg}
                Sets up the object files produced by the compiler for profiling.
                -pg is like -p, but it produces more extensive statistics.

         -qpdf1[=pdfname=<file_path] | -qnopdf1
                Tunes optimizations through profile-directed feedback (PDF),
                where results from sample program execution are used to improve
                optimization near conditional branches and in frequently
                executed code sections.
                Used with a minimum optimization level of -O2, -qpdf1 produces
                an object that is instrumented to collect runtime execution
                information. This is phase 1 of the profile-directed feedback
                optimization process.

                pdfname=<file_path>
                     Specifies the location and name of the profile data file
                     containing the PDF profiling information.
                     Default:
                       If you do not specify <file_path>, the default file name
                       is ._pdf and the file is saved in the current working
                       directory, or in the directory named by the PDFDIR
                       environment variable, if it is set.

                Default: -qnopdf1

         -qpdf2[=pdfname=<file_path>] | -qnopdf2
                Tunes optimizations through profile-directed feedback (PDF),
                where results from sample program execution are used to improve
                optimization near conditional branches and in frequently
                executed code sections.
                Used with a minimum optimization level of -O2, -qpdf2 tunes
                application performance using the data generated by running a
                program compiled with -qpdf1. This is phase 2 of the profile-
                directed feedback optimization process.

                pdfname=<file_path>
                     Specifies the location and name of the profile data file
                     containing the PDF profiling information.
                     Default:
                       If you do not specify <file_path>, the default file name
                       is ._pdf and the file is saved in the current working
                       directory, or in the directory named by the PDFDIR
                       environment variable, if it is set.

                Default: -qnopdf2

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

                Default: -qprefetch

         -qprocimported[=<procedures>]
                Specifies functions that the compiler can assume are imported.
                Imported functions are dynamically bound with a shared portion
                of a library. Code generated for calls to functions marked as
                imported may be larger, but is faster than the default code
                sequence generated for functions marked as unknown. <procedures>
                is a colon-separated list of function identifiers.
                (C++) In C++ programs, function names must be specified using
                their mangled names.

         -qproclocal[=<procedures>]
                Specifies functions that the compiler can assume are local.
                Local functions are statically bound with the functions that
                call them; smaller, faster code is generated for calls to such
                functions. <procedures> is a colon-separated list of function
                identifiers.
                (C++) In C++ programs, function names must be specified using
                their mangled names.

         -qprocunknown[=<procedures>]
                Specifies functions that the compiler can assume are
                unknown. Unknown functions are resolved to either
                statically or dynamically bound objects during linking.
                <procedures> is a colon-separated list of function
                identifiers.
                (C++) In C++ programs, function names must be specified using
                their mangled names.

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

                (C) Specifies which specific functions the compiler should
                attempt to inline. You must specify at least an optimization
                level of -O2 for inlining to take effect with -Q. To turn on
                inline expansion for calls to procedures in different scopes,
                you must also use the -qipa=inline.

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

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

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

                -Q
                     Attempts to inline all appropriate functions with 20
                     executable source statements or fewer, subject to the
                     setting of any of the suboptions to the -Q option. If -Q is
                     specified last, all functions are inlined.
                -Q!
                     Does not inline any functions. If -Q! is specified last, no
                     functions are inlined.
                -Q-<procedures>
                     Does not inline functions listed in <procedures>, where
                     <procedures> is a colon-separated list. All other
                     appropriate functions are inlined. The option implies -Q.
                -Q+<procedures>
                     Attempts to inline the functions listed in <procedures>,
                     where <procedures> is a colon-separated list. All other
                     appropriate functions are inlined.
                -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.

                Default: -Q!

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

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

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

                -qinline
                     The compiler attempts to inline all appropriate functions
                     with 20 executable source statements or fewer, subject to
                     any other settings of the suboptions to the -qinline
                     option.
                -qinline+<procedures>
                     Attempts to inline the functions listed in <procedures> and
                     any other appropriate functions, where <procedures> is a
                     colon-separated list.
                -qinline-<procedures>
                     Specifies that functions listed in <procedures> do not get
                     inlined, where <procedures> is a colon-separated list.
                -qnoinline
                     Does not inline any functions.
                -qinline=<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.
                Default: -qnoinline

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

                Default: -qnosmallstack

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

                Default:
                     o -qnostrict at -O3 or higher.
                     o -qstrict otherwise.

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

                Default:
                     o -qnostrict_induction at -O2 or higher.
                     o -qstrict_induction otherwise.

         -qtune=cellppu
                Specifies the architecture system for which the executable
                program is optimized.

                cellppu
                     Generates object code containing instructions that will run
                     on the CBE PowerPC Processor Unit, PPU.

                Default: -qtune=cellppu

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

                auto
                     Instructs the compiler to perform basic loop unrolling.
                yes
                     Instructs the compiler to search for more opportunities for
                     loop unrolling than that performed with auto. In general,
                     this suboption is more likely to increase compile time or
                     program size than auto processing, but it may also improve
                     your application's performance.
                no
                     Instructs the compiler to not unroll loops.

                Default: -qunroll=auto

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

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

                Default: -qunwind

  Linking options
         -qbigdata | -qnobigdata
                Allows initialized data to be larger than 16MB in 32-bit mode.

                Default: -qnobigdata

         -qcrt | -qnocrt
                Instructs the linker to use the standard system startup files at
                link time.

                Default: -qcrt

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

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

                Default:
                     The default is to search only the standard directories.

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

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

         -qlib | -qnolib
                Specifies whether the compiler should use the standard system
                libraries at link time. -qnolib is similar to the gcc option
                nostdlib; the driver will not pass the standard system startup
                files or libraries when linking.

                Default: -qlib

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

         -qstaticlink[=libgcc] | -qnostaticlink[=libgcc]
                Specifies how shared libraries are linked into the application,
                where:

                -qstaticlink
                     Objects generated with this compiler option in effect will
                     not link with shared libraries.
                -qstaticlink=libgcc
                     Links to the static version of libgcc.
                -qnostaticlink
                     Links shared libraries with the object file named in the
                     invocation.
                -qnostaticlink=libgcc
                     Links to the shared version of libgcc.

                Default: -qstaticlink

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

  Portability and migration options
         -qabi_version=<n>
                (C++) Instructs the compiler to use version <n> of the C++
                Application Binary Interface (ABI), where <n> is one of the
                following:

                1
                     Allows users to get the same C++ ABI behavior as GNU C++
                     3.2
                2
                     Allows users to get the same C++ ABI behavior as GNU C++
                     3.4

                Default: -qabi_version=2

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

                bit_packed
                     The compiler uses the bit_packed alignment rules.
                linuxppc
                     The compiler uses the default GCC alignment rules to
                     maintain compatibility with GCC objects.

                Default: -qalign=linuxppc

         -qgenproto[=parmnames] | -qnogenproto
                (C) Generates ANSI prototypes from K&R function definitions and
                displays them on standard output. Specifying -qgenproto without
                '=parmnames' will cause prototypes to be generated without
                parameter names.

                Default: -qnogenproto

         -qupconv | -qnoupconv
                (C) Preserves the unsigned specification when performing
                integral promotions.

                Default:
                     o -qupconv when -qlanglvl={extended|classic}
                     o -qnoupconv otherwise

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

         -B[<prefix>]
                Determines substitute path names for programs used during
                compilation, such as the compiler, assembler, linkage editor,
                and preprocessor, where <prefix> can be any program name
                recognized by the -t compiler option. The optional <prefix>
                defines part of a path name to the new programs. The -t
                parameter, <program>, specifies the program to which the
                <prefix> is to be appended. When specifying <prefix>, there must
                be a slash (/) after the folder name.

         -qcomplexgccincl[=<path>] | -qnocomplexgccincl[=<path>]
                Specifies whether to use GCC parameter-passing conventions for
                complex data types (equivalent to enabling -qfloat=complexgcc)
                for selected include files only.
                When -qcomplexgccincl is in effect, the compiler internally
                wraps #pragma complexgcc(on) and #pragma complexgcc(pop)
                directives around include files found in a specified directory.

                Default:
                     -qcomplexgccincl=<path>, where <path> is the location of
                     the GCC include files.

         -qc_stdinc=<paths_list>
                (C) Changes the standard search location for the XL C headers.
                <paths_list> is a semicolon-separated list of paths to search.

         -qcpp_stdinc=<paths_list>
                (C++) Specifies the standard search directories for the XL C++
                headers, where <paths_list> is a semicolon-separated list of
                paths.

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

         -qgcc_c_stdinc=<paths_list>
                (C) Specifies the standard search directories for the GNU C
                system header files. <paths_list> is a semicolon-separated list
                of one or more paths. This option is ignored if the -qnostdinc
                option is in effect.

         -qgcc_cpp_stdinc=<paths_list>
                (C++) Specifies the standard search directories for the XL C++
                headers. <paths_list> is a semicolon-separated list of one or
                more search directories. This option is ignored if the
                -qnostdinc option is in effect.

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

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

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

                Default: -qspill=512

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

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

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

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


  SEE ALSO
         spuxlc(1), resetpdf(1), cleanpdf(1).

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


  COPYRIGHT
         Licensed Materials - Property of IBM.

         IBM XL C/C++ for Multicore Acceleration for Linux on x86 Systems, V9.0

         5724-T42

         IBM XL C/C++ for Multicore Acceleration for Linux on System p, V9.0

         5724-T43

         Copyright IBM Corp. 1991, 2007. All Rights Reserved.

         IBM, PowerPC, SAA and System p are trademarks or registered trademarks
         of International Business Machines Corporation in the United States,
         other countries, or both.

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

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



  IBM                                  2007                            ppuxlc(1)
