Content-type: text/html Manpage of bgxlc

bgxlc

Section: IBM XL C/C++ Blue Gene/Q, V12.0 (1)
Updated: 2012
Index Return to Main Contents
 

NAME

bgxlc, bgxlc_r, bgxlc++, bgxlc++_r, bgxlC, bgxlC_r, bgcc, bgcc_r, bgc89, bgc89_r, bgc99 and bgc99_r commands - invoke the IBM XL C/C++ compiler for Blue Gene/Q.

 

SYNTAX

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

 

DESCRIPTION


The commands and their recommended usages are described below.


Invocations                   Usage (supported standards)

_________________________________________________________

The main difference between these commands is that they use different default options (which are set in the configuration file /etc/opt/ibmcmp/vac/bg/12.0/vac.cfg).

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 or C++ source file .a Archive file .o Object file for ld command .s Assembler source file .S Assembler source file that
requires preprocessing
.so Shared object file
 

OPTIONS

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

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 enabled or disabled. -qx enables the option, and -qnox disables it. 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 and send preprocessed source to standard output.
-M
Creates an output file that contains information to be included in a "make" description file. This is equivalent to specifying -qmakedep without a suboption.
-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. 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).
-qshowmacros[=<suboptions_list>] | -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

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

all
-qshowmacros=all appends all macro definitions to preprocessed output. This is the same as specifying -qshowmacros.
pre | nopre
-qshowmacros=pre appends only predefined macro definitions to preprocessed output. -qshowmacros=nopre suppresses appending these definitions.
Only macros defined internally by the preprocessor are considered predefined; all other macros are considered as user-defined.

-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 -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 #include "<file_name>" directive. Use -qidirfirst 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>] | -qnoinclude
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_path> is the absolute or relative path and name of the header file.

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

Default: -qnoinclude

-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

-qasm[=<sub>] | -qnoasm
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 the xlc or c99 and related invocations are used, or when the stdc99 or extc99 language level is in effect.
o -qnocpluscmt for all other invocation commands and language levels.

-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.
-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 '$' in an identifier is treated as a base character. If the 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.
omp Ignores all OpenMP parallel processing 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, inline, asm and typeof.
(C++) This option can be used with all C++ built-in keywords.

-qlanglvl=<suboptions_list>
Selects the base C language level 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.
extc1x Compilation is based on the C1X standard, invoking all the currently supported C1X features and other extended features that are implemented in this release.

Note: C1X is a new version of the C programming language standard. IBM continues to develop and implement the features of the new standard. The implementation of the language level is based on IBM's interpretation of the standard. Until IBM's implementation of all the features of the C1X standard is complete, including the support of a new C 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 features of the C1X standard and therefore they should not be relied on as a stable programming interface.

Note: C1X has been ratified and published as ISO/IEC 9899:2011. All references to C1X in this document are equivalent to the ISO/IEC 9899:2011 standard. Corresponding information, including programming interfaces, will be updated in a future release.
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.
textafterendif | notextafterendif Controls whether a message is emitted when there is any extraneous text after #else or #endif.
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.
extended0x Compilation is based on the the C++0x standard, invoking all the C++ and currently-supported C++0x features that are implemented in this release.

Note: C++0x is a new version of the C++ programming language standard. IBM continues to develop and implement the features of the new standard. The implementation of the language level is based on IBM's interpretation of the standard. Until IBM's implementation of all the features of the C++0x standard is complete, including the support of a new C++ 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 features of the C++0x standard and therefore they should not be relied on as a stable programming interface.

