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


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

         Invocations                   Usage (supported standards)
         _________________________________________________________

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

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

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

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

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


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

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

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

         The input file may have any of the following suffixes:

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

          .c                 C source file

          .i                 Preprocessed C source file

          .ii                Preprocessed C++ source file


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

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

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

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

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

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

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

         -MD

         -qmakedep[=gcc]
                Produces the dependency files that are used by the make tool for each source file. The dependency output file is named with a .d suffix. The suboption can be:

                gcc
                     The format of the generated make rule to match the GCC format: the dependency output file includes a single target that lists all of the main source file's
                     dependencies. This suboption is equivalent to -MD.

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

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

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

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

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

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

         -MT <target>

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

         -dM (-qshowmacros)

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

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

                Default: -qnoshowmacros

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

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

                Default: -qtimestamps

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

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

         -qidirfirst | -qnoidirfirst
                Specifies whether the compiler searches for user included files in directories that are specified by the -I option before searching any other directories. When
                -qidirfirst is in effect, the compiler first searches the directories that are specified by the -I option before searching any other directories.

                Default: -qnoidirfirst

         -include <file>

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

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

                Default: None.

         -x <type>

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

                assembler

         -nostdinc | -nostdinc++ (-qnostdinc)

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

                Default: -qstdinc

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

         -maltivec | -mno-altivec
                Enables the compiler support for vector data types and operators.
                le
                     In vector registers, changes the vector element sequence to little-endian element order, with the first element on the right.
                be
                     In vector registers, changes the vector element sequence to big-endian element order, with the first element on the left.

                Default: By default, -mno-altivec is effective. Specifying -maltivec is equivalent to specifying -qaltivec=le.

         -fasm | -fno-asm

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

                Default: -qasm=gcc or -fasm

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

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

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

                Default: -fdollars-in-identifiers or qdollar

         -std[=<suboption>]

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

                (C) For C language programs, the suboptions of -std include:
                c89 | c90 | iso9899:1990
                     Compilation conforms strictly to the ANSI C89 standard, also known as ISO C90.
                iso9899:199409
                     Compilation conforms strictly to the ISO C95 standard.

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

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

                (C++) For C++ language programs, the suboptions of -qlanglvl include:
                extended
                     Compilation is based on the ISO C++ standard, with some differences to accommodate extended language features.
                extended0x
                     Compilation is based on the C++11 standard, invoking most of the C++ features and all the currently-supported C++11 features.

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

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

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

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


                Default:
                -qnostaticinline

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

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

                Default:
                -fexec-charset=UTF-8

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

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

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

         -qtmplinst=none
                Instantiates only the inline functions.

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

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

                Default: -fsigned-bitfields or -qbitfields=signed

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

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

                Default: -funsigned-char or -qchars=unsigned

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

                fold | nofold
                     Specifies that constant floating-point expressions are to be evaluated at compile time rather than at run time.
                     Default: fold
                hscmplx | nohscmplx
                     Speeds up operations involving complex division and complex absolute value. This suboption, which provides a subset of the optimizations of the hsflt suboption,

                relax | norelax
                     Relaxes the strict IEEE-conformance slightly for greater speed, typically by removing some trivial, floating-point arithmetic operations, such as adds and
                     subtracts involving a zero on the right. Specifying -qstrict=noieeefp also relaxes IEEE conformance.
                     Default: norelax
                rngchk | norngchk
                     Specifying norngchk instructs the compiler to skip range checking, allowing for increased performance where division and sqrt operations are performed repeatedly
                     within a loop.
                     When rngchk is specified, range checking is performed for input arguments for software divide and inlined sqrt operations.
                     When -qstrict, -qstrict=infinities, -qstrict=operationprecision, or -qstrict=exceptions is active, the setting of this option is forced to -qfloat=rngchk. When
                     -qnostrict is active, the setting of this option is -qfloat=norngchk unless the -qfloat=rngchk option is explicitly set by the user.
                     Default: rngchk
                rrm | norrm
                     Prevents floating-point optimizations that require the rounding mode to be the default, round-to-nearest, at run time, by informing the compiler that the
                     floating-point rounding mode may change or is not round-to-nearest at run time. You should use rrm if your program changes the runtime rounding mode by any means;
                     otherwise, the program may compute incorrect results.
                     Default: norrm
                rsqrt | norsqrt
                     Specifies whether a sequence of code that involves division by the result of a square root can be replaced by calculating the reciprocal of the square root and
                     multiplying. Allowing this replacement produces code that runs faster. -qfloat=rsqrt has no effect unless -qignerrno is also specified.
                     Default:
                       o norsqrt at -O2 optimization
                       o rsqrt when  -qnostrict or -O3 or higher optimization level is in effect
                spnans | nospnans
                     Detects signaling NaN on conversion from single-precision to double-precision.
                     Default: nospnans
                subnormals | nosubnormals
                     Specifies whether the code uses subnormal floating point values, also known as denormalized floating point values. Whether or not you specify this suboption, the
                     behavior of your program will not change, but the compiler uses this information to gain possible performance improvements.
                     Default: nosubnormals

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

                For binary floating-point types, <rounding_mode> is one of the following options:
                m = round towards minus infinity
                n = round to the nearest representable number, ties to even
                p = round towards plus infinity
                z = round towards zero

                Default: -yn

  Object code control options
         -fcommon | -fno-common

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

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

         -qeh | -qnoeh
                This option is ignored as glue code is always generated.

                Default: -qinlglue

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

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

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

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

                Default: -qpriority=65535

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

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

         -qrtti | -qnortti

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

                Default: -qnortti

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

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

                Default: -qnosaveopt

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

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

                global-dynamic
                     This model is the most general, and can be used for all thread-local variables.
                local-dynamic
                     This model provides better performance than the global-dynamic model, and can be used for thread-local variables defined in dynamically-loaded modules.
                initial-exec
                     This model provides better performance than the global-dynamic or local-dynamic models, and can be used for thread-local variables defined in dynamically-loaded
                     modules, provided that those modules are loaded at the same time as the executable.

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

         -fstandalone-debug | -fno-standalone-debug
                When used with the -g option, controls whether to generate the debugging information for all symbols.

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

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

                all
                     Enables all suboptions.
                bounds | nobounds
                     Performs runtime checking of addresses when subscripting within an object of known size.
                divzero | nodivzero
                     Performs runtime checking of integer division. A trap will occur if an attempt is made to divide by zero.
                nullptr | nonullptr
                     Performs runtime checking of addresses contained in pointer variables used to reference storage.
                stackclobber | nostackclobber
                     Detects stack corruption of nonvolatile registers in the save area in user programs. This type of corruption happens only if any of the nonvolatile registers in
                     the save area of the stack is modified.
                unset | nounset
                     Checks for automatic variables that are used before they are set at run time.

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

                Default: -qnocheck

         -ftrapping-math | -fnotrapping-math

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

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

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

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

         -Werror

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

                w = warning messages

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

         -qinitauto=<hex_value> | -qnoinitauto
                Specifies a hexadecimal value <hex_value> of 1 to 8 digits to initialize automatic variables.  This generates extra code and should only be used for error
                determination.

                Default: -qnoinitauto

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

                Default: -qnokeepparm

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

                ".class" to the source file name.

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

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

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

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

                Default: -qnolist

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

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

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

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

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

                filename
                     Specifies the name of the report file. One file is produced during the compile phase, and one file is produced during the IPA link phase.  If no filename is
                     specified, a file with the suffix .xml is generated in a way that is consistent with the rules of name generation for the given platform.
                stylesheet
                     Specifies the name of an existing XML stylesheet for which an xml-stylesheet directive is embedded in the resulting report. The default behavior is to not include
                     a stylesheet. The stylesheet supplied with XL Fortran is xlstyle.xsl. This stylesheet renders the XML to an easily read format when viewed using a browser that
                     supports XSLT.
                version
                When used with the option that enables profiling, -qpdf, the report contains information about call and block counts and cache misses.

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

                Default: This option is off by default. If none of the contentSelectionList suboptions is specified, all available report information is produced. For example,
                specifying -qlistfmt=xml is equivalent to -qlistfmt=xml=all.

         -qphsinfo | -qnophsinfo
                Reports the time taken in each compilation phase. Phase information is sent to standard output. The output takes the form <number1>/<number2> for each phase where
                <number1> represents the CPU time used by the compiler and <number2> represents real time (wall clock time).

                Default: -qnophsinfo

         -qreport | -qnoreport
                Produces listing files that show how sections of code have been optimized. A listing file is generated with a .lst suffix for each source file named on the command
                line. When you specify -qreport with an option that enables vectorization, the listing file shows a pseudo-C code listing and a summary of how program loops are
                optimized. The report also includes diagnostic information to show why specific loops cannot be vectorized.
                For -qreport to generate a loop transformation listing, you must also specify the following option on the command line:
                o -qhot
                o -qsmp
                o -O3 or higher
                For -qreport to generate PDF information in the listing, you must specify the following option in the command line:
                o -qpdf2 -qreport

                Default: -qnoreport

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

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

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

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

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

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

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

                auto | noauto
                     Enables or disables automatic inlining.
                level=number
                     Indicates the relative degree of inlining. The values for number must be integers from 0 to 10 inclusive. The default value for number is 5. The greater the value
                     of number, the more aggressive inlining the compiler conducts.
                function_name
                     If function_name is specified after the -qinline+ option, the named function must be inlined. If function_name is specified after the -qinline- option, the named

                Default: -qaggrcopy=nooverlap

         -fstrict-aliasing (-qalias=ansi)

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

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

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

         -mcpu[={pwr8|power8}]

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

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

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

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

                assoc=<number>
                     Specifies the set associativity of the cache, where <number> is one of the following values:
                          0         Direct-mapped cache
                          1         Fully associative cache
                          (n > 1)   n-way set associative cache
                auto
                type=<cache_type>
                     The settings apply to the specified type of cache, where <cache_type> is one of the following values:
                          c = Combined data and instruction cache
                          d = Data cache
                          i = Instruction cache

                Default:
                     Automatically determined by the setting of the -mtune (-qtune) option.

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

                arraypad[=<number>] | noarraypad
                     When <number> is specified, the compiler will pad every array in the code. The pad amount must be a positive integer value. Otherwise, the compiler will pad any
                     arrays where it infers that there may be a benefit.
                level={0|1|2}
                     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.
                     2
                          Performs the default set of high-order transformations and some more aggressive loop transformations. -qhot=level=2 must be used with -qsmp. This option
                          performs aggressive loop analysis and transformations to improve cache reuse and exploit loop parallelization opportunities.
                vector | novector
                     When specified with -qnostrict and -qignerrno, or an optimization level of -O3 or higher (otherwise -qhot=vector has no effect), the compiler converts certain
                     operations in a loop that apply to successive elements of an array into a call to a routine in the Mathematical Acceleration Subsystem (MASS) library, part of the
                     libxlopt.a library.
                     If you specify -qhot=novector, the compiler performs optimizations on loops and arrays, but avoids replacing certain code with calls to vector library routines.
                fastmath | nofastmath
                     Tunes your application to either use fast scalar versions of math functions or use the default versions.
                     You must use this suboption together with -qignerrno, unless -qignerrno is already enabled by other options.
                     -qhot=fastmath enables the replacement of math routines with available math routines from the XLOPT library only if -qstrict=nolibrary is enabled. -qhot=fastmath
                     is enabled by default if -qhot is specified regardless of the hot level.

                Default:
                     o -qnohot
                     o -qhot=noarraypad:level=0:novector:fastmath
                     when -O3 is in effect.
                     o -qhot=noarraypad:level=1:vector:fastmath when
                     -O4 or -O5 is in effect.
                     o Specifying -qhot without suboptions is equivalent to
                     -qhot=noarraypad:level=1:vector:fastmath.

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

                Default: -qnoignerrno

         -qipa[=<suboptions_list>] | -qnoipa
                     2
                          Full interprocedural data flow and alias analysis.
                          To generate data reorganization information, specify the optimization level -qipa=level=2 or -O5 together with -qreport.
                     Default: 1
                list[={<file_name>|short|long}]
                     Specifies an output listing file name during the link phase. The default name is "a.lst". Specifying 'long' or 'short' can be used to request more or less
                     information in the listing file to determine which listing sections will be included.
                     Default: short
                lowfreq=<functions>
                     Specifies a comma-separated list of functions that are likely to be called infrequently during the course of a typical program run.
                missing={unknown|safe|isolated|pure}
                     Specifies the default assumption for functions not compiled with -qipa.
                     unknown
                          Greatly restricts the amount of interprocedural optimization for calls to unknown functions.
                     safe
                          Functions which do not indirectly call a visible (not missing) function either through direct call or function pointer.
                     isolated
                          Functions which do not directly reference global variables accessible to visible functions.
                     pure
                          Functions which are safe and isolated and which do not indirectly alter storage accessible to functions.
                     Default: missing=unknown
                object | noobject
                     Specifies whether to include standard object code in the object files. Specifying 'noobject' can substantially reduce overall compile time by not generating
                     object code during the first IPA phase.
                partition={small|medium|large}
                     Specifies the size of program sections that are analyzed together. Larger partitions may produce better analysis but require more storage.
                     Default: partition=medium
                pure=<functions>
                     Specifies a comma-separated list of functions not compiled with -qipa and that are "isolated", "safe", and do not modify any data objects that are visible to the
                     caller.
                safe=<functions>
                     Specifies a comma-separated list of functions not compiled with -qipa and that do not call any other part of the program.
                threads[=<suboption>] | nothreads
                     Runs portions of the IPA optimization process during pass 2 in parallel threads, which can speed up the linking process on multi-processor systems. <suboption>
                     can be one of the following suboptions:
                     auto | noauto
                          When auto is in effect, the compiler selects a number of threads heuristically based on machine load. When noauto is in effect, the compiler creates one
                          thread per machine processor.
                     <number>
                          Instructs the compiler to use a specific number of threads. <number> can be any integer value in the range of 1 to 32767. However, <number> is effectively
                          limited to the number of processors available on your system.
                     Specifying threads with no suboptions implies threads=auto.
                     Default: -qipa=threads
                unknown=<functions>
                     Specifies a comma-separated list of functions that are not compiled with -qipa and that may update global variables and dummy arguments and call other parts of
                     the program compiled with -qipa.
                <file_name>
                     Specifies the name of a file that contains suboption information in a special format.

                Regular expressions are supported when specifying function names for these suboptions:
                exits, isolated, lowfreq, pure, safe, unknown.
                (C++) Function names must be specified using their mangled names.
                Limits the amount of memory used by certain memory-intensive optimizations to <size> kilobytes. When <size> is -1, the optimizer will use as much memory as needed.

                Default:

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

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

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

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

                Default: -O0

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

                Default: -qnooptimize

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

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

                pdfname=<file_path>
                     Specifies the directories and names for PDF files and any existing PDF map files. By default, if the PDFDIR environment variable is set, the compiler places the
                     PDF and PDF map files in the directory specified by PDFDIR. Otherwise, if the PDFDIR environment variable is not set, the compiler places these files in the
                     current working directory. If the PDFDIR environment variable is set but the specified directory does not exist, the compiler issues a warning message. The name

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

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

                Default: -qnopdf2

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

                assistthread | noassistthread
                     Use this supoption to work with applications that generate a high cache-miss rate. When you run -qprefetch=assistthread, the compiler uses the delinquent load
                     information to perform analysis and generates prefetching assist threads.
                     You can specify system architectures when using -qprefetch=assistthread:
                     CMP
                          For systems based on the chip multi-processor architecture (CMP), use -qprefetch=assistthread=cmp.
                     SMT
                          For systems based on the simultaneous multi-threading architecture (SMT), use -qprefetch=assistthread=smt.
                aggressive | noaggressive
                     When you run this supoption, the system guides the compiler to generate aggressive data prefetching at optimization level -O3 -qhot or higher.
                     Default: noaggressive
                dscr
                     You can specify a value for the dscr suboption to improve the runtime performance of your applications. For POWER8 processors, the value is valid only when the
                     optimization level is -O2 or greater; for POWER5, POWER6, and POWER7 processors, the value is valid only when the optimization level is -O3 or greater and the
                     high-order transformation (HOT) is in effect. The default value of dscr is 0. The value that you specify for dscr must be 0 or greater, and representable as a
                     64-bit unsigned integer. The value can be either decimal or hexadecimal.

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

         -qrestrict | -qnorestrict
                Adds the restrict type qualifier to the pointer parameters within all functions without modifying the source file.

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

                Default: -qshowpdf

         -qsimd[=<suboption>]
                Controls whether the compiler can automatically take advantage of vector instructions for processors that support them. -qsimd can take the following suboption:
                Enables parallelization of program code. <suboptions_list> is a colon-separated list of one or more of the following suboptions:

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

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

                Default: -qnosmp

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

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

                Default:

                     guards, and library suboptions. noexceptions enables these transformations.
                ieeefp | noieeefp
                     ieeefp disables transformations that affect IEEE floating-point compliance, including those controlled by the nans, infinities, subnormals, zerosigns, and
                     operationprecision suboptions. noieeefp enables these transformations.
                nans | nonans
                     nans disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce IEEE floating-point NaN (not-a-number)
                     values. nonans enables these transformations.
                infinities | noinfinities
                     infinities disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce floating-point infinities.
                     noinfinities enables these transformations.
                subnormals | nosubnormals
                     subnormals disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce IEEE floating-point subnormals.
                     nosubnormals enables these transformations.
                zerosigns | nozerosigns
                     zerosigns disables transformations that may affect or be affected by whether the sign of a floating-point zero is correct. nozerosigns enables these
                     transformations.
                operationprecision | nooperationprecision
                     operationprecision disables transformations that produce approximate results for individual floating-point operations. nooperationprecision enables these
                     transformations.
                vectorprecision | novectorprecision
                     vectorprecision disables vectorization in loops where it might produce different results in vectorized iterations than in nonvectorized residue iterations, to
                     ensure that every loop iteration of identical floating point operations on identical data produces identical results. novectorprecision enables vectorization even
                     when different iterations might produce different results from the same inputs.
                order | noorder
                     order disables all code reordering between multiple operations that may affect results or exceptions, including those controlled by the association,
                     reductionorder, and guards suboptions. noorder enables code reordering.
                association | noassociation
                     association disables reordering operations within an expression. noassociation enables reordering operations.
                reductionorder | noreductionorder
                     reductionorder disables parallelizing floating-point reductions. noreductionorder enables parallelizing these reductions.
                guards | noguards
                     If you specify -qstrict=guards, the compiler does not move operations past guards, which control whether the operations are executed. When the compiler encounters
                     if expressions that contain pointer wraparound checks that can be resolved at compile time, the compiler does not remove the checks or the enclosed operations.
                     The pointer wraparound check compares two pointers that have the same base but have constant offsets applied to them.
                     If you specify qstrict=noguards, the compiler moves operations past guards and evaluates if expressions according to language standards, in which pointer
                     wraparounds are undefined.
                library | nolibrary
                     library disables transformations that affect floating-point library functions. nolibrary enables these transformations.

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

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

         -mtune[={pwr8|power8}]

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

                     Optimizations are tuned for single-threaded execution.
                smt2
                     Optimizations are tuned for SMT2 execution mode (two threads).
                smt4
                     Optimizations are tuned for SMT4 execution mode (four threads).
                smt8
                     Optimizations are tuned for SMT8 execution mode (eight threads).

                Default: -mtune=pwr8, -mtune=power8, or -qtune=pwr8:st

         -funroll-loops (-qunroll)

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

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

                Default: -funroll-loops

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

                auto
                     This suboption is equivalent to -funroll-loops.
                yes
                     This suboption is equivalent to -funroll-all-loops.
                no
                     Instructs the compiler to not unroll loops.
                n
                     Instructs the compiler to unroll loops by a factor of n. In other words, the body of a loop is replicated to create n copies and the number of iterations is
                     reduced by a factor of 1/n.  The -qunroll=n option specifies a global unroll factor that affects all loops that do not have an unroll pragma already.  The value
                     of n must be a positive integer.

                Default: -qunroll=auto

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

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

                Default: -qunwind

         -fvisibility=<suboption>

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


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

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

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

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

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

         -qlib | -qnolib

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

                Default: -qlib

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

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

                Default: -qnostaticlink

  Portability and migration options
         -fpack-struct

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

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

                Default: -fpack-struct or -qalign=linuxppc

         -qxlcompatmacros | -qnoxlcompatmacros
                Determines whether the macros used by earlier versions of the compiler for indicating the XL C/C++ compiler product are defined. The -qxlcompatmacros option helps you
                migrate programs from IBM XL C/C++ for Linux for big endian distributions to IBM XL C/C++ for Linux for little endian distributions. Use -qnoxlcompatmacros if you are

         -isystem <dir>

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

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

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

         -isystem <dir>

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

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

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

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

         @<filename>

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

         -isystem <dir>

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

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

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

         -isystem <dir>

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

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

                <directory_path> is the path for the directory where the compiler should search for the GNU C++ header files. The directory_path can be a relative or absolute path.

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

                Default: -qspill=512

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

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


         -X{<X_program> <option>}

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

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

                o assembler
                o preprocessor
                o linker

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

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


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

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


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



  IBM                                                                                      2015                                                                                  xlc(1)

Man(1) output converted with man2html