Intel(R) C++ Compiler 8.1 for Itanium
---------------------------------------------
Intel(R) C++ compiler options. Used for SGI Altix submissions
NAME
icc - invokes the Intel(R) C++ compiler
ifort - invokes the Intel(R) Fortran Compiler
Optimization Levels
The Intel C++ and Intel Fortran Compilers apply the
following optimizations when you invoke the -O1, -O2, or
-O3 options: Constant propagation, copy propagation, dead-
code elimination, global register allocation, instruction
scheduling, lLoop unrolling (-O2, -O3 only), loop-invar-
iant code movement, partial redundancy elimination,
strength reduction/induction variable simplification, var-
iable renaming, exception handling optimizations, tail
recursions, peephole optimizations, structure assignment
lowering and optimizations, dead store elimination, loop-
invariant code motion.
Depending on the Intel architecture, optimization options
can have different effects. To specify optimizations for
your target architecture, refer to the following:
-O1 Optimizes to favor code size and code locality.
Disables loop unrolling. -O1 may improve perfor-
mance for applications with very large code size,
many branches, and execution time not dominated by
code within loops. In most cases, -O2 is recom-
mended over -O1.
Itanium architecture-based systems: Disables soft-
ware pipelining and global code scheduling.
-O2 (DEFAULT)
Optimize for code speed. This is the generally rec-
ommended optimization level.
Itanium architecture-based systems: Turns software
pipelining ON.
-O3 Enable -O2 optimizations and in addition, enable
more aggressive optimizations such as loop and mem-
ory access transformation. The -O3 optimizations
may slow down code in some cases compared to -O2
optimizations. Recommended for applications that
have loops with heavy use of floating point calcu-
lations and process large data sets.
-fast Enhances speed across the entire program. Sets the
following command options that can improve run-time
performance: -O3, -ipo, and -static. The default is
-nofast.
The Intel Compiler 8.1 second update includes
several improvements to the -fast switch. These
improvements are related to data transpose, per-
formance tuning of prefetch heuristics, more inlin-
ing and unroll & Jam.
-O Same as -O2
-Ob<n> Control inline expansion, where <n> is one of the
following values:
0 -- Disables inlining.
1 -- (DEFAULT) Enables inlining of functions
declared with the __inline keyword. Also enables
inlining according to the C++ language.
2 -- Inline any function, at the compiler's discre-
tion. Enables interprocedural optimizations and has
the same effect as -ip.
-O0 Disables optimizations.
Floating Point Optimization Options
-mp Maintain floating-point precision (disables some
optimizations). The -mp option restricts optimiza-
tion to maintain declared precision and to ensure
that floating-point arithmetic conforms more
closely to the ANSI and IEEE standards. For most
programs, specifying this option adversely affects
performance. If you are not sure whether your
application needs this option, try compiling and
running your program both with and without it to
evaluate the effects on both performance and preci-
sion.
-mp1 Improve floating-point precision. -mp1 disables
fewer optimizations and has less impact on perfor-
mance than -mp.
-ftz
Flush denormal results to zero.
-IPF_fma[-]
Enable [disable] the combining of floating point
multiplies and add/subtract operations. -IPF_fma[-]
enables [disables] the contraction of float-
ing-point multiply and add/subtract operations into
a single operation. Unless -mp is specified, the
compiler contracts these operations whenever possi-
ble. The -mp option disables the contractions.
-IPF_fma and -IPF_fma- can be used to override the
default compiler behavior.
-IPF_fp_relaxed
Enables use of faster but slightly less accurate
code sequences for math functions, such as divide
and sqrt. When compared to strict IEEE* pre-
cision, this option slightly reduces the accuracy
of floating-point calculations performed by these
functions, usually limited to the least signifi-
cant digit.
-IPF_fp_speculation<mode>
Enable floating point speculations with the follow-
ing <mode> conditions:
fast -- Speculate floating point operations
safe -- Speculate only when safe
strict -- Same as off
off -- Disables speculation of floating-point oper-
ations
-IPF_flt_eval_method0
Directs the compiler to evaluate the expressions
involving floating-point operands in the precision
indicated by the variable types declared in the
program.
-IPF_fltacc[-]
Enable [disable] optimizations that affect floating
point accuracy. By default (-IPF_fltacc-) the com-
piler may apply optimizations that reduce float-
ing-point accuracy. You may use -IPF_fltacc or -mp
to improve floating-point accuracy, but at the cost
of disabling some optimizations.
Optimizing Non-Exclusively for Specific Processors
The -tpp options optimize your application's performance
for a specific processor. The resulting binary will also
run on other processors in the same architecture (IA-32 or
Itanium architecture). The Intel C++ Compiler includes
gcc-compatible versions of the -tpp options. These options
are listed below, following the -tpp options.
-tpp1
Target optimization to the Itanium processor.
-tpp2
Target optimization to the Itanium 2 processor.
(DEFAULT on Itanium architecture-based systems)
The Intel C++ Compiler includes gcc-compatible versions of
the -tpp options, listed as follows
-mcpu=<cpu>
Optimize for a specific cpu, where <cpu> is one of
the following:
itanium -- Optimize for Intel Itanium processor
itanium2 -- Optimize for Intel Itanium 2 processor.
Interprocedural Optimizations (IPO)
Enable and Specify the Scope of IPO
-ip Enable single-file IP optimizations (within files).
With this option, the compiler performs inline
function expansion for calls to functions defined
within the current source file.
-ipo Enable multi-file IP optimizations (between files).
When you use -ipo to specify multifile IPO, the
compiler performs inline function expansion for
calls to functions defined in separate files. For
this reason, it is important to compile the entire
application or multiple, related source files
together when you specify -ipo.
-ipo_c Generate a multi-file object file (ipo_out.o) that
can be used in further link steps.
-ipo_S Generate a multi-file assembly file (ipo_out.s)
that can be used in further link steps.
Modify the Behavior of IPO
-ip_no_inlining
Disables inlining that would result from the -ip
interprocedural optimization, but has no effect on
other interprocedural optimizations.
-ipo_obj
Force the compiler to create real object files when
used with -ipo (requires -ipo).
-nolib_inline
Disable inline expansion of intrinsic functions
-auto_ilp32
Specifies that the application should run within a
32-bit address space. Also tells the compiler to
use 32-bit pointers whenever possible. To use this
option, you must specify -ipo.
Profile-guided Optimizations (PGO)
-prof_gen[x]
Instructs the compiler to produce instrumented code
in your object files in preparation for instru-
mented execution. With the x qualifier, extra
information is gathered. This option is used in
Phase 1 of PGO to instruct the compiler to produce
instrumented code in your object files in prepara-
tion for instrumented execution. Parallel make is
automatically supported for -prof_genx compila-
tions.
-prof_use
Instruct the compiler to produce a profile-opti-
mized executable and merge available dynamic infor-
mation (.dyn) files into a pgopti.dpi file. Use the
-prof_use option in Phase 3 of PGO.
-prof_dir <dir>
Specify directory <dir> for profiling output files
(*.dyn and *.dpi). Use the -prof_dir option with
-prof_gen as recommended for most programs, espe-
cially if the application includes the source files
located in multiple directories. -prof_dir ensures
that the profile information is generated in one
consistent place.
-prof_file <file>
Specify file name <file> for profiling summary file
-fnsplit[-]
Enable[disable] function splitting. Function split-
ting is enabled by -prof_use in Phase 3 to improve
code locality by splitting routines into different
sections: one section to contain the cold or very
infrequently executed code, and one section to con-
tain the rest of the code (hot code).
You can use -fnsplit to disable function splitting
for the following reasons:
Most importantly, to get improved debugging capa-
bility. In the debug symbol table, it is difficult
to represent a split routine, that is, a routine
with some of its code in the hot code section and
some of its code in the cold code section.
The -fnsplit- option disables the splitting
within a routine but enables function grouping, an
optimization in which entire routines are placed
either in the cold code section or the hot code
section. Function grouping does not degrade debug-
ging capability.
Another reason can arise when the profile data
does not represent the actual program behavior,
that is, when the routine is actually used fre-
quently rather than infrequently.
High-level Language Optimizations (HLO)
-O3 Turn on high-level optimizations. Enable -O2 plus
more aggressive optimizations, such as loop trans-
formation and prefetching. -O3 optimizes for maxi-
mum speed, but may not improve performance for some
programs.
-unroll<n>
The only
allowed value for n is 0. Disable loop unrolling.
-ivdep_parallel
For Itanium architecture-based applications, the
-ivdep_parallel option indicates there is abso-
lutely no loop-carried memory dependency in the
loop where IVDEP directive is specified. This tech-
nique is useful for some sparse matrix applica-
tions.
Auto Parallelization Options
-parallel
Enable the auto-parallelizer to generate
multi-threaded code for loops that can be safely
executed in parallel. The -parallel option enables
the auto-parallelizer if either the -O2 or -O3
optimization option is also on (the default is
-O2). The -parallel option detects parallel loops
capable of being executed safely in parallel and
automatically generates multithreaded code for
these loops.
-par_report[<n>]
Control the diagnostic messages from the auto-par-
allelizer where <n> is one of the following:
0 -- no diagnostic information is displayed.
1 -- indicates loops successfully auto-parallelized
(DEFAULT). Issues a "LOOP AUTO-PARALLELIZED" mes-
sage for parallel loops.
2 -- indicates successfully auto-parallelized loops
as well as unsuccessful loops.
3 -- same as 2 plus additional information about
any proven or assumed dependencies inhibiting
auto-parallelization (reasons for not paralleliz-
ing).
-par_threshold[<n>]
Set a threshold for the auto-parallelization of
loops based on the probability of profitable execu-
tion of the loop in parallel. This option is used
for loops whose computation work volume cannot be
determined at compile-time. The threshold is usu-
ally relevant when the loop trip count is unknown
at compile-time.
<n>=0-100. (DEFAULT: <n>=75)
The compiler applies a heuristic that tries to bal-
ance the overhead of creating multiple threads ver-
sus the amount of work available to be shared
amongst the threads.
Parallelization with OpenMP*
The Intel C++ Compiler supports the OpenMP* C++ version
2.0 API specification. The Intel C++ Compiler performs
transformations to generate multithreaded code based on
the user's placement of OpenMP directives in the source
program making it easy to add threading to existing soft-
ware. The Intel compiler supports all of the current
industry-standard OpenMP directives, except WORKSHARE, and
compiles parallel programs annotated with OpenMP direc-
tives. In addition, the Intel C++ Compiler provides
Intel-specific extensions to the OpenMP C++ version 2.0
specification including run-time library routines and
environment variables.
Note: As with many advanced features of compilers, you
must properly understand the functionality of the OpenMP
directives in order to use them effectively and avoid
unwanted program behavior.
-openmp
Enable the parallelizer to generate multi-threaded
code based on the OpenMP* directives. The code can be
executed in parallel on both uniprocessor and multi-
processor systems. The -openmp option works with both
-O0 (no optimization) and any optimization level of
-O1, -O2 (default) and -O3. Specifying -O0 with
-openmp helps to debug OpenMP applications.
-openmp_report[<n>]
Control the OpenMP parallelizer diagnostic level,
where <n> is one of the following:
0 -- no diagnostic information is displayed.
1 -- DEFAULT. Display diagnostics indicating loops,
regions, and sections successfully parallelized.
2 -- same as -openmp_report1 plus diagnostics indicat
ing MASTER constructs, SINGLE constructs, CRITICAL
constructs, ORDERED constructs, ATOMIC directives,
etc. are successfully handled.
-openmp_profile
Link with instrumented OpenMP runtime library to gen-
erate OpenMP profiling information for use with the
OpenMP component of the VTune(TM) Performance Analyzer
-openmp_stubs
Enables the user to compile OpenMP programs in sequen-
tial mode. The openmp directives are ignored and a
stub OpenMP library is linked (sequential)
Optimizer Report Options
The Intel C++ Compiler provides the following options to
generate and manage optimization reports:
-opt_report
Generate an optimization report and direct it to
stderr.
DEFAULT: The compiler does not generate optimiza-
tion reports.
-opt_report_file<file>
Specify the filename for the generated report
-opt_report_level[<level>]
Specify the level of report verbosity, where
<level> is one of the following:
min -- DEFAULT
med
max
-opt_report_routine<name>
Generate reports from all routines with names con-
taining the substring as part of their name. If not
specified, reports from all routines are generated.
DEFAULT: The compiler generates reports for all
routines.
-opt_report_phase<name>
Specify the phase that reports are generated
against. The compiler can generate reports for an
optimizer you specify in the <name> argument of the
-opt_report_phase<name> option. The option can be
used multiple times on the same command line to
generate reports for multiple optimizers. Cur-
rently, the following optimizer reports are sup-
ported:
ipo -- Interprocedural Optimizer
hlo -- High Level Optimizer
ilo -- Intermediate Language Scalar Optimizer
ecg -- Code Generator
omp -- Open MP
all -- All phases
When one of the above logical names for optimizers
is specified for <name>, all reports from that
optimizer are generated.
-opt_report_help
List the logical names of optimizers available for
report generation.
Conformance Options
-ansi_alias
directs the compiler to assume that the program
adheres to the rules defined in the ISO C Standard.
If your program adheres to these rules, then this
option will allow the compiler to optimize more
aggressively. If it doesn't adhere to these rules,
then it can cause the compiler to generate
incorrect code.
-Xc, -ansi
Select strict ANSI C/C++ conformance dialect
-Xa (Itanium architecture-based systems)
Select extended ANSI C dialect
-c99[-]
Enable(DEFAULT) [disable] C99 support for C pro-
grams.
-std=c99
Enable C99 support for C programs
-mp This option is described above in Floating-point
Optimizations.
Miscellaneous Optimization Options
-qp, -p
Compile and link for function profiling with Linux
gprof* tool
-alias_args[-]
This option implies arguments may be aliased [not
aliased].
DEFAULT: -alias_args
-mserialize-volatile (Itanium architecture-based systems)
Enable strict memory access ordering for volatile
data object references.
-mno-serialize-volatile (Itanium architecture-based sys-
tems)
Memory access ordering for volatile data object
references may be suppressed .
-complex_limited_range
This option causes the compiler to use the highest
performance formulations of complex arithmetic
operations, which may not produce acceptable
results for input values near the top or bottom of
the legal range. Without this option, the compiler
users a better formulation of complex arithmetic
operations, which produces acceptable results for
the full range of input values, at some loss in
performance.
Debugging Options
-g Produce symbolic debug information in object file.
The compiler does not support the generation of
debugging information in assemblable files. If you
specify the -g option, the resulting object file
will contain debugging information, but the assem-
blable file will not.
If you specify -g with -O1, -O2, or -O3, then -fp
is disabled and allows the compiler to use the EBP
register as a general-purpose register in optimiza-
tions. However, most debuggers expect EBP to be
used as a stack frame pointer, and cannot produce a
stack backtrace unless this is so. Using the -fp
option can result in slightly less efficient code.
IA-32 systems only: Specifying the -g or -O0 option
automatically enables the -fp option.
See the Intel C++ Compiler User's Guide for more
information
-syntax
Check the syntax of a program and stop the compila-
tion process after the C or C++ source files and
preprocessed source files have been parsed. This
option generates no code and produces no output
files. Warnings and messages appear on stderr.
Output Options
By default, the compiler converts source code directly to
an executable file. Appropriate options allow you to con-
trol the process by directing the compiler to produce pre-
processed files (.i), assemblable files (.s) and object
files (.o).
-P, -F Preprocess to file (.i) only. See Preprocessing
Options below for more information.
-S Compile to assembly (.s) only, do not link (*I).
-c Compile to object (.o) only, do not link.
-use_asm
Produce objects through assembler.
-fcode-asm
Produce assembly file with optional code annota-
tions.
-fsource-asm
Produce assembly file with optional code annota-
tions.
-f[no]verbose-asm
Produce assembly file with compiler comments
(DEFAULT).
-o<file>
Name output file.
-inline_debug_info
Preserve the source position of inlined code
instead of assigning the call-site source position
to inlined code.
Preprocessing Options
-A<name>[<value(s)>]
Associate a symbol <name> with the specified
sequence of <value(s)>. Equivalent to an #assert
preprocessing directive.
-A- Remove all predefined macros. Causes all predefined
macros and assertions to be inactive.
-C Preserve comments in preprocessed source output.
Comments following preprocessing directives are not
preserved.
-D<name>[=<value>]
Define the macro <name> and associate it with the
specified <value>. Equivalent to a #define prepro-
cessing directive.
DEFAULT: -D<name> defines a macro with a <value> of
1.
-E Direct the preprocessor to expand your source mod-
ule and write the result to standard output. The
preprocessed source contains #line directives,
which the compiler uses to determine the source
file and line number.
Direct the preprocessor to expand your source module and
write the result to standard output. Does not include
#line directives in the output. -EP is equivalent to -E
-P.
-P Direct the preprocessor to expand your source mod-
ule and store the result in a .i file in the cur-
rent directory. Unlike the -E option, the output
from -P does not include #line number directives.
By default, the preprocessor creates the name of
the output file using the prefix of the source file
name with a .i extension.
Caution: When you use the -P option, any existing
files with the same name and extension are over-
written.
-I<dir>
Add directory to include file search path. For mul-
tiple search directories, multiple -I<dir> commands
must be used. The compiler searches directories for
include files in the following order: 1. Directory
of the source file that contains the include. 2.
Directories specified by the -I option.
-idirafter<dir>
Add directory <dir> to the second include file
search path (after -I).
-isystem<dir>
Add directory <dir> to the start of the system
include path.
-U<name>
Remove predefined macro. Equivalent to a #undef
preprocessing directive.
-X Remove standard directories from include file
search path. You can use the -X option with the -I
option to prevent the compiler from searching the
default path for include files and direct it to use
an alternate path.
-nostdinc
Same as -X.
-no-gcc
Do not predefine the __GNUC__, __GNUC_MINOR__, and
__GNUC_PATCHLEVEL__ macros.
-H Print "include" file order and continue compila-
tion.
-M Generate makefile dependency lines for each source
file, based on the #include lines found in the
source file.
-MD Preprocess and compile. Generate output file (.d
extension) containing dependency information.
-MF<file>
Generate makefile dependency information in <file>.
Must specify -M or -MM.
-MG Similar to -M, but treats missing header files as
generated files.
-MM Similar to -M, but does not include system header
files.
-MMD Similar to -MD, but does not include system header
files.
-MX Generate dependency file (.o.dep extension) con-
taining information used for the Intel wb tool.
-dM Output macro definitions in effect after prepro-
cessing (use with -E).
-pch Automatic processing for precompiled headers.
-pch_dir <dir>
Directs the compiler to find and/or create a file
for pre-compiled headers in <dir>.
-create_pch <file>
Manual creation of precompiled header (file.pchi).
-use_pch <file>
Manual use of precompiled header (file.pchi).
Specifying Alternate Tools and Paths
You can direct the compiler to specify alternate tools for
preprocessing, compilation, assembly, and linking. Fur-
ther, you can invoke options specific to your alternate
tools on the command line.
-Qoption,<tool>,<optlist>
Pass options <optlist> to tool specified by <tool>.
<tool> may be cpp, c, asm, or ld. <optlist> Indi-
cates one or more valid argument strings for the
designated program. If the argument is a com-
mand-line option, you must include the hyphen. If
the argument contains a space or tab character, you
must enclose the entire argument in quotation char-
acters (""). You must separate multiple arguments
with commas.
-Qlocation,<tool>,<path>
Set <path> as the location of the tool specified by
<tool>. <tool> may be cpp, c, asm, or ld. <path> is
the complete path to the tool.
-Qinstall <dir>
Set <dir> as root of compiler installation.
Precompiled Headers
The Intel C++ Compiler supports precompiled header (PCH)
files to significantly reduce compile times using the
options described below.
Caution: Depending on how you organize the header files
listed in your sources, these options may increase compile
times.
-pch Direct the compiler to use appropriate PCH files.
If none are available, they are created as source
file.pchi. This option supports multiple source
files.
Note: The -pch option uses PCH files created from
other sources if the headers files are the same.
For example, if you compile source1.cpp using -pch,
then source1.pchi is created. If you then compile
source2.cpp using -pch, the compiler will use
source1.pchi if it detects the same headers.
-create_pch <filename>
Manual creation of precompiled header <filename>.
Use the -create_pch <filename> option if you want
the compiler to create a PCH file called <file
name>. The filename parameter must be specified.
The filename parameter can be a full path name.
The full path to filename must exist. The .pchi
extension is not automatically appended to file
name. This option cannot be used in the same compi-
lation as -use_pch filename. The -create_pch file-
name option is supported for single source file
compilations only.
-pch_dir <dirname>
Directs the compiler to find and/or create a file
for pre-compiled headers in dirname. Use the
-pch_dir <dirname> option to specify the path
(dirname) to the PCH file. You can use this option
with -pch, -create_pch filename, and -use_pch file-
name.
-use_pch <filename>
Manual use of precompiled header (filename.pchi).
This option directs the compiler to use the PCH
file specified by filename. It cannot be used in
the same compilation as -create_pch <filename>. The
-use_pch <filename> option supports full path names
and supports multiple source files when all source
files use the same .pchi file.
Language Options
-[no]restrict
Enable [disable] the �restrict� keyword for disam
biguating pointers.
-Kc++ Compile all source or unrecognized file types as
C++ source files.
-fno-rtti
Disable RTTI support.
-[no]align (IA-32 systems only)
Analyze and reorder memory layout for variables and
arrays.
-Zp[n] Specify alignment constraint for structure and
union types, where n is one of the following:
1,2,4,8,16.
-fshort-enums
Allocate as many bytes as needed for enumerated
types.
-fsyntax-only
Same as -syntax.
-funsigned-char
Change default char type to unsigned.
-funsigned-bitfields
Change default bitfield type to unsigned.
Options for Controlling Compiler Diagnostics
-w Disable all warnings. Displays error messages only.
-w<n> Control diagnostics, where <n> is one of the fol-
lowing:
0 -- Display errors (same as -w)
1 -- Display warnings and errors (DEFAULT)
2 -- Display remarks, warnings, and errors
-wn<n> Print a maximum of <n> errors displayed before the
compiler aborts. By default, if more than 100
errors are displayed, compilation aborts. Remarks
and warnings do not count towards this limit.
-wd<L1>[,<L2>,...<LN>]
Disable diagnostics L1 through LN.
-we<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to
error.
-ww<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to
warning.
-wr<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to
remark.
-Wall Enable all warnings.
-Werror
Force warnings to be reported as errors.
-Wbrief
Print brief one-line diagnostics. When enabled, the
original source line is not displayed and the error
message text is not wrapped when too long to fit on
a single line.
-Wcheck
Enable more strict diagnostics. Performs com-
pile-time code checking for code that exhibits
non-portable behavior, represents a possible unin-
tended code sequence, or possibly affects operation
of the program because of a quiet change in the
ANSI C Standard.
-Wp64 (Itanium architecture-based systems)
Print diagnostics for 64-bit porting.
Miscellaneous Options
-help Print list of compiler options.
-V Display compiler version information.
-dryrun
Show driver tool commands but do not execute tools.
-v Show driver tool commands and execute tools.
-x <type>
All source files found subsequent to -x <type> will
be recognized as one of the following types:
c -- C source file
c++ -- C++ source file
c-header -- C header file
cpp-output -- C pre-processed file
assembler -- Assembly file
assembler-with-cpp -- Assembly file that needs to
be preprocessed
none -- Disable recognition, and revert to file
extension
-falias
Assume aliasing in program (DEFAULT).
-fno-alias
Assume no aliasing in program.
-ffnalias
Assume aliasing within functions (DEFAULT).
-fno-fnalias
Assume no aliasing within functions, but assume
aliasing across calls.
-fr32 (Itanium architecture-based systems only)
Disable use of high floating point registers. Use
only lower 32 floating-point registers.
-Kpic, -KPIC
Deprecated option. Use -fpic instead.
-fpic, -fPIC
Itanium architecture-based systems: This option
generates code allowing full symbol preemption.
-fvisibility=[extern|default|protected|hidden|internal]
Global symbols (data and functions) will get the
visibility attribute given by default. Symbol visi-
bility attributes explicitly set in the source code
or using the symbol visibility attribute file
options will override the -fvisibility setting.
-fvisibility-extern=<file>
Space separated symbols listed in the <file> argu-
ment will get visibility set to extern.
-fvisibility-default=<file>
Space separated symbols listed in the <file> argu-
ment will get visibility set to default.
-fvisibility-protected=<file>
Space separated symbols listed in the <file> argu-
ment will get visibility set to protected.
-fvisibility-hidden=<file>
Space separated symbols listed in the <file> argu-
ment will get visibility set to hidden.
-fvisibility-internal=<file>
Space separated symbols listed in the <file> argu-
ment will get visibility set to internal.
-fminshared
Compilation is for the main executable. Absolute
addressing can be used and non-position independent
code generated for symbols that are at least pro-
tected.
-fno-common
Enables the compiler to treat common variables as
if they were defined, allowing the use of gprel
addressing of common data variables.
-Knopic, -KNOPIC (Itanium architecture-based systems)
Deprecated. Use fpic instead of this option.
-nobss_init
Place variables that are initialized with zeroes in
the DATA section. Disable placement of zero-ini-
tialized variables in BSS (use DATA).
-tcheck
Generate instrumentation to detect multi-threading
bugs (requires Intel Threading Tools; cannot be
used with compiler alone).
Linker Options
-L<dir>
Instruct linker to search <dir> for libraries.
-i_dynamic
Link Intel provided libraries dynamically.
-dynamic-linker<filename>
Select a dynamic linker (filename) other than the
default.
-mrelax
Pass -relax to the linker.
-mnorelax
Do not pass -relax to the linker.
-no_cpprt
Do not link in C++ runtime libraries.
-cxxlib-gcc
Use C++ header files provided by gcc during compi-
lation, and use C++ libraries provided by gcc.
Also, see gcc Interoperability above.
-cxxlib-icc
Use C++ libraries provided by Intel compiler.
-gcc-name
Use this option to specify the location of g++ when
compiler cannot locate gcc C++ libraries. For use
with -cxxlib-gcc configuration.
-nodefaultlibs
Do not use standard libraries when linking.
-nostartfiles
Do not use standard startup files when linking.
-nostdlib
Do not use standard libraries and startup files
when linking.
-static
Prevent linking with shared libraries. Causes the
executable to link all libraries statically, as
opposed to dynamically.
-shared
Produce a shared object.
-static-libcxa
Link Intel libcxa C++ library statically. By
default, the Intel-provided libcxa C++ library is
linked in dynamically. Use -static-libcxa on the
command line to link libcxa statically, while still
allowing the standard libraries to be linked in by
the default behavior.
-shared-libcxa
Link Intel libcxa C++ library dynamically, overrid-
ing the default behavior when -static is used. This
option has the opposite effect of -static-libcxa.
When this option is used, the Intel-provided libcxa
C++ library is linked in dynamically, allowing the
user to override the static linking behavior when
the -static option is used.
-u <symbol>
Pretend the <symbol> is undefined.
-T <file>
Direct linker to read link commands from <file>.
-Xlinker <val>
Pass <val> directly to the linker for processing.
-Wl,<o1>[,<o2>,...]
Pass options o1, o2, etc. to the linker for pro-
cessing.
ENVIRONMENT VARIABLES
You can customize your environment by editing the follow-
ing environment variables. You can specify paths where the
compiler can search for special files such as libraries
and include files.
LD_LIBRARY_PATH
Specifies the location for all Intel-provided
libraries. The LD_LIBRARY_PATH environment variable
contains a colon-separated list of directories in
which the linker will search for library (.a)
files. If you want the linker to search additional
libraries, you can add their names to
LD_LIBRARY_PATH, to the command line, to a response
file, or to the configuration file. In each case,
the names of these libraries are passed to the
linker before the names of the Intel libraries that
the driver always specifies.
PATH Specifies the directories the system searches for
binary executable files.
ICCCFG Specifies the configuration file for customizing
compilations with the icc compiler.
ICPCCFG
Specifies the configuration file for customizing
compilations with the icpc compiler.
TMP Specifies the directory in which to store temporary
files. If the directory specified by TMP does not
exist, the compiler places the temporary files in
the current directory.
IA32ROOT (IA32-based systems)
Points to the directory containing the bin, lib,
include and substitute header directories.
IA64ROOT (Itanium architecture-based systems)
Points to the directory containing the bin, lib,
include and substitute header directories.
GNU* Environment Variables
The Intel C++ Compiler supports the following GNU environ�
ment variables:
CPATH Specifies a list of directories to search following
the directories specified by -I.
C_INCLUDE
Specifies a list of directories to search following
the directories specified by -isystem.
CPLUS_INCLUDE_PATH
Same as C_INCLUDE.
DEPENDENCIES_OUTPUT
Specifies how to output dependencies for Make based
on preprocessed, non-system header files.
SUNPRO_DEPENDENCIES
Same as DEPENDENCIES_OUTPUT, except that system
header files are not ignored.
Compilation Environment Options
The Intel C++ Compiler installation includes shell scripts
that you can use to set environment variables. See the
Intel C++ User�s Guide for more information
Standard OpenMP Environment Variables
OMP_SCHEDULE
Specifies the type of runtime scheduling.
DEFAULT: static
OMP_NUM_THREADS
Sets the number of threads to use during execution.
DEFAULT: Number of processors currently installed
in the system while generating the executable
OMP_DYNAMIC
Enables (TRUE) or disables (FALSE) the dynamic
adjustment of the number of threads.
DEFAULT: FALSE
OMP_NESTED
Enables (TRUE) or disables (FALSE) nested paral-
lelism.
DEFAULT: FALSE
Intel Extensions to OpenMP Environment Variables
KMP_LIBRARY
Selects the OpenMP run-time library throughput. The
options for the variable value are: serial,
turnaround, or throughput indicating the execution
mode. The default value of throughput is used if
this variable is not specified.
DEFAULT: throughput (execution mode)
KMP_STACKSIZE
Sets the number of bytes to allocate for each par-
allel thread to use as its private stack. Use the
optional suffix b, k, m, g, or t, to specify bytes,
kilobytes, megabytes, gigabytes, or terabytes.
DEFAULT:
IA-32 systems: 2m
Itanium architecture-based systems: 4m
PGO Environment Variables
The following environment values determine the directory
in which to store dynamic information files or whether to
overwrite pgopti.dpi.
PROF_DIR
Specifies the directory in which dynamic informa-
tion files are created. This variable applies to
all three phases of the profiling process.
PROF_NO_CLOBBER
Alters the feedback compilation phase slightly. By
default, during the feedback compilation phase, the
compiler merges the data from all dynamic informa-
tion files and creates a new pgopti.dpi file if
.dyn files are newer than an existing pgopti.dpi
file. When this variable is set, the compiler does
not overwrite the existing pgopti.dpi file.
Instead, the compiler issues a warning and you must
remove the pgopti.dpi file if you want to use addi-
tional dynamic information files.
PROF_DUMP_INTERVAL
Initiate Interval Profile Dumping in an instru-
mented application. The _PGOPTI_Set_Inter-
val_Prof_Dump(int interval) function activates
Interval Profile Dumping and sets the approximate
frequency at which dumps will occur. The interval
parameter is measured in milliseconds and specifies
the time interval at which profile dumping will
occur. An alternative method of initiating Interval
Profile Dumping is by setting this environment
variable. Set this environment variable to the
desired interval value prior to starting the appli-
cation.
COPYRIGHT INFORMATION
Copyright (C) 1985-2003, Intel Corporation. All rights
reserved.
* Other brands and names are the property of their respec-
tive owners.
Copyright(C) 1985-2003 Intel Corporation ICC(1)
dplace - a tool for controlling placement of processes
onto cpus
-c Cpu_number(s). Specified as a list of cpu ranges:
Example: "-c1", "-c2-4", "-c1,4-8,3". Cpu numbers
are NOT physical cpu numbers. They are logical cpu
number that are relative to the cpus that are in
the set of allowed cpus as specified by the current
cpumemset or "runon" command. Cpu numbers start at
0. If this option is not specified, all cpus of the
current cpumemset are available.
+FDO this is shorthand notation to indicate that feedback opti-
mization was used in the build. The actual compiler flag
used was -prof_gen for the first pass build, ie. before the
training run, and -prof_use for the second pass build
which is after the training run.
Extra Libraries: libsmartheap64.a
this denotes that the 64 bit version of MicroQuill SmartHeap
Library 7.01 or later, from www.microquill.com, was used.
The exact version used is documented under the Software
section of each submission.
Portability flags for SPEC CPU2000:
-Dalloca=__builtin_alloca Replace occurrences of alloca() with
__builtin_alloca.
-DSPEC_CPU2000_LP64 Compile using LP64 programming model.
-D_LIBC Don't nclude GNU C libraries
-DLINUX_i386 Linux Intel system, use "long long" as
64bit variable.
-DHAS_ERRLIST Prog env provides specification for
"sys_errlist[]".
-DFMAX_IS_DOUBLE Specifies whether FMAX is double or float.
-DSPEC_CPU2000_NEED_BOOL Use SPEC provided definition of the boolean type.
-DSPEC_CPU2000_LINUX_IA64 Compile for an IA64 system running Linux.
-DPSEC_CPU2000_GLIBC22 Compatibility with 2.2 & later versions of glibc
-DSYS_IS_USG Specifies that the operating system is
USG compliant.
-DSYS_HAS_TIME_PROTO Do not explicitly declare time().
-DSYS_HAS_SIGNAL_PROTO Do not explicitly #include <signal.h>
-DSYS_HAS_IOCTL_PROTO Do not explicitly declare ioctl().
-DSYS_HAS_ANSI System is ANSI compliant.
-DSYS_HAS_CALLOC_PROTO Do not explicitly declare calloc().
-FI Fixed-format F90 source code.
srcalt=closed_files 255.vortex: Original code attempted a final
write using file pointers which had just been
closed. Those file pointers are set to null in
the approved source alt.