Note: C++0x has been ratified and published as ISO/IEC 14882:2011. All references to C++0x in this document are equivalent to the ISO/IEC 14882:2011 standard. Corresponding information, including programming interfaces, will be updated in a future release.
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.
autotypededuction | noautotypededuction Controls whether the auto type deduction feature and the trailing return type feature are enabled. The auto type deduction feature can be used to delegate the task of type deduction of an auto variable to the compiler from the type of the initializer expression. Trailing return types are primarily used in function templates with return types that depend on the types of the function arguments.
Default: -qlanglvl=noautotypededuction
c1xnoreturn | noc1xnoreturn Enables or disables support of the _Noreturn function specifier. The -qlanglvl=c1xnoreturn option is included in group options -qlanglvl=extended and -qlanglvl=extended0x, so you can also use these group options to enable the _Noreturn function specifier.
Default: -qlanglvl=noc1xnoreturn
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.
c99longlong | noc99longlong Controls whether the C99 long long feature is enabled. When you specify the -qlanglvl=c99longlong option, the C++ compiler provides the C99 long long feature, which improves source compatibility between the C and C++ languages.
Default: -qlanglvl=noc99longlong
c99preprocessor | noc99preprocessor Controls whether the C99 preprocessor features adopted in C++0x are enabled. When -qlanglvl=c99preprocessor is in effect, the C99 and C++0x compilers provide a more common preprocessor interface, which can ease porting C source files to the C++ compiler and avoid preprocessor compatibility issues.
Default: -qlanglvl=noc99preprocessor
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.
compatrvaluebinding | nocompatrvaluebinding Instructs the compiler to allow a non-const reference to bind to an rvalue of a user-defined type where an initializer is not required.
complexinit | nocomplexinit Controls whether to enable the initialization of complex types.
Default: -qlanglvl=complexinit
constexpr | noconstexpr Extends the expressions permitted within constant expressions.
Note: In XL C/C++ V12.1, this feature is a partial implementation of what is defined in the C++0x standard.
Default: -qlanglvl=noconstexpr
decltype | nodecltype Controls whether the decltype feature is enabled. It can be used to get a type that is based on the resultant type of a possibly type-dependent expression.
Default: -qlanglvl=nodecltype
delegatingctors | nodelegatingctors Controls whether the delegating constructors feature is enabled. It can be used to concentrate common initializations in one constructor.
Default: -qlanglvl=nodelegatingctors
dependentbaselookup | nodependentbaselookup Provides the ability to specify compilation in conformance with issue 213 of TC1 of the C++ standard.
Default: -qlanglvl=dependentbaselookup
empty_struct | noempty_struct instructs the compiler to tolerate empty member declarations in structs. Empty member declaration in structs is not allowed.
Default: -qlanglvl=noemptystruct
explicitconversionoperators | noexplicitconversionoperators Controls whether the explicit conversion operators feature is enabled. When you specify the -qlanglvl=explicitconversionoperators option, you can apply the explicit function specifier to the definition of a user-defined conversion function, and thus to inhibit unintended implicit conversions through the user-defined conversion function.
Default: -qlanglvl=noexplicitconversionoperators
extendedfriend | noextendedfriend Controls whether the extended friend declarations feature is enabled. It can be used to accept additional forms of non-function friend declarations.
Default: -qlanglvl=noextendedfriend
extendedintegersafe | noextendedintegersafe With this option, if a decimal integer literal that does not have a suffix containing u or U cannot be represented by the long long int type, you can decide whether to use the unsigned long long int type to represent the literal. This option takes effect only when the -qlanglvl=c99longlong option is specified.
Default: -qlanglvl=noextendedintegersafe
externtemplate | noexterntemplate Controls whether explicit instantiation declarations are used. Explicit instantiation declarations provides you with the ability to suppress implicit instantiations of template specializations or or its members. When -qlanglvl=externtemplate is in effect, explicit instantiation declarations are supported.
Default: -qlanglvl=externtemplate
FileScopeConstExternLinkage | noFileScopeConstExternLinkage Controls whether the file scope of constant variables have internal or external linkage when the static or extern keyword is not specified.
Default: -qlanglvl=noFileScopeConstExternLinkage
gnu_assert | nognu_assert Enables or disables support for the following GNU C system identification assertions: '#assert', '#unassert', '#cpu', '#machine', '#system'.
gnu_complex | nognu_complex This suboption instructs the compiler to recognize GNU complex data types and related keywords.
gnu_computedgoto | nognu_computedgoto Enables support for computed gotos. This suboption is enabled for -qlanglvl=extended.
gnu_externtemplate | nognu_externtemplate This suboption is an alias for [no]externtemplate.
Default:
gnu_externtemplate is enabled by default when compiling to the extended language level.
Note: With C++0x, the suboptions -qlanglvl=[no]gnu_externtemplate is deprecated in IBM XL C/C++ for AIX/LINUX, V11.1, you can use the suboption -qlanglvl=[no]externtemplate instead.
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.
inlinenamespace | noinlinenamespace Controls whether the inline namespace definitions feature is enabled. It can be used to define and specialize members of an inline namespace as if they were also members of the enclosing namespace.
Default: -qlanglvl=noinlinenamespace
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 #undef or undefine() statement.
referencecollapsing | noreferencecollapsing Controls whether the reference collapsing feature is enabled.
Default:  -qlanglvl=noreferencecollapsing
rightanglebracket | norightanglebracket Controls whether the right angle bracket feature is enabled.
Default:  -qlanglvl=norightanglebracket
rvaluereferences | norvaluereferences Controls whether the rvalue references feature is enabled.
Default:  -qlanglvl=norvaluereferences
scopedenum | noscopedenum Controls whether the scoped enumeration feature is enabled.
Default:  -qlanglvl=noscopedenum
static_assert | nostatic_assert When -qlanglvl=static_assert is in effect, at compile time, the compiler issues a server error message if the assertion fails.
Default:  -qlanglvl=nostatic_assert
tempsaslocals | notempsaslocals Extends the lifetime of C++ temporaries beyond which is specified in the C++ Language Standard.
textafterendif | notextafterendif Controls whether a message is emitted when there is any extraneous text after #else or #endif.
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.
variadic[templates] | novariadic[templates] Controls whether the variadic templates feature is enabled. It can be used to define class or function templates that have an arbitrary number of template parameters.
Default: -qlanglvl=novariadic[templates]
zeroextarray | nozeroextarray This suboption controls whether you can use zero-extent arrays as the last nonstatic data member in a structure definition.
By default, you can use arrays with zero elements.

The default depends on the invocation command used:


Command                       Default
_____________________________________________

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

Default: o -qlonglong when compiling with
o -qnolonglong when compiling with

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

 

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. Unless it is otherwise specified, signedness is signed if a signed type of the size chosen can represent all values in the range of values. The suboptions are:

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. Signedness is unsigned, unless the range of values includes negative values.
int Specifies that enumerations occupy 4 types.
(C)Type is int.
(C++) Type is signed or unsigned int.
intlong Specifies that enumerations occupy 8 bytes of storage if the range of values in the enumeration cannot be represented by one of int or unsigned int. Otherwise, the enumerations occupy 4 bytes of storage and are represented by int or unsigned 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.

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.
If -qarch is set to a processor that has an instruction to convert from floating point to integer, that instruction will be used regardless of the [no]fltint setting. This conversion also applies to all Power processors in 64-bit mode.
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. 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 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 -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>

Specifies the compile-time rounding mode of constant floating-point expressions.

For binary floating-point types, <rounding_mode> is one of the following:
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

-qalloca
(C) Substitutes inline code for calls to function alloca , as if #pragma alloca directives were in the source code.
-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)
(C++) -qnocommon

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

Default: -qeh

-qpic[={small|large}] | -qnopic
Generates position-independent code (pic).

Specify -qpic=small if the Table of Contents must be 64 Kb or smaller, or specify -qpic=large if it must be larger than 64 Kb to avoid the overflow conditions.

Default: -qpic=small

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

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

Default: o -qroconst with invocations commands.
o -qnoroconst with

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

-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

-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

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

Default: -qnodbxextra

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

enable Enables trapping of the specified exceptions.
inexact Detects floating-point inexact exceptions.
invalid Detects floating-point invalid operation exceptions.
nanq | nonanq Generates code to detect and trap on NaNQ (Quiet Not-a-Number) exceptions handled or generated by floating-point operations.
overflow Detects floating-point overflow.
qpxstore, qpxs Enables the detection of Not a Number (NaN) or infinity values in Quad Processing eXtension (QPX) vectors.
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 debugging information for use by a symbolic debugger, and makes the program state available to the debugging session at selected source locations.

When the -O2 optimization level is in effect, the debug capability is completely supported. When an optimization level higher than -O2 is in effect, the debug capability is limited.

-g has the following levels:

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

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

-qfunctrace[<suboption>] | -qnofunctrace
Calls the tracing routines to trace the entry and exit points of the specified functions in a compilation unit.

-qfunctrace+<suboption> Instructs the compiler to trace <suboption>, and any of its internal functions. -qfunctrace-<suboption> Instructs the compiler not to trace <suboption>, or any of its internal functions.

The suboptions are:

function_name Indicates the named functions to be traced. classname Indicates the named class to be traced. namespace Indicates the namespace to be traced.

The -qfunctrace+ and -qfunctrace- suboptions enable tracing for a specific list of functions and are not affected by -qnofunctrace. The list of functions is cumulative.

Default: -qnofunctrace
When -qfunctrace is specified for a C++ program, the functions in the std namespace are not traced by default.

-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=<msg_id_list> | -qnohaltonmsg[=<msg_id_list>]
Stops compilation before producing any object files, executable files, or assembler source files if a specified error message is generated.

<msg_id_list> can be one message identifier or a list of message identifiers. The message identifier must be in the following format. To specify a list of messages, separate each message number with a colon.
15dd-number

15 Is the compiler product identifier.
dd Is the two-digit code representing the compiler component that produces the message.
number Is the message number.

Default: -qnohaltonmsg

-qinfo[=[<suboption>][<groups_list>]] | -qnoinfo
Produces or suppresses additional 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 except als and ppt.
noall Disables all diagnostic messages for all groups.
als Enables reporting of possible violations of the ANSI aliasing rule in effect.
noals Disables reporting of possible ANSI aliasing rule violations.
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.
stp | nostp Issues warnings for procedures that are not protected against stack corruption. -qinfo=stp has no effects unless the -qstackprotect option is also enabled. Like other -qinfo options, -qinfo=stp is enabled or disabled through -qinfo=all / noall. -qinfo=nostp is the default option.

<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
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
Specifying -qinfo with no suboptions is equivalent to -qinfo=all.

-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
Stops compilation when the number of error messages of a specified severity level (by default, the value of -qhalt) or higher reaches a specified number. <num> must be a positive integer. The severity levels, <sev>, are:

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

Default: -qnomaxerr

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

 

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 listing. You can use the object 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

-qlistfmt={xml|html}[=<suboptions_list>]
Creates a report to assist with finding 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 shipped with XL Fortran is xlstyle.xsl. This stylesheet renders the XML to an easily read format when viewed using a browser that supports XSLT. version Specifies the major version name of the report to be generated. If you have written a tool that requires a certain version of this report, you need to specify the version.

When used with an option that enables inlining such as -qinline, the report shows which functions were inlined and why others were not inlined.

To generate a loop transformation listing, you must also specify one of the following options on the command line:
o -qsimd=auto
o -qsmp
o -O5
o -qipa=level=2

To generate a parallel transformation listing or parallel performance messages, you must also specify one of the following options on the command line:
o -qsmp
o -O5
o -qipa=level=2

When used with the option that enables profiling, -qpdf, the report contains information about call and block counts and cache misses.

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

Default: This option is not on by default. If no <contentSelectionList> options are selected in their positive form, all available report information is produced. For example, specifying -qlistfmt=xml is equivalent to -qlistfmt=xml=all.

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

Default: -qnoreport

-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

-qskipsrc={show | hide}
Used with -qsource to determine whether the source statements skipped by the compiler are shown in the source section of the listing file.

show | hide When show is in effect, the compiler will display all source statements in the listing. This will result in both true and false paths of the preprocessing directives to be shown.

Default: -qskipsrc=show

-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

-qstackprotect[={all | size=N}] | -qnostackproteck
Provides protection against malicious code or programming errors that overwrite or corrupt the stack. The suboptions are:

all Protects all procedures whether or not there are vulnerable objects. This option is not set by default.
size=N Protects all procedures containing automatic objects greater or equal to N bytes in size. The default size is 8 when -qstackprotect is enabled.

Note:
o This option cannot be used with #pragma options.
o This feature can only be utilized on Blue Gene OS with GLIBC 2.4 and up (Machines with GCC 4.X and up).

Default: -qnostackprotect

-qsuppress=<msg_id_list> | -qsuppress[=<msg_id_list>]
Prevents specific informational or warning messages from being displayed or added to the listing file, if one is generated.

<msg_id_list> can be one message identifier or a list of message identifiers. The message identifier must be in the following format. To specify a list of messages, separate each message number with a colon.
15dd-number

15 Is the compiler product identifier.
dd Is the two-digit code representing the compiler component that produces the message.
number Is the message number.

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 version information and exits; compilation is stopped.

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



-qarch=<suboption>
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. The suboptions are:

auto When you compile your program with bg-prefixed invocation commands, -qarch=auto has the same effect as -qarch=qp.
qp Produces object code that will run on the Blue Gene/Q platforms. The -qarch=qp option automatically sets the -qsimd=auto option. You can disable SIMD optimization with the -qsimd=noauto option. When -qhot is set with -qarch=qp, -qhot=fastmath:level=0 is also set by default. -qarch=qp also enables the Blue Gene/Q vector type.

Default:
o -qarch=qp
o -qarch=auto when -O4 or -O5 is in effect.

-qassert=<suboption>
Provides information about the program to help fine-tune optimizations. Suboptions include:

refalign | norefalign Specifies that all pointers inside the compilation unit only point to data that is naturally aligned according to the length of the pointer types.

Default:  -qassert=norefalign

-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
auto Automatically detects the specific cache configuration of the compiling machine. It assumes that the execution environment will be the same as the compilation environment.
cost=<cycles> Specifies the performance penalty, in CPU cycles, resulting from a cache miss.
level=<level> Specifies which level of cache is affected, where level is one of the following: 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 = Combined data and instruction cache
d = Data cache
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

-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 The compiler performs the default set of high-order transformations and some more aggressive loop transformations. -qhot=level=2 must be used with -qsmp.

Default:
o -qnohot

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

Default: -qnoignerrno

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

exits=<function_names> Specifies names of functions which represent program exits. <function_names> is a comma-separated list of function names.
infrequentlabel=<function_names> Specifies a comma-separated list of user-defined labels that are likely to be called infrequently during a program run.
isolated=<functions> Specifies a comma-separated list of functions that are not compiled with -qipa and do not directly refer to any global variable.
level=<level> Determines the amount of IPA analysis and optimization performed, where <level> can be equal to:
0 Performs only minimal interprocedural analysis and optimization.
1 Turns on inlining, limited alias analysis, and limited call-site tailoring.
2 Full interprocedural data flow and alias analysis.
To generate data reorganization information, specify the optimization level -qipa=level=2 or -O5 together with -qreport.
Default: 1 list[={<file_name>|short|long}] Specifies an output listing file name during the link phase. The default name is "a.lst". Specifying 'long' or 'short' can be used to request more or less information in the listing file to determine which listing sections will be included.
Default: short lowfreq=<functions> Specifies a comma-separated list of functions that are likely to be called infrequently during the course of a typical program run.
missing={unknown|safe|isolated|pure} Specifies the default assumption for functions not compiled with -qipa.
unknown Greatly restricts the amount of interprocedural optimization for calls to unknown functions.
safe Functions which do not indirectly call a visible (not missing) function either through direct call or function pointer.
isolated Functions which do not directly reference global variables accessible to visible functions.
pure Functions which are safe and isolated and which do not indirectly alter storage accessible to functions.

Default: missing=unknown object | noobject Specifies whether to include standard object code in the object files. Specifying 'noobject' can substantially reduce overall compile time by not generating object code during the first IPA phase.
partition={small|medium|large} Specifies the size of program sections that are analyzed together. Larger partitions may produce better analysis but require more storage.
Default: partition=medium
pure=<functions> Specifies a comma-separated list of functions not compiled with -qipa and that are "isolated", "safe", and do not modify any data objects that are visible to the caller.

safe=<functions> Specifies a comma-separated list of functions not compiled with -qipa and that do not call any other part of the program.
unknown=<functions> Specifies a comma-separated list of functions that are not compiled with -qipa and that may update global variables and dummy arguments and call other parts of the program compiled with -qipa. <file_name> Specifies the name of a file that contains suboption information in a special format.

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

Default:
o -qnoipa

o -qipa=level=1:missing=unknown:
partition=medium:threads=auto when -O4 is in
effect.

o -qipa=level=2:missing=unknown:
partition=medium:threads=auto when -O5 is in
effect.

-qisolated_call=<procedures>
Informs the compiler that specific functions do not have or rely on side effects, other than those implied by their parameters. <procedures> is a colon-separated list of function names.
-qlibansi | -qnolibansi
Assumes that all functions with the name of an ANSI C defined library function are, in fact, the library functions.

Default: -qnolibansi

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

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

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

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

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

Default: -O0

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

Default: -qnooptimize

-p, -pg, -qprofile={-p|-pg}
Sets up the object files produced by the compiler for profiling.
-pg is like -p, but it produces more extensive statistics.
-qprefetch [=<suboption_list>] | -qnoprefetch
Enables generation of prefetching instructions such as dcbt and dcbz in compiled code.
<suboptions_list> is a colon-separated list of the following suboptions:

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

Default:
o -qprefetch
o -qprefetch=noaggressive

-qprocimported[=<procedures>] | -qnoprocimported
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>] | -qnoproclocal
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>] | -qnoprocunknown
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.
-qinline[<suboption>] | -qnoinline
Attempts to inline procedures instead of generating calls to those procedures, for improved performance.

(C++) Specifying -qinline enables automatic inlining by the compiler front end. Specifying -qinline with -O provides additional inlining by enabling inlining by the low-level optimizer.

-qinline+<function_name> Attempts to inline the functions listed in <function_name> and any other appropriate functions, where <function_name> is a colon-separated list. -qinline-<function_name> Specifies that functions listed in <function_name> do not get inlined, where <function_name> is a colon-separated list.
function_name A colon separated list of function names to be inlined. auto | noauto Enables or disables auto inlining.
level=number The values you specify must be positive integers between 0 and 10 inclusive. The default value for number is 5. Larger values increase the likelihood of inlining.
threshold Represents the number of executable statements in a function.

Default: o -qnoinline
o At optimization levels of -O2 and higher, the default is -qinline=noauto
o -qinline=auto:level=5 is the default suboption of -qinline

-qsimd[=<suboption>]
Controls whether the compiler can automatically take advantage of vector instructions for processors that support them. -qsimd can take the following suboption:

auto | noauto Enables or disables the automatic generation of vector instructions for processors that support them.

Default: -qsimd=auto

-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

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

auto | noauto Enables automatic parallelization and optimization. If noauto is specified, automatic parallelization of program code is disabled; only program code explicitly parallelized with OpenMP directives is optimized.
Default: auto
explicit | noexplicit Enables explicit parallelization of loops.
Default: explicit
nested_par | nonested_par If nested_par is specified, prescriptive nested parallel constructs are parallelized by the compiler.
Default: nonested_par
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
ostls | noostls Enables Thread Local Storage (TLS) provided by the operating system to be used for threadprivate data. The noostls suboption is to enable the non-TLS for threadprivate.
Default: ostls
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.
Default: schedule=auto speculative| nospeculative Enables thread-level speculative execution. 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:explicit:opt:noomp:norec_locks:

nonested_par:schedule=auto:nostackcheck:threshold=100:ostls:speculative

Default: -qnosmp

-qstrict[=<suboptions_list>] | -qnostrict
Ensures that optimizations done by default at optimization levels -O3, and higher, 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:

o Always -qstrict or -qstrict=all when the -qnoopt or -O0 optimization level is in effect
o -qstrict or -qstrict=all is the default when the -O2 or -O optimization level is in effect
o -qnostrict or -qstrict=none is the default when -O3 or a higher optimization level is in effect

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

all | none
all disables all semantics-changing transformations, including those controlled by the ieeefp, order, library, precision, and exceptions suboptions. none enables these transformations.
precision | noprecision
precision disables all transformations that are likely to affect floating-point precision, including those controlled by the subnormals, operationprecision, association, reductionorder, and library suboptions. noprecision enables these transformations.
exceptions | noexceptions
exceptions disables all transformations likely to affect exceptions or be affected by them, including those controlled by the nans, infinities, subnormals, guards, and library suboptions. noexceptions enables these transformations.
ieeefp | noieeefp
ieeefp disables transformations that affect IEEE floating-point compliance, including those controlled by the nans, infinities, subnormals, zerosigns, and operationprecision suboptions. noieeefp enables these transformations.
nans | nonans
nans disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce IEEE floating-point NaN (not-a-number) values. nonans enables these transformations.
infinities | noinfinities
infinities disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce floating-point infinities. noinfinities enables these transformations.
subnormals | nosubnormals
subnormals disables transformations that may produce incorrect results in the presence of, or that may incorrectly produce IEEE floating-point subnormals (formerly known as denorms). nosubnormals enables these transformations.
zerosigns | nozerosigns
zerosigns disables transformations that may affect or be affected by whether the sign of a floating-point zero is correct. nozerosigns enables these transformations.
operationprecision | nooperationprecision
operationprecision disables transformations that produce approximate results for individual floating-point operations. nooperationprecision enables these transformations.
vectorprecision | novectorprecision
vectorprecision disables vectorization in loops where it might produce different results in vectorized iterations than in nonvectorized residue iterations, to ensure that every loop iteration of identical floating point operations on identical data produces identical results. novectorprecision enables vectorization even when different iterations might produce different results from the same inputs.
order | noorder
order disables all code reordering between multiple operations that may affect results or exceptions, including those controlled by the association, reductionorder, and guards suboptions. noorder enables code reordering.
association | noassociation
association disables reordering operations within an expression. noassociation enables reordering operations.
reductionorder | noreductionorder
reductionorder disables parallelizing floating-point reductions. noreductionorder enables parallelizing these reductions.
guards | noguards
guards disables moving operations past guards (that is, past if statements, out of loops, or past function calls which might end the program or throw an exception) which control whether the operation should be executed. noguards enables moving operations past guards.
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.

-qtm

Enables support for transactional memory.

The -qtm option requires the thread safe compilation mode. Use -qtm with the -qthreaded option or the thread-safe compiler invocations.

-qtune=<suboption>
Tunes instruction selection, scheduling, and other architecture-dependent performance enhancements to run best on a specific hardware architecture.
<suboption> must be one of the following:

auto Optimizations are tuned for the platform on which the application is compiled.
qp Optimizations are tuned for the Blue Gene/Q platform.

Default: The -qtune=qp setting is the default setting for -qarch=qp, or when no -qarch or -qtune settings are specified and the bg-prefixed commands are used.

-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

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

Default: -qcrt

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

 

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: The default value depends on the level of GNU C++ configured during installation:
o -qabi_version=1 if GNU C++ 3.2 or 3.3 is installed.
o -qabi_version=2 if GNU C++ 3.4 or 4.0 is installed.

-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

-qpack_semantic={gnu|ibm}
Controls the syntax and semantics of the #pragma pack directive.

gnu Uses the GCC syntax and semantics for #pragma pack.
ibm Uses the IBM syntax and semantics for #pragma pack.

You should not need to use this option unless you are porting applications compiled with GCC and need to preserve source-level compatibility with the GCC version of the pragma directive.

Default: -qpack_semantic=ibm

-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>]] | -qnoasm_as
Specifies the path and flags used to invoke the assembler in order to handle assembler code in an asm statement. <asm_path> is the full path to the assembler to be used, and <flags_list> is a series of one or more flags (and their arguments), separated by spaces. Single quotes (or double quotes) are required around the string of arguments if any spaces exist.
-B[<prefix>]
Determines substitute path names for programs used during compilation, such as the compiler, assembler, linkage editor, and preprocessor, where <prefix> can be the path of any program name recognized by the -t compiler option. The optional <prefix> defines part of a path name to the new programs. The -t parameter, <program>, specifies the program to which the <prefix> is to be appended. When specifying <prefix>, there must be a slash (/) after the 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=/usr/include

The base .cfg file for the invocation commands sets -qcomplexgccincl to point to the location of the Blue Gene run time.

-qc_stdinc=<paths_list>
(C) Changes the standard search location for the XL C headers. <paths_list> is a colon-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 colon-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.
-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.
-qgcc_c_stdinc=<paths_list>
(C) Specifies the standard search directories for the GNU C system header files. <paths_list> is a colon-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 colon-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

-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

-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

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

 

COPYRIGHT

Licensed Materials - Property of IBM.

IBM XL C/C++ for Blue Gene/Q, V12.1

5799AG1

Copyright IBM Corp. 1991, 2012.

Blue Gene, Blue Gene/Q, IBM, the IBM logo, ibm.com, Power, POWER, POWER6, POWER6+, POWER7, PowerPC, and Power PC 604 are trademarks or registered trademarks of International Business Machines Corp., registered in many jurisdictions worldwide. Other product and service names might be trademarks of IBM or other companies. A current list of IBM trademarks is available on the Web at "Copyright and trademark information" at www.ibm.com/legal/copytrade.shtml.

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

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


 

Index

NAME
SYNTAX
DESCRIPTION
OPTIONS
Output control options
Input control options
Language element control options
Template control options (C++ only)
Floating-point and integer control options
Object code control options
Error checking and debugging options
Listing and messages options
Optimization and tuning options
Linking options
Portability and migration options
Compiler customization options
COPYRIGHT

This document was created by man2html, using the manual pages.
Time: 15:22:20 GMT, January 23, 2014