Content-type: text/html Manpage of ICC

ICC

Section: Intel(R) C++ Compiler Options (1)
Updated: Intel Corporation
Index Return to Main Contents
 

NAME

icc - invokes the Intel(R) C++ compiler  

SYNOPSIS

icc [
options ] file1 [ file2 ...] where:
options
represents zero or more compiler options.
filen
is a C/C++ source (.C .c .cc .cpp .cxx .c++ .i), assembly (.s), object (.o), static library (.a), or other linkable file.

NOTE: The icpc command uses the same compiler options as the icc command. Invoking the compiler using icpc compiles .c, and .i files as C++. Invoking the compiler using icc compiles .c and .i files as C. Using icpc always links in C++ libraries. Using icc only links in C++ libraries if C++ source is provided on the command line.  

DESCRIPTION

The Intel(R) C++ Compiler is designed to preprocess, compile, assemble, and link C and C++ programs on systems based on Intel architecture.

This document explains how information and instructions apply differently to IA-32 applications, Intel(R) EM64T applications, and Itanium(R) architecture-based applications. If a description does not explicitly state a specific architecture, it is applicable to all. See the Intel C++ Compiler User's Guide for more complete information than is presented here.

Some compiler features (options, predefined macros, etc.) are only available on certain systems. In this document, such compiler features are labeled. The label "i32" means the compiler feature is defined on IA-32-based systems; label "i32em" means the compiler feature is defined on Intel(R) Extended Memory 64 Technology (Intel(R) EM64T) systems; label "i64" means the compiler feature is defined on Itanium(R)-based systems. If no label is present, the compiler feature is available on all supported systems. If "only" appears in the label, that compiler feature is only available on the identified system(s).  

gcc* Interoperability

C++ compilers are interoperable if they can link object files and libraries generated by one compiler with object files and libraries generated by the second compiler, and the resulting executable runs successfully. The Intel(R) C++ Compiler options that affect gcc* interoperability include:

*
-cxxlib-<mode>
*
-gcc-name
*
-gcc-version
*
-fabi-version
*
-no-gcc (see gcc Predefined Macros for more information)

The Intel(R) C++ Compiler is interoperable with GNU gcc* compiler versions greater than or equal to 3.2. See the Intel C++ Compiler User's Guide for more information.  

OPTION SUMMARIES

 

Option Alphabetic Summary

All of the Intel C++ Compiler options are listed alphabetically in this section. After each listing is a reference to the Functional area where a detailed description of the option appears.

-A-
see Preprocessor Options
-A<name>[<value(s)>]
see Preprocessor Options
-[no-]alias-args
see Advanced Performance Options
-[no]align
see Language Options
-ansi
see Language Options
-[no-]ansi-alias
see Advanced Performance Options
-auto-ilp32
see Advanced Performance Options
-ax{K|W|N|B|P}
see Performance Options, Optimization Levels, Automatic Processor-specific Optimization, Vectorization Options
-B<dir>
see Miscellaneous Options
-c
see Output, Debug, and PCH Options
-C
see Preprocessor Options
-[no-]c99
see Language Options
-[no-]complex-limited-range
see Advanced Performance Options
-create-pch <file>
see Output, Debug, and PCH Options; Precompiled Headers
-cxxlib-<mode>
see Linking or Linker Options
-D<name>[=<value>]
see Preprocessor Options
-[no-]debug [keyword]
see Output, Debug, and PCH Options
-dM
see Preprocessor Options
-dryrun
see Miscellaneous Options
-dynamic-linker<filename>
see Linking or Linker Options
-E
see Preprocessor Options
-EP
see Preprocessor Options
-export
see Language Options
-export-dir <dir>
see Language Options
-F
see Preprocessor Options
-falias
see Performance Options
-fargument-alias
see Advanced Performance Options
-fargument-noalias
see Advanced Performance Options
-fargument-noalias-global
see Advanced Performance Options
-fast
see Performance Options, Optimization Levels
-fcode-asm
see Output, Debug, and PCH Options
-f[no-]common
see Miscellaneous Options
-fdata-sections
see Performance Options
-f[no-]exceptions
see Performance Options
-ffnalias
see Performance Options
-ffunction-sections
see Performance Options
-finline-functions
see Performance Options
-f[no-]math-errno
see Miscellaneous Options
-fminshared
see Miscellaneous Options
-fno-alias
see Performance Options
-fno-builtin
see Miscellaneous Options
-fno-builtin-<func>
see Performance Options, Miscellaneous Options
-fno-fnalias
see Performance Options
-fno-gnu-keywords
see Language Options
-fno-implicit-inline-templates
see Language Options
-fno-implicit-templates
see Language Options
-f[no-]omit-frame-pointer
see Performance Options
-fno-operator-names
see Language Options
-fnsplit[-]
see Advanced Performance Options
-fp
see Performance Options
-fpack-struct
see Miscellaneous Options
-fpermissive
see Language Options
-f[no-]pic
see Miscellaneous Options
-f[no-]PIC
see Miscellaneous Options
-fp-model <name>
see Advanced Performance Options
-[no-]fp-port
see Performance Options
-fpstkchk
see Performance Options
-fr32
see Miscellaneous Options
-f[no-]rtti
see Language Options
-freg-struct-return
see Miscellaneous Options
-fshort-enums
see Language Options
-fsource-asm
see Output, Debug, and PCH Options
-fstack-security-check
see Miscellaneous Options
-fsyntax-only
see Language Options
-ftemplate-depth-<n>
see Language Options
-ftls-model=<model>
see Advanced Performance Options
-ftrapuv
see Output, Debug, and PCH Options
-[no-]ftz
see Advanced Performance Options
-funroll-loops
see Advanced Performance Options
-funsigned-bitfields
see Language Options
-funsigned-char
see Language Options
-f[no]verbose-asm
see Output, Debug, and PCH Options
-fvisibility=[extern|default|protected|hidden|internal]
see Miscellaneous Options
-fvisibility-default=<file>
see Miscellaneous Options
-fvisibility-extern=<file>
see Miscellaneous Options
-fvisibility-hidden=<file>
see Miscellaneous Options
-fvisibility-internal=<file>
see Miscellaneous Options
-fvisibility-protected=<file>
see Miscellaneous Options
-g
see Output, Debug, and PCH Options
-g0
see Output, Debug, and PCH Options
-gcc-name=<name>
see Miscellaneous Options
-gcc-version=<nnn>
see Miscellaneous Options
-[no-]global-hoist
see Miscellaneous Options
-H
see Preprocessor Options
-help
see Miscellaneous Options
-I<dir>
see Preprocessor Options
-idirafter<dir>
see Preprocessor Options
-i-dynamic
see Linking or Linker Options
-imacros <file>
see Preprocessor Options
-inline-debug-info
see Output, Debug, and PCH Options
-ip
see Advanced Performance Options, Interprocedural Optimizations (IPO)
-[no-]IPF-fltacc
see Advanced Performance Options
-IPF-flt-eval-method0
see Advanced Performance Options
-[no-]IPF-fma
see Advanced Performance Options
-[no-]IPF-fp-relaxed
see Advanced Performance Options
-IPF-fp-speculation{fast|safe|strict|off}
see Advanced Performance Options
-ip-no-inlining
see Advanced Performance Options
-ip-no-pinlining
see Advanced Performance Options
-ipo[value]
see Advanced Performance Options, Interprocedural Optimizations (IPO)
-ipo-c
see Advanced Performance Options, Interprocedural Optimizations (IPO)
-[no-]ipo-obj
see Advanced Performance Options, Interprocedural Optimizations (IPO)
-ipo-S
see Advanced Performance Options, Interprocedural Optimizations (IPO)
-ipo-separate
see Advanced Performance Options, Interprocedural Optimizations (IPO)
-iprefix <prefix>
see Preprocessor Options
-i-static
see Linking or Linker Options
-isystem<dir>
see Preprocessor Options
-ivdep-parallel
see Advanced Performance Options
-iwithprefix <dir>
see Preprocessor Options
-iwithprefixbefore <dir>
see Preprocessor Options
-Kc++
see Language Options
-kernel
see Miscellaneous Options
-L<dir>
see Linking or Linker Options
-long_double
see Miscellaneous Options
-M
see Preprocessor Options
-malign-double
see Language Options
-map-opts
see Output, Debug, and PCH Options
-march={pentiumpro|pentiumii|pentiumiii|pentium4}
see Performance Options
-mcpu={pentium|pentiumpro|pentium4|itanium|itanium2}
see Performance Options
-MD
see Preprocessor Options
-MF<file>
see Preprocessor Options
-mfixed-range=f12-f15,f32-f127
see Miscellaneous Options
-MG
see Preprocessor Options
-m[no-]ieee-fp
see Performance Options
-MM
see Preprocessor Options
-MMD
see Preprocessor Options
-mno-relax
see Linking or Linker Options
-mno-serialize-volatile
see Advanced Performance Options
-mp
see Performance Options
-MP
see Preprocessor Options
-mp1
see Performance Options
-MQ<target>
see Preprocessor Options
-mrelax
see Linking or Linker Options
-mserialize-volatile
see Advanced Performance Options
-msse
see Performance Options
-msse2
see Performance Options
-msse3
see Performance Options
-MT<target>
see Preprocessor Options
-[no-]multibyte-chars
see Miscellaneous Options
-nobss-init
see Miscellaneous Options
-no-cpprt
see Linking or Linker Options
-nodefaultlibs
see Linking or Linker Options
-no-gcc
see Preprocessor Options
-nostartfiles
see Linking or Linker Options
-nostdinc
see Preprocessor Options
-nostdlib
see Linking or Linker Options
-mtune=<cpu>
see Performance Options
-o<file>
see Output, Debug, and PCH Options
-O0
see Performance Options, Optimization Levels
-O1
see Performance Options, Optimization Levels
-O2
see Performance Options, Optimization Levels
-O3
see Performance Options, Optimization Levels
-Ob<n>
see Performance Options
-openmp
see Advanced Performance Options, Parallelization with OpenMP*
-openmp-profile
see Advanced Performance Options, Parallelization with OpenMP*
-openmp-report{0|1|2}
see Advanced Performance Options, Parallelization with OpenMP*
-openmp-stubs
see Advanced Performance Options, Parallelization with OpenMP*
-opt-report
see Advanced Performance Options
-opt-report-file<file>
see Advanced Performance Options
-opt-report-help
see Advanced Performance Options
-opt-report-level[{min|med|max}]
see Advanced Performance Options
-opt-report-phase{ipo|hlo|ilo|ecg|omp|all}
see Advanced Performance Options, Parallelization with OpenMP*
-opt-report-routine<name>
see Advanced Performance Options
-Os
see Performance Options
-p
see Advanced Performance Options
-P
see Preprocessor Options
-parallel
see Advanced Performance Options, Auto Parallelization Options
-par-report{0|1|2|3}
see Advanced Performance Options, Auto Parallelization Options
-par-threshold[<n>]
see Advanced Performance Options, Auto Parallelization Options
-pc{32|64|80}
see Performance Options
-pch
see Output, Debug, and PCH Options; Precompiled Headers
-pch-dir <dir>
see Output, Debug, and PCH Options; Precompiled Headers
-[no-]prec-div
see Performance Options
-[no-]prec-sqrt
see Performance Options
-[no-]prefetch
see Advanced Performance Options
-print-multi-lib
see Output, Debug, and PCH Options
-prof-dir <dir>
see Advanced Performance Options, Profile-guided Optimizations (PGO)
-prof-file <file>
see Advanced Performance Options, Profile-guided Optimizations (PGO)
-prof-gen[x]
see Advanced Performance Options, Profile-guided Optimizations (PGO)
-prof-gen-sampling
see Advanced Performance Options, Profile-guided Optimizations (PGO)
-prof-use
see Advanced Performance Options, Profile-guided Optimizations (PGO)
-Qinstall <dir>
see Component Control Options
-Qlocation,<tool>,<path>
see Component Control Options
-Qoption,<tool>,<optlist>
see Component Control Options
-qp
see Advanced Performance Options
-rcd
see Performance Options
-reserve-kernel-regs
see Miscellaneous Options
-[no]restrict
see Language Options
-S
see Output, Debug, and PCH Options
-shared
see Linking or Linker Options
-shared-libcxa
see Linking or Linker Options
-[no-]sox
see Miscellaneous Options
-ssp
see Preprocessor Options
-static
see Linking or Linker Options
-static-libcxa
see Linking or Linker Options
-std=c99
see Language Options
-strict-ansi
see Language Options
-T <file>
see Linking or Linker Options
-tcheck
see Advanced Performance Options
-[no]traceback
see Compiler Diagnostics Options
-u <symbol>
see Linking or Linker Options
-U<name>
see Preprocessor Options
-unroll<n>
see Advanced Performance Options
-unroll0
see Advanced Performance Options
-use-asm
see Output, Debug, and PCH Options
-use-msasm
see Output, Debug, and PCH Options
-use-pch <file>
see Output, Debug, and PCH Options; Precompiled Headers
-V
see Miscellaneous Options
-v
see Miscellaneous Options
-vec-report[{0|1|2|3|4|5}]
see Advanced Performance Options
--version
see Miscellaneous Options
-w
see Compiler Diagnostics Options
-w<n>
see Compiler Diagnostics Options
-Wa<o1>[,<o2>,...]
see Linking or Linker Options
-W[no-]abi
see Compiler Diagnostics Options
-Wall
see Compiler Diagnostics Options
-Wbrief
see Compiler Diagnostics Options
-Wcheck
see Compiler Diagnostics Options
-W[no-]comment[s]
see Compiler Diagnostics Options
-Wcontext-limit=<n>
see Compiler Diagnostics Options
-wd<L1>[,<L2>,...]
see Compiler Diagnostics Options
-W[no-]deprecated
see Compiler Diagnostics Options
-we<L1>[,<L2>,...]
see Compiler Diagnostics Options
-Werror
see Compiler Diagnostics Options
-Winline
see Compiler Diagnostics Options
-Wl,<o1>[,<o2>,...]
see Linking or Linker Options
-W[no-]main
see Compiler Diagnostics Options
-W[no-]missing-prototypes
see Compiler Diagnostics Options
-wn<n>
see Compiler Diagnostics Options
-Wp64
see Compiler Diagnostics Options
-Wp,<o1>[,<o2>,...]
see Linking or Linker Options, Precompiled Headers
-W[no-]pointer-arith
see Compiler Diagnostics Options
-wr<L1>[,<L2>,...]
see Compiler Diagnostics Options
-W[no-]return-type
see Compiler Diagnostics Options
-W[no-]shadow
see Compiler Diagnostics Options
-W[no-]uninitialized
see Compiler Diagnostics Options
-W[no-]unknown-pragmas
see Compiler Diagnostics Options
-W[no-]unused-function
see Compiler Diagnostics Options
-ww<L1>[,<L2>,...]
see Compiler Diagnostics Options
-X
see Preprocessor Options
-x <type>
see Miscellaneous Options
-x{K|W|N|B|P}
see Performance Options, Optimization Levels, Optimizing Exclusively for Specific Processors, Vectorization Options
-Xlinker <val>
see Linking or Linker Options
-Zp[n]
see Language Options
 

Option Functional Summary

All the options listed in the following summary are described in more detail in the sections that follow.

Performance Options
-ax{K|W|N|B|P} -falias -fast -fdata-sections -f[no-]exceptions -ffnalias -ffunction-sections -finline-functions -fno-alias -fno-builtin-<func> -fno-fnalias -f[no-]omit-frame-pointer -fp -[no-]fp-port -fpstkchk -march={pentiumpro|pentiumii|pentiumiii|pentium4} -mcpu={pentium|pentiumpro|pentium4|itanium|itanium2} -m[no-]ieee-fp -mp -mp1 -msse -msse2 -msse3 -mtune=<cpu> -O0 -O1 -O2 -O3 -Ob<n> -pc{32|64|80} -[no-]prec-div -[no-]prec-sqrt -rcd -x{K|W|N|B|P}
Advanced Performance Options
-[no-]alias-args -[no-]ansi-alias -auto-ilp32 -[no-]complex-limited-range -fargument-alias -fargument-noalias -fargument-noalias-global -fnsplit[-] -fp-model <name> -ftls-model=<model> -[no-]ftz -funroll-loops -ip -[no-]IPF-fltacc -IPF-flt-eval-method0 -[no-]IPF-fma -[no-]IPF-fp-relaxed -IPF-fp-speculation{fast|safe|strict|off} -ip-no-inlining -ip-no-pinlining -ipo[value] -ipo-c -[no-]ipo-obj -ipo-S -ipo-separate -ivdep-parallel -mno-serialize-volatile -mserialize-volatile -openmp -openmp-profile -openmp-report{0|1|2} -openmp-stubs -opt-report -opt-report-file<file> -opt-report-help -opt-report-level[{min|med|max}] -opt-report-phase{ipo|hlo|ilo|ecg|omp|all} -opt-report-routine<name> -p -parallel -par-report{0|1|2|3} -par-threshold[<n>] -[no-]prefetch -prof-dir <dir> -prof-file<file> -prof-gen[x] -prof-gen-sampling -prof-use -qp -tcheck -unroll<n> -unroll0 -vec-report[{0|1|2|3|4|5}]
Output, Debug, and PCH Options
-c -create-pch <file> -[no-]debug[keyword] -fcode-asm -fsource-asm -ftrapuv -f[no]verbose-asm -g -g0 -inline-debug-info -map-opts -o<file> -pch -pch-dir<dir> -print-multi-lib -S -use-asm -use-msasm -use-pch <file>
Preprocessor Options
-A- -A<name>[<value(s)>] -C -D<name>[=<value>] -dM -E -EP -H -I<dir> -idirafter<dir> -imacros<file> -iprefix<prefix> -isystem<dir> -iwithprefix<dir> -iwithprefixbefore<dir> -M -MD -MF<file> -MG -MM -MMD -MP -MQ<target> -MT<target> -no-gcc -nostdinc -P -ssp -U<name> -X
Component Control Options
-Qinstall<dir> -Qlocation,<tool>,<path> -Qoption,<tool>,<optlist>
Language Options
-[no]align -ansi -[no-]c99 -export -export-dir <dir> -fno-gnu-keywords -fno-implicit-inline-templates -fno-implicit-templates -fno-operator-names -fpermissive -f[no-]rtti -fshort-enums -fsyntax-only -ftemplate-depth-<n> -funsigned-bitfields -funsigned-char -Kc++ -malign-double -[no]restrict -std=c99 -strict-ansi -Zp[n]
Compiler Diagnostics Options
-[no]traceback -w -w<n> -W[no-]abi -Wall -Wbrief -Wcheck -W[no-]comment[s] -Wcontext-limit=<n> -wd<L1>[,<L2>,...] -W[no-]deprecated -we<L1>[,<L2>,...] -Werror -Winline -W[no-]main -W[no-]missing-prototypes -wn<n> -Wp64 -W[no-]pointer-arith -wr<L1>[,<L2>,...] -W[no-]return-type -W[no-]shadow -W[no-]uninitialized -W[no-]unknown-pragmas -W[no-]unused-function -ww<L1>[,<L2>,...]
Miscellaneous Options
-B<dir> -dryrun -f[no-]common -f[no-]math-errno -fminshared -fno-builtin -fno-builtin-<func> -fpack-struct -f[no-]pic -f[no-]PIC -fr32 -freg-struct-return -fstack-security-check -fvisibility=[extern|default|protected|hidden|internal] -fvisibility-default=<file> -fvisibility-extern=<file> -fvisibility-hidden=<file> -fvisibility-internal=<file> -fvisibility-protected=<file> -gcc-name=<name> -gcc-version=<nnn> -[no-]global-hoist -help -kernel -long_double -mfixed-range=f12-f15,f32-f127 -[no-]multibyte-chars -nobss-init -reserve-kernel-regs -[no-]sox -V -v --version -x <type>
Linking or Linker Options
-cxxlib-<mode> -dynamic-linker<filename> -i-dynamic -i-static -L<dir> -mno-relax -mrelax -no-cpprt -nodefaultlibs -nostartfiles -nostdlib -shared -shared-libcxa -static -static-libcxa -T <file> -u <symbol> -Wa<o1>[,<o2>,...] -Wl,<o1>[,<o2>,...] -Wp,<o1>[,<o2>,...] -Xlinker<val>

 

OPTION DESCRIPTIONS

 

Performance Options

The performance options act using general criteria to optimize code. The optimizations listed in this section are available for Intel architectures or are compatible with gcc compiler options.
-ax<codes> (i32, i32em only)
Generate code specialized for processor extensions specified by <codes> while also generating generic IA-32 code. <codes> includes one or more of the following characters:

K -- Intel Pentium III processors and compatible Intel processors

W -- Intel Pentium 4 processors and compatible Intel processors

N -- Intel Pentium 4 processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific optimizations.

B -- Intel Pentium M processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific optimizations.

P -- Intel Pentium 4 Processors with Streaming SIMD Extensions 3 (SSE3) instruction support. Enables new optimizations in addition to Intel processor-specific optimizations.

NOTE: The only -ax options available on Intel(R) EM64T-based systems are -axW and -axP.

-falias
Assume aliasing in the program (DEFAULT).
-fast
The -fast option maximizes speed across the entire program. It sets command options that can improve run-time performance, as follows:

i32, i32em: The -fast option turns on -O3, -ipo, -static, and -xP. IA-32 programs compiled with -fast will execute only on Intel(R) Pentium(R) 4 processors with Streaming SIMD Extensions 3 (SSE3). Programs compiled with this option will detect non-compatible processors and generate an error message during execution.

i64: The -fast option turns on -O3, -ipo, and -static.

-fdata-sections
Separate functions for the linker (COMDAT). Same as -ffunction-sections.
-f[no-]exceptions
The -f[no-]exceptions option turns off exception handling table generation, resulting in smaller code. Any use of exception handling constructs - try blocks, throw statements will produce an error. Exception specifications are parsed but ignored. A preprocessor symbol __EXCEPTIONS is defined when this option is not used. It is undefined when this option is present.
-ffnalias
Assume aliasing within functions (DEFAULT).
-ffunction-sections
Separate functions for the linker (COMDAT). Same as -fdata-sections.
-finline-functions
Inline any function at the compiler's discretion. Same as -ip.
-fno-alias
Assume no aliasing in program.
-fno-builtin-<func>
Disable the <func> intrinsic.
-fno-fnalias
Assume no aliasing within functions, but assume aliasing across calls.
-f[no-]omit-frame-pointer
The negative version is the same as -fp.
-fp (i32, i32em only)
Disable using EBP as general purpose register.
-[no-]fp-port (i32, i32em only)
Round floating-point results at assignments and casts (some speed impact).
-fpstkchk (i32, i32em only)
Generate extra code after every function call to assure that the FP stack is in the expected state. Generally, when the FP stack overflows, a NaN value is put into FP calculations, and the program's results differ. Unfortunately, the overflow point can be far away from the point of the actual bug. The -fpstkchk option places code that would access violate immediately after an incorrect call occurred, thus making it easier to locate these issues.
-march=<cpu> (i32 only)
Generate code exclusively for a given cpu, where <cpu> is one of the following:

pentiumpro -- Intel Pentium Pro processors

pentiumii -- Intel Pentium II processors

pentiumiii -- Intel Pentium III processors

pentium4 -- Intel Pentium 4 processors

-mcpu=<cpu>
Optimize for a specific cpu, where <cpu> is one of the following:

pentium -- (i32 only) Optimize for Intel Pentium processor.

pentiumpro -- (i32 only) Optimize for Intel Pentium Pro, Intel Pentium II and Intel Pentium III processors.

pentium4 -- (i32 only; DEFAULT on IA-32) Optimize for Intel Pentium 4 processors.

itanium -- (i64 only) Optimize for Intel Itanium processor

itanium2 -- (i64 only) Optimize for Intel Itanium 2 processor.

-m[no-]ieee-fp
-mp
Maintain floating-point precision (disables some optimizations). The -mp option restricts optimization 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 precision.
-mp1
Improve floating-point precision. -mp1 disables fewer optimizations and has less impact on performance than -mp.
-msse (i32 only)
Generate code for Intel Pentium III and compatible Intel processors.
-msse2 (i32 only)
Generate code for Intel Pentium 4 and compatible Intel processors.
-msse3 (i32, i32em only)
Generate code for Intel Pentium 4 processors with SSE3 extensions.
-mtune=<cpu>
Optimize for a specific <cpu> processor.
-O0
Disable optimizations.
-O
Same as -O2
-O1
Optimize to favor code size and code locality. Disables loop unrolling. -O1 may improve performance for applications with very large code size, many branches, and execution time not dominated by code within loops. In most cases, -O2 is recommended over -O1.

i32: Disable intrinsics inlining to reduce code size.

i64: Disable software pipelining and global code scheduling.

-O2 (DEFAULT)
Optimize for code speed. This is the generally recommended optimization level.

i64: Turn software pipelining ON.

-O3
Enable -O2 optimizations and in addition, enable more aggressive optimizations such as loop and memory access transformation, and prefetching. The -O3 option optimizes for maximum speed, but may not improve performance for some programs. 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 calculations and process large data sets. Turn on high-level optimizations. Enable -O2 plus more aggressive optimizations, such as loop transformation.

i32, i32em: In conjunction with -ax{K|W|N|B|P} and -x{K|W|N|B|P} options, this option causes the compiler to perform more aggressive data dependency analysis than for -O2. This may result in longer compilation times.

-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 -- Inlines any function, at the compiler's discretion. Enables interprocedural optimizations and has the same effect as -ip.

-Os
Enable speed optimizations, but disable some optimizations that increase code size for small speed benefit.
-pc<n> (i32, i32em only)
Enable floating-point significand precision control. Some floating-point algorithms are sensitive to the accuracy of the significand, or fractional part of the floating-point value. For example, iterative operations like division and finding the square root can run faster if you lower the precision with the -pc<n> option. Set <n> to one of the following values to round the significand to the indicated number of bits:

32: 24 bits (single precision) -- Caution: A change of the default precision control or rounding mode (for example, by using the -pc32 flag or by user intervention) may affect the results returned by some of the mathematical functions.

64: 53 bits (single precision)

80: 64 bits (double precision) -- DEFAULT

-[no-]prec-div (i32, i32em only)
Improve precision of floating-point divides (some speed impact). With some optimizations the Intel C++ Compiler changes floating-point division computations into multiplication by the reciprocal of the denominator. For example, A/B is computed as A x (1/B) to improve the speed of the computation. However, for values of B greater than 2126, the value of 1/B is "flushed" (changed) to 0. When it is important to maintain the value of 1/B, use -[no-]prec-div to disable the floating-point division-to-multiplication optimization. The result of -[no-]prec-div is more accurate, with some loss of performance.
-[no-]prec-sqrt (i32, i32em only)
Determine if certain square root optimizations are enabled.
-rcd (i32, i32em only)
Enable fast float-to-int conversions. The Intel compiler uses the -rcd option to improve the performance of code that requires floating-point-to-integer conversions. The system default floating point rounding mode is round-to-nearest. However, the C language requires floating point values to be truncated when a conversion to an integer is involved. To do this, the compiler must change the rounding mode to truncation before each floating-point-to-integer conversion and change it back afterwards. The -rcd option disables the change to truncation of the rounding mode for all floating point calculations, including floating point-to-integer conversions. Turning on this option can improve performance, but floating point conversions to integer will not conform to C semantics.
-x<codes> (i32, i32em only)
Generate specialized code to run exclusively on processors supporting the extensions indicated by <codes>. <codes> includes one or more of the following characters:

K -- Intel Pentium III processors and compatible Intel processors

W -- Intel Pentium 4 processors and compatible Intel processors

N -- Intel Pentium 4 processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific optimizations.

B -- Intel Pentium M processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific optimizations.

P -- Intel Pentium 4 Processors with Streaming SIMD Extensions 3 (SSE3) instruction support. Enables new optimizations in addition to Intel processor-specific optimizations.

Note: The only options available on Intel(R) EM64T-based systems are -xW and -xP.

You can use more than one of the -x options by combining the characters that denote the processor type. For example, you can specify -xKW to generate code for Intel(R) Pentium(R) III and Intel Pentium 4 processors (though the -xW option does not support i32em features).

Note: Programs compiled using option -xN, -xB, or -xP will display a fatal run-time error if executed by an unsupported processor. For more information, see the Intel C++ Compiler User's Guide.

 

Advanced Performance Options

The advanced performance options allow fine tuning of compilation or allow control over advanced features of the compiler.
-[no-]alias-args
Assume arguments may be aliased. (DEFAULT) [not aliased].
-[no-]ansi-alias
The -[no-]ansi-alias option 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.
-auto-ilp32 (i32em, i64 only)
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.

Note: The -auto-ilp32 option applies to i64 and i32em, but with i32em it has no effect unless option -xP or option -axP is also specified. It does not apply to i32.

-[no-]complex-limited-range
Tell 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 uses a better formulation of complex arithmetic operations, thus producing acceptable results for the full range of input values, though at some loss in performance.
-fargument-alias
Same as -alias-args.
-fargument-noalias
Same as -no-alias-args.
-fargument-noalias-global
Arguments do not alias each other and do not alias global storage.
-fnsplit[-]
Enable[disable] function splitting. Function splitting 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 contain 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 capability. 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 debugging capability.


       *
When the profile data does not represent the actual program behavior, that is, when the routine is actually used frequently rather than infrequently.
-fp-model <name>
Enable <name> floating point model variation.
-ftls-model=<model>
Change thread-local storage model, where <model> can be the following:


       *
global-dynamic


       *
local-dynamic


       *
initial-exec


       *
local-exec
-ftz (i64 only)
Flush denormal results to zero.
-funroll-loops
Unroll loops based on default heuristics.
-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.
-IPF-flt-eval-method0 (i64 only)
Direct the compiler to evaluate the expressions involving floating-point operands in the precision indicated by the variable types declared in the program.
-[no-]IPF-fltacc (i64 only)
Enable [disable] optimizations that affect floating point accuracy. By default (-IPF-fltacc-) the compiler may apply optimizations that reduce floating-point accuracy. You may use -IPF-fltacc or -mp to improve floating-point accuracy, but at the cost of disabling some optimizations.
-[no-]IPF-fma (i64 only)
Enable [disable] the combining of floating point multiplies and add/subtract operations. -IPF-fma[-] enables [disables] the contraction of floating-point multiply and add/subtract operations into a single operation. Unless -mp is specified, the compiler contracts these operations whenever possible. The -mp option disables the contractions. -IPF-fma and -IPF-fma- can be used to override the default compiler behavior.
-[no-]IPF-fp-relaxed (i64 only)
Enable [disable] use of faster but slightly less accurate code sequences for math functions, such as divide and square root.
-IPF-fp-speculation{fast|safe|strict|off} (i64 only)
Enable floating point speculations with the following conditions:

fast -- Speculate floating point operations

safe -- Speculate only when safe

strict -- Same as off

off -- Disables speculation of floating-point operations

-ip-no-inlining
Disable inlining that would result from the -ip interprocedural optimization, but has no effect on other interprocedural optimizations.
-ip-no-pinlining (i32, i32em only)
Disable partial inlining (requires -ip or -ipo)
-ipo[value]
Enables multifile IP optimizations (between files). When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files.

The [value] argument is an optional integer that specifies the number of object files the compiler should create. Any integer greater than or equal to 0 is valid.

If [value] is 0, the compiler decides whether to create one or more object files based on an estimate of the size of the object file. It generates one object file for small applications, and two or more object files for large applications.

If [value] is positive, the compiler generates [value] object files, unless [value] exceeds the number of source files (m), in which case the compiler generates only m object files.

If you do not specify [value], the default is 1.

-ipo-c
Generate a multi-file object file (ipo-out.o) that can be used in further link steps.
-[no-]ipo-obj
Force the compiler to create real object files when used with -ipo (requires -ipo).
-ipo-S
Generate a multi-file assembly file (ipo-out.s) that can be used in further link steps.
-ipo-separate
Creates one object file for every source file. This option overrides -ipo[value].
-ivdep-parallel (i64 only)
Indicate there is absolutely no loop-carried memory dependency in any loop where IVDEP directive is specified. This technique is useful for some sparse matrix applications.
-mno-serialize-volatile (i64 only)
Memory access ordering for volatile data object references may be suppressed.
-mserialize-volatile (i64 only)
Enable strict memory access ordering for volatile data object references.
-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 multiprocessor 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-profile
Enables analysis of OpenMP* applications with Intel(R) Thread Profiler, which is required to use this option.
-openmp-report[<n>]
Control the OpenMP parallelizer's level of diagnostic messages, where <n> is one of the following:

0 -- no diagnostic information is displayed.

1 -- Display diagnostics indicating loops, regions, and sections successfully parallelized. (DEFAULT)

2 -- same as -openmp-report1 plus diagnostics indicating MASTER constructs, SINGLE constructs, CRITICAL constructs, ORDERED constructs, ATOMIC directives, etc. successfully handled.

-openmp-stubs
Enable the user to compile OpenMP programs in sequential mode. The openmp directives are ignored and a stub OpenMP library is linked (sequential).
-opt-report (i32em, i64 only)
Generate an optimization report and direct it to stderr.

DEFAULT: The compiler does not generate optimization reports.

-opt-report-file<file> (i32em, i64 only)
Specify the filename for the generated report
-opt-report-help (i32em, i64 only)
List the logical names of optimizers available for report generation.
-opt-report-level[<level>] (i32em, i64 only)
Specify the level of report verbosity, where <level> is one of the following:

min -- The min argument provides the minimal summary (DEFAULT)

med -- The med argument produces an intermediate-level report.

max -- The max argument produces the full report.

-opt-report-phase<name> (i32em, i64 only)
Specify the optimizer phase against which reports are generated. The compiler generates reports for the optimizer you specify in the <name>. This option can be used multiple times on the same command line to generate reports for multiple optimizers. Currently, the following optimizer reports are supported:

ipo -- Interprocedural Optimizer

hlo -- High Level Optimizer

ilo -- Intermediate Language Scalar Optimizer

ecg -- Code Generator

omp -- OpenMP

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-routine<substring> (i32em, i64 only)
Generate reports from all routines with names containing <substring> as part of their name. If <substring> is not specified, reports from all routines are generated.

DEFAULT: The compiler generates reports for all routines.

-p
Compile and link for function profiling with Linux gprof* tool. Same as -qp.
-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).
-par-report[<n>]
Control the level of auto-parallelizer diagnostic messages, 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" message 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 parallelizing).

-par-threshold[<n>]
Set a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel. This option is used for loops whose computation work volume cannot be determined at compile-time. The threshold is usually 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 balance the overhead of creating multiple threads versus the amount of work available to be shared amongst the threads.

-[no-]prefetch
Enables [disables] the insertion of software prefetching by the compiler. Default is -prefetch.
-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, especially 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
-prof-gen[x]
Instruct the compiler to produce instrumented code in your object files in preparation for instrumented 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 preparation for instrumented execution. Parallel make is automatically supported for -prof-genx compilations.
-prof-gen-sampling
Prepare code for use with the profrun sample gathering tool.
-prof-use
Instruct the compiler to produce a profile-optimized executable and merge available dynamic information (.dyn) files into a pgopti.dpi file. Use the -prof-use option in Phase 3 of PGO.
-qp
Compile and link for function profiling with Linux gprof* tool. Same as -p.
-tcheck
The -tcheck compiler option enables analysis of threaded applications with Intel(R) Thread Checker, which is required to use this option.
-unroll<n> (i32, i32em only)
Set maximum number of times to unroll loops. This applies only to loops that the compiler determines should be unrolled. Omit n to let the compiler decide whether to perform unrolling or not. Use n=0 to disable loop unrolling.
-unroll0 (i64 only)
Disable loop unrolling (i64-only). For i64: the only allowed value is 0.
-vec-report[<n>] (i32, i32em only)
Control the vectorizer's level of diagnostic messages, where <n> is one of the following:

0 -- No diagnostic information

1 -- Indicate vectorized loops (DEFAULT)

2 -- Indicate vectorized/non-vectorized loops

3 -- Indicate vectorized/non-vectorized loops and prohibiting data dependence information

4 -- Indicate non-vectorized loops

5 -- Indicate non-vectorized loops and prohibiting data dependence information

If you use -c, -ipo with -vec-report{n} option or -c, -x{K|W|N|B|P} or -ax{K|W|N|B|P} with -vec-report[<n>], the compiler issues a warning and no report is generated.

To produce a report when using the aforementioned options, you need to add the -ipo-obj option. The combination of -c and -ipo-obj produces a single file compilation, and hence does generate object code, and eventually a report is generated.

 

Output, Debug, and PCH Options

The output, debug, and PCH options provide control over compiler output, setup for debugging, and use of the precompiled header features of the compiler.
-c
Compile to object (.o) only, do not link.
-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 <filename>. 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 filename. This option cannot be used in the same compilation as -use-pch filename. The -create-pch filename option is supported for single source file compilations only.
-[no-]debug[keyword]
Enable debug information and control output of enhanced debug information. The supported [keywords] are extended, [no]variable-locations, [no]semantic-stepping, [no-]expr-source-pos, and [no]inline_debug_info}. The debug switches control emission of enhanced debug information. They must be used in conjunction with the basic -g switches that request debug information.

extended -- Turns on the -debug options;


       *
-debug [no-]expr-source-pos,

       *
-debug [no]variable-locations,

       *
-debug [no]semantic-stepping, and

       *
-debug [no]inline_debug_info.

[no-]expr-source-pos -- Determines whether source position information at the expression level of granularity is produced.

[no]variable-locations -- Determines whether enhanced debug information useful in finding scalar local variables is produced.

[no]semantic-stepping -- Determines whether enhanced debug information useful for breakpoints and stepping is produced.

[no]inline_debug_info -- Determines whether enhanced debug information is produced for inlined code.

-fcode-asm
Produce assembly file with optional code annotations.
-fsource-asm
Produce assembly file with optional code annotations.
-ftrapuv
Initializes stack local variables to an unusual value to help error detection.
-f[no]verbose-asm
Produce assembly file with compiler comments (DEFAULT).
-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 assemblable file will not. The -g option changes the default optimization from -O2 to -O0. 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 optimizations. 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. i32 only: Specifying the -g or -O0 option automatically enables the -fp option.
-g0
Disable generation of symbolic debug information.
-inline-debug-info
Preserve the source position of inlined code instead of assigning the call-site source position to inlined code.
-map-opts
Enable option mapping tool.
-o<file>
Name output file.
-pch
Automatic processing for precompiled headers. Direct the compiler to use appropriate PCH files. If none are available, they are created as sourcefile.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.

-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 filename.
-print-multi-lib
Print information about libraries being used.
-S
Compile to an assemblable file (.s), then stop the compilation.
-use-asm
Produce objects through the assembler.
-use-msasm (i32, i32em only)
Support Microsoft* style assembly language insertion using MASM style syntax and, if requested, output assembly in MASM format.
-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.
 

Preprocessor Options

The preprocessor options listed here control preprocessing operations for the compiler.
-A-
Remove all predefined macros. Causes all predefined macros and assertions to be inactive.
-A<name>[<value(s)>]
Associate a symbol <name> with the specified sequence of <value(s)>. Equivalent to an #assert preprocessing directive.
-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 preprocessing directive.

DEFAULT: -D<name> defines the macro <name> with a <value> of 1.

-dM
Output macro definitions in effect after preprocessing (use with -E).
-E
Direct the preprocessor to expand your source module 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.
-EP
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.
-H
Print "include" file order and continue compilation.
-I<dir>
Add directory <dir> to include file search path. For multiple 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).
-imacros<file>
Treat <file> as an #include file, but throw away all preprocessing while the macros that are defined remain defined.
-iprefix<prefix>
Use <prefix> with -iwithprefix as a prefix.
-isystem<dir>
Add directory <dir> to the start of the system include path.
-iwithprefix<dir>
Append <dir> to the prefix passed in by -iprefix and put it on the include search path at the end of the include directories.
-iwithprefixbefore<dir>
Similar to -iwithprefix except the include directory is placed in the same place as the -I command line include directories.
-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.
-MP
Add a phony target for each dependency.
-MQ<target>
Same as -MT, but quotes special Make characters.
-MT<target>
Change the default target rule for dependency generation.
-no-gcc
Do not predefine the __GNUC__, __GNUC_MINOR__, and __GNUC_PATCHLEVEL__ macros.
-nostdinc
Same as  X.
-P
Direct the preprocessor to expand your source module and store the result in a .i file in the current 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 overwritten.

-ssp (i32 only)
Enable software-based speculative pre-computation.
-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.
 

Component Control Options

You can direct the compiler to specify alternate tools for preprocessing, compilation, assembly, and linking. Further, you can invoke options specific to your alternate tools on the command line. These are the component control options.
-Qinstall <dir>
Set <dir> as the root of the compiler installation.
-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. For example:

-Qlocation,gas,<path> Specifies the GNU assembler.

-Qlocation,gld,<path> Specifies the GNU linker.

-Qoption,<tool>,<optlist>
Pass options <optlist> to the tool specified by <tool>. <tool> may be cpp, c, asm, or ld. The <optlist> argument indicates one or more valid argument strings for the designated program. If the argument is a command-line option, you must include the hyphen. If the argument contains a space or tab character, you must enclose the entire argument in quotation characters (""). You must separate multiple arguments with commas.
 

Language Options

The language options define parameters and standards for the compiler with reference to the C/C++ source files.
-[no]align (i32, i32em only)
Analyze and reorder memory layout for variables and arrays.
-ansi
Support all ANSI standard C programs, equivalent to the -ansi option of gcc.
-[no-]c99
Enable [disable] C99 support for C programs.
-export
Enable recognition of exported templates. Supported in C++ mode only.
-export-dir <dir>
Specifies a directory name for the exported template search path.
-fno-gnu-keywords
Do not recognize 'typeof' as a keyword.
-fno-implicit-inline-templates
Do not emit code for implicit instantiations of inline templates.
-fno-implicit-templates
Never emit code for non-inline templates which are instantiated implicitly (i.e. by use); only emit code for explicit instantiations.
-fno-operator-names
Disable support for operator name keywords.
-fpermissive
Allow for non-conformant code.
-f[no-]rtti
Enable [disable] RTTI support.
-fshort-enums
Allocate as many bytes as needed for enumerated types.
-fsyntax-only
Same as -syntax.
-ftemplate-depth-<n>
Control the depth to which recursive templates are expanded.
-funsigned-bitfields
Change default bitfield type to unsigned.
-funsigned-char
Change default char type to unsigned.
-Kc++
Compile all source or unrecognized file types as C++ source files.
-malign-double
Same as -align.
-[no]restrict
Enable [disable] the "restrict" keyword for disambiguating pointers.
-std=c99
Enable C99 support for C programs
-strict-ansi
Select strict ANSI C/C++ conformance dialect
-Zp[n]
Specify alignment constraint for structure and union types, where n is one of the following: 1,2,4,8,16.
 

Compiler Diagnostics Options

The compiler diagnostics options define and control aspects of the compilation associated with diagnostics.
-[no]traceback
Tells the compiler to generate [not generate] extra information in the object file to allow the display of source file traceback information at run time when a severe error occurs
-w
Disable all warnings. Displays error messages only.
-w<n>
Control diagnostics, where <n> is one of the following:

0 -- Display errors (same as -w)

1 -- Display warnings and errors (DEFAULT)

2 -- Display remarks, warnings, and errors

-W[no-]abi
Warn if generated code is not C++ ABI compliant (DEFAULT).
-Wall
Enable all warnings.
-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 compile-time code checking for code that exhibits non-portable behavior, represents a possible unintended code sequence, or possibly affects operation of the program because of a quiet change in the ANSI C Standard.
-W[no-]comment[s]
Warn when /* appears in the middle of a /* */ comment.
-Wcontext-limit=<n>
Set maximum number of template instantiation contexts shown in diagnostic.
-wd<L1>[,<L2>,...<LN>]
Disable diagnostics L1 through LN.
-W[no-]deprecated
Print warnings related to deprecated features.
-we<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to error.
-Werror
Force warnings to be reported as errors.
-Winline
Enable inline diagnostics.
-W[no-]main
Warn if return type of main is not expected.
-W[no-]missing-prototypes
Warn for missing prototypes.
-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.
-Wp64 (i64, i32em only)
Print diagnostics for 64-bit porting.
-W[no-]pointer-arith
Warn for questionable pointer arithmetic.
-wr<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to remark.
-W[no-]return-type
Warn when a function uses the default int return type and warn when a return statement is used in a void function.
-W[no-]shadow
Warn if a variable declaration hides a previous variable declaration.
-W[no-]uninitialized
Warn if a variable is used before being initialized.
-W[no-]unknown-pragmas
Warn if an unknown #pragma directive is used (DEFAULT).
-W[no-]unused-function
Warn if declared function is not used.
-ww<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to warning.
 

Miscellaneous Options

The miscellaneous options cover a variety of unrelated tasks related to the compiler.
-B<prefix>
Specifies where to find libraries, headers, and executables for the compiler itself.
-dryrun
Show driver tool commands but do not execute tools.
-f[no-]common
Enables the compiler to treat common variables as if they were defined, allowing the use of gprel addressing of common data variables.
-f[no-]math-errno
Set ERRNO after calling standard math library functions.
-fminshared
Compilation is for the main executable. Absolute addressing can be used and non-position independent code generated for symbols that are at least protected.
-fno-builtin
Disable inline expansion of intrinsic functions.
-fno-builtin-<func>
Disable the <func> intrinsic.
-fpack-struct
Pack structure members together.
-f[no-]pic, -f[no-]PIC
i32: This option generates position independent code. By default this option is OFF.

i64: This option generates code allowing full symbol preemption. By default this option is OFF.

-fr32 (i64 only)
Disable use of high floating point registers. Use only lower 32 floating-point registers.
-freg-struct-return
Return struct and union values in registers when possible.
-fstack-security-check (i32, i32em only)
Enable overflow security checks.
-fvisibility=[extern|default|protected|hidden|internal]
Global symbols (data and functions) will get the visibility attribute given by default. Symbol visibility attributes explicitly set in the source code or using the symbol visibility attribute file options will override the -fvisibility setting.
-fvisibility-default=<file>
Space separated symbols listed in the <file> argument will get visibility set to default.
-fvisibility-extern=<file>
Space separated symbols listed in the <file> argument will get visibility set to extern.
-fvisibility-hidden=<file>
Space separated symbols listed in the <file> argument will get visibility set to hidden.
-fvisibility-internal=<file>
Space separated symbols listed in the <file> argument will get visibility set to internal.
-fvisibility-protected=<file>
Space separated symbols listed in the <file> argument will get visibility set to protected.
-gcc-name=<name>
Use this option to specify the location of g++ when compiler cannot locate gcc C++ libraries. For use with -cxxlib-<mode> configuration. Use this option when referencing a non-standard gcc installation.
-gcc-version=<nnn>
This option provides compatible behavior with gcc, where <nnn> indicates the gcc version. The required values for <nnn> are:

not set -- if gcc version is older than 3.2

320 -- if gcc version is 3.2

330 -- if gcc version is 3.3

340 -- if gcc version is 3.4

-[no-]global-hoist
Enables [disables] hoisting and speculative loads of global variables.
-help
Print list of compiler options.
-kernel (i64 only)
Generates code for inclusion in the kernel. Prevents generation of speculation as support may not be available when code runs. Suppresses software pipelining.
-long_double
Enable 80-bit 'long double'.
-mfixed-range=f12-f15,f32-f127 (i64 only)
Reserves certain registers (f12-f15, f32-f127) for use by the kernel.
-[no-]multibyte-chars
Provide support for multi-byte characters.
-nobss-init
Place variables that are initialized with zeroes in the DATA section instead of the BSS section.
-reserve-kernel-regs (i64 only)
Reserves registers f12-f15 and f32-f127 for use by the kernel. These will not be used by the compiler.
-[no-]sox
Enable (DEFAULT) [disable] saving of compiler options and version in the executable.
-V
Display compiler version information.
-v
Show driver tool commands and execute tools.
--version
Display GCC style version information. Note that two '-'s are required.
-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

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

 

Linking or Linker Options

The linking/linker options group all link-related options together.
-cxxlib-<mode>
Tells the compiler to link using certain C++ runtime libraries. You can specify one of the following values for <mode>:

gcc[=<dir>] -- Link using the C++ run-time libraries provided with the gcc compiler. The <dir>parameter is an optional top-level location for the gcc binaries and libraries.

icc -- Link using the C++ run-time libraries provided by Intel.

-dynamic-linker<filename>
Select a dynamic linker (filename) other than the default.
-i-dynamic
Link Intel provided libraries dynamically.
-i-static
-L<dir>
Instruct the linker to search <dir> for libraries.
-mno-relax (i64 only)
Do not pass -relax to the linker.
-mrelax (i64 only)
Pass -relax to the linker.
-no-cpprt
Do not link in C++ runtime libraries.
-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.
-shared
Produce a shared object.
-shared-libcxa
Link Intel libcxa C++ library dynamically, overriding 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.
-static
Prevent linking with shared libraries. Causes the executable to link all libraries statically, as opposed to dynamically.
-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.
-T <file>
Direct linker to read link commands from <file>.
-u <symbol>
Pretend the <symbol> is undefined.
-Wa<o1>[,<o2>,...]
-Wl,<o1>[,<o2>,...]
-Wl,<o1>[,<o2>,...]
Pass options o1, o2, etc. to the linker for processing.
-Xlinker <val>
Pass <val> directly to the linker for processing.
 

Optimization Levels

The Intel C++ Compiler applies the following optimizations when you invoke the -O1, -O2, or -O3 options:
*
Constant propagation
*
Copy propagation
*
Dead-code elimination
*
Global register allocation
*
Instruction scheduling
*
Loop unrolling (-O2, -O3 only)
*
Loop-invariant code movement
*
Partial redundancy elimination
*
Strength reduction/induction variable simplification
*
Variable 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 -O[0|1|2|3], -fast, -ax<code>, -x<code>, and related options.  

Optimizing Exclusively for Specific Processors (i32, i32em only)

The -x{K|W|N|B|P} options target your program to run on a specific Intel processor. The resulting code might contain unconditional use of features that are not supported on other processors. If these options are used on a non-compatible processor, the program might fail with an illegal instruction exception, or it might display other unexpected behavior. Do not specify this option if the program will be executed on x86 processors not provided by Intel Corporation. For more information, see the Intel C++ Compiler User's Guide.  

Automatic Processor-specific Optimization (i32, i32em Only)

The -ax{K|W|N|B|P} options direct the compiler to find opportunities to generate separate versions of functions that use instructions supported on the specified processors. If the compiler finds such an opportunity, it first checks whether generating a processor-specific version of a function is likely to result in a performance gain. If so, the compiler generates both a processor-specific version of a function and a generic version of the function. The generic version will run on any IA-32 processor.

At run time, one of the versions is chosen to execute, depending on the current processor. In this way, the program can benefit from performance gains on more advanced processors, while still working properly on older processors.

The disadvantages of using -ax{K|W|N|B|P} are:

*
The size of the compiled binary increases because it contains both a processor-specific version of some of the code and a generic version of the code.
*
Performance is affected by the run-time checks to determine which code to run.
 

Interprocedural Optimizations (IPO)

Use -ip and -ipo[value] to enable interprocedural optimizations (IPO), which allow the compiler to analyze your code to determine where to apply the following optimizations: inline function expansion, interprocedural constant propagation, monitoring module-level static variables, dead code elimination, propagation of function characteristics, and multifile optimization. For IA-32, IPO also passes arguments in registers.

Inline function expansion is one of the main optimizations performed by the interprocedural optimizer. For function calls that the compiler believes are frequently executed, the compiler might decide to replace the instructions of the call with code for the function itself (inline the call).

See the Intel C++ Compiler User's Guide for more complete information on IPO.  

Profile-guided Optimizations (PGO)

Profile-guided optimizations (PGO) tell the compiler which areas of an application are most frequently executed. By knowing these areas, the compiler is able to use feedback from a previous compilation to be more selective in optimizing the application. For example, the use of PGO often enables the compiler to make better decisions about function inlining, thereby increasing the effectiveness of interprocedural optimizations.

PGO creates an instrumented program from your source code and special code from the compiler. Each time this instrumented code is executed, the instrumented program generates a dynamic information file. When you compile a second time, the dynamic information files are merged into a summary file. Using the profile information in this file, the compiler attempts to optimize the execution of the most heavily traveled paths in the program.

The PGO methodology requires three phases:

Phase 1:
Instrumentation compilation and linking with -prof-gen[x]
Phase 2:
Instrumented execution by running the executable
Phase 3:
Feedback compilation with -prof-use

See the Intel C++ Compiler User's Guide for more complete information on PGO.  

High-level Language Optimizations (HLO)

High-level language optimizations (HLO) exploit the properties of source code constructs, such as loops and arrays, in applications developed in high-level programming languages, such as C++. They include loop interchange, loop fusion, loop unrolling, loop distribution, unroll-and-jam, blocking, data prefetch, scalar replacement, data layout optimizations, and others.  

Vectorization Options (i32 only)

The vectorizer is a component of the Intel C++ Compiler that automatically uses SIMD instructions in the MMX, SSE, and SSE2 instruction sets. The vectorizer detects operations in the program that can be executed in parallel, and then converts the sequential program to process 2, 4, 8, or 16 elements in one operation, depending on the data type.

The -x{K|W|N|B|P} and -ax{K|W|N|B|P} options enable the vectorizer. See the Intel C++ Compiler User's Guide for more complete information on the vectorizer.  

Auto Parallelization Options

The auto-parallelization feature of the Intel C++ Compiler automatically translates serial portions of the input program into equivalent multithreaded code. The auto-parallelizer analyzes the dataflow of the program's loops and generates multithreaded code for those loops which can be safely and efficiently executed in parallel. This enables the potential exploitation of the parallel architecture found in symmetric multiprocessor (SMP) systems.

The parallel run-time support provides the same run-time features found in OpenMP*, such as handling the details of loop iteration modification, thread scheduling, and synchronization.

While OpenMP directives enable serial applications to transform into parallel applications quickly, the programmer must explicitly identify specific portions of the application code that contain parallelism and add the appropriate compiler directives. Auto-parallelization triggered by the -parallel option automatically identifies those loop structures that contain parallelism. During compilation, the compiler automatically attempts to decompose the code sequences into separate threads for parallel processing. No other effort by the programmer is needed.  

Parallelization with OpenMP*

The Intel C++ Compiler supports the OpenMP* C++ version 2.0 API specification. The 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 software. The Intel compiler supports all of the current industry-standard OpenMP directives, except WORKSHARE, and compiles parallel programs annotated with OpenMP directives. In addition, the 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.  

Precompiled Headers

The Intel C++ Compiler supports precompiled header (PCH) files to significantly reduce compile times using the options described below. If many of your source files include a common set of header files, place the common headers first, followed by the #pragma hdrstop directive. This pragma instructs the compiler to stop generating PCH files.

For example, if source1.cpp, source2.cpp, and source3.cpp all include common.h, then place #pragma hdrstop after common.h to optimize compile times. See the Intel C++ Compiler User's Guide for more complete information on Precompiled Headers.

Caution: Depending on how you organize the header files listed in your sources, these options might increase compile time.  

PREDEFINED MACROS

The predefined macros available for the Intel C++ Compiler are described below.

Intel C++ Compiler Predefined Macros

__ECC
Value on IA-32 -- NA

Value on Itanium Architecture -- 800

Notes -- Assigned value refers to the compiler (e.g., 800 is 8.00). Supported for legacy reasons. Use __INTEL_COMPILER instead.

__EDG__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__EDG_VERSION__
Value on IA-32 -- 302

Value on Itanium Architecture -- 302

__ELF__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__EXCEPTIONS
Value on IA-32 -- Defined when -fno-exceptions is not used.

Value on Itanium Architecture -- NA

__extension__
Value on IA-32 -- no value

Value on Itanium Architecture -- no value

__GNUC__
Values on IA-32 or Itanium Architecture --

2 -- if gcc version is less than 3.2

3 -- if gcc version is 3.2, 3.3, or 3.4

__gnu_linux__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__GNUC_MINOR__
Values on IA-32 or Itanium Architecture --

95 -- if gcc version is less than 3.2

2 -- if gcc version is 3.2

3 -- if gcc version is 3.3

4 -- if gcc version is 3.4

__GNUC_PATCHLEVEL__
Value on IA-32 -- 0

Value on Itanium Architecture -- 0

__GXX_ABI_VERSION
Value on IA-32 -- 102

Value on Itanium Architecture -- 102

__HONOR_STD
Value on IA-32 -- 1
__i386
Value on IA-32 -- 1

Value on Itanium Architecture -- NA

__i386__
Value on IA-32 -- 1

Value on Itanium Architecture -- NA

i386
Value on IA-32 -- 1

Value on Itanium Architecture -- NA

__ia64
Value on IA-32 -- NA

Value on Itanium Architecture -- 1

__ia64__
Value on IA-32 -- NA

Value on Itanium Architecture -- 1

ia64
Value on IA-32 -- NA

Value on Itanium Architecture -- 1

__ICC
Value on IA-32 -- 800

Value on Itanium Architecture -- NA

Notes -- Assigned value refers to the compiler (e.g., 800 is 8.00). Supported for legacy reasons. Use __INTEL_COMPILER instead.

__INTEL_COMPILER
Value on IA-32 -- 800

Value on Itanium Architecture -- 800

Notes -- Defines the compiler version. Defined as 800 for the Intel C++ Compiler 8.0.

__INTEL_COMPILER_BUILD_DATE=<YYYYMMDD>

Notes -- Defines the compiler build date. This date should correspond to the date on the compiler version banner. Applies to both IA-32 and Itanium Architecture.

__INTEL_RTTI__

Notes -- Is defined (default) when the -frtti option is specified for the Intel Linux C++ compiler (i.e., when RTTI support is enabled). It is disabled when the the -fno-rtti option is specified for the Intel Linux C++ compiler. Applies to both IA-32 and Itanium Architecture.

__INTEL_STRICT_ANSI__

Notes -- Enabled when the -strict_ansi option is specified for the Intel Linux C++ compiler (i.e., strict ANSI conformance dialect). Applies to both IA-32 and Itanium Architecture.

_INTEGRAL_MAX_BITS
Value on IA-32 -- NA

Value on Itanium Architecture -- 64

Notes -- Indicates support for the __int64 type.

__itanium__
Value on Itanium Architecture -- 1
__linux
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__linux__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

linux
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__LONG_DOUBLE_SIZE__
Value on IA-32 -- 80

Value on Itanium Architecture -- NA

__LONG_MAX__
Value on IA-32 -- NA

Value on Itanium Architecture -- 9223372036854775807L

__lp64
Value on IA-32 -- NA

Value on Itanium Architecture -- 1

__LP64__
Value on IA-32 -- NA

Value on Itanium Architecture -- 1

__LP64
Value on IA-32 -- NA

Value on Itanium Architecture -- 1

_OPENMP
Value on IA-32 -- 200203

Value on Itanium Architecture -- 200203

Notes -- Defined when -openmp is used.

__OPTIMIZE__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

Notes -- Not enabled if all optimizations are turned off.

_PGO_INSTRUMENT
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

Notes -- Defined when compiled with either -prof_gen or -prof_genx.

__PTRDIFF_TYPE__
Value on IA-32 -- int

Value on Itanium Architecture -- long

__QMSPP_
Value on IA-32 -- 1

Value on Itanium Architecture -- NA

__REGISTER_PREFIX__
Value on IA-32 -- no value

Value on Itanium Architecture -- no value

__SIGNED_CHARS__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__SIZE_TYPE__
Value on IA-32 -- unsigned

Value on Itanium Architecture -- unsigned long

__STDC_HOSTED__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__unix
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__unix__
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

unix
Value on IA-32 -- 1

Value on Itanium Architecture -- 1

__USER_LABEL_PREFIX__
Value on IA-32 -- (no value)

Value on Itanium Architecture -- (no value)

__WCHAR_TYPE__
Value on IA-32 -- long int

Value on Itanium Architecture -- int

__WINT_TYPE__
Value on IA-32 -- unsigned int

Value on Itanium Architecture -- unsigned int

 

ANSI/ISO Macros Included with the Compiler

The ANSI/ISO standard for C language requires that certain predefined macros be supplied with conforming compilers. The Intel C++ Compiler supplies the following macros in accordance with this standard, as well as additional predefined macros:
__cplusplus
The name __cplusplus is defined when compiling a C++ translation unit.
__DATE__
The date of compilation as a string literal in the form Mmm dd yyyy.
__FILE__
A string literal representing the name of the file being compiled.
__LINE__
The current line number as a decimal constant.
__STDC__
The name __STDC__ is defined when compiling a C translation unit.
__TIME__
The time of compilation. As a string literal in the form hh:mm:ss.
 

gcc Predefined Macros

This version of the Intel C++ Compiler includes the following new predefined macros also supported by gcc:

__GNUC__

__GNUC_MINOR__

__GNUC_PATCHLEVEL__

You can specify the -no-gcc option if you do not want these macros defined. If you need gcc interoperability (-cxxlib-gcc),  do not use the -no-gcc compiler option.  

Suppress Macro Definition

Use the -Uname option to suppress any macro definition currently in effect for the specified name. The -U option performs the same function as an #undef preprocessor directive.  

ENVIRONMENT VARIABLES

You can customize your environment by setting the following 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 (i32 only)
Points to the directory containing the bin, lib, include and substitute header directories.
IA64ROOT (i64 only)
Points to the directory containing the bin, lib, include and substitute header directories.
 

GNU* Environment Variables

The Intel C++ Compiler supports the following GNU environment 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 parallelism.

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

i32: 2m

i64: 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 information 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 information 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 additional dynamic information files.
PROF_DUMP_INTERVAL
Initiate Interval Profile Dumping in an instrumented application. The _PGOPTI_Set_Interval_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 application.
 

EXAMPLES

The following examples demonstrate optimizing across multiple input files:
  1.  icc ax.cpp
      This command compiles the C++ file 'ax.cpp' producing 
      executable file 'a.out'. Optimizations occur by default.
  2.  icc -o abc ax.cpp bx.cpp cx.cpp
      This command uses option -o to name the 
      executable file 'abc' and compiles 'ax.cpp', 
      'bx.cpp', and 'cx.cpp' as one program.
  3.  icc -c ax.cpp bx.cpp cx.cpp
      This command uses option -c to suppress 
      linking and produce individual object 
      files 'ax.o', 'bx.o', and 'cx.o'. Interprocedural 
      optimizations are prevented.
  4.  icc -c ay.c
      This command compiles the C file 'ay.c' and the -c option
      suppresses linking to produce of an object file 'ay.o'.
  5.  icpc -c by.cpp
      This command compiles the C++ file 'by.cpp' and the -c 
      option suppresses linking to produce an object file 'by.o'.
  6.  icpc ay.o by.o
      This command links the two object files 'ay.o' and 'by.o' 
      and produces an executable file 'a.out'.
  7.  icc -c -O1 sub2.cpp
      icc -c -O1 sub3.cpp
      icc -o main.exe -g -O0 main.cpp sub2.o sub3.o
      The first two commands show incremental 
      compilation with minimal optimization. 
      The first command generates an object 
      file of 'sub2'; the second generates
      an object file of 'sub3'.
      The last command uses option -O0 to 
      disable all compiler default optimizations. 
      It uses option -g to generate symbolic 
      debugging information and line numbers in 
      the object code, which can be used by a
      source-level debugger.  

TECHNICAL SUPPORT

The Intel C++ Compiler product web site offers timely and comprehensive product information, including product features, white papers, and technical articles. For the latest information, visit http://developer.intel.com/software/products/.

Intel also provides a support web site that contains a rich repository of self help information, including getting started tips, known product issues, product errata, license information, user forums, and more.

Registering your product entitles you to one year of technical support and product updates through Intel Premier Support. Intel Premier Support is an interactive issue management and communication web site that enables you to submit issues and review their status, and to download product updates anytime of the day.

To register your product, contact Intel, or seek product support, please visit: http://www.intel.com/software/products/support.  

SEE ALSO

The Intel C++ Compiler User's Guide is the definitive source for detailed information on using the Intel C++ Compiler, including a complete listing of all compiler options, and much more.

In addition, see these other documents:

*
Product Release Notes
*
Intel Itanium Assembler User's Guide
*
Intel Itanium Architecture Assembly Language Reference Guide
*
Enhancing Performance with the Intel Compiler (training)

You can access these documents from <install-dir>/doc/doc_index.htm or from http://developer.intel.com/software/products/compilers/ .  

COPYRIGHT INFORMATION

Copyright (C) 2002 - 2005, Intel Corporation. All rights reserved.

* Other brands and names are the property of their respective owners.


 

Index

NAME
SYNOPSIS
DESCRIPTION
gcc* Interoperability
OPTION SUMMARIES
Option Alphabetic Summary
Option Functional Summary
OPTION DESCRIPTIONS
Performance Options
Advanced Performance Options
Output, Debug, and PCH Options
Preprocessor Options
Component Control Options
Language Options
Compiler Diagnostics Options
Miscellaneous Options
Linking or Linker Options
Optimization Levels
Optimizing Exclusively for Specific Processors (i32, i32em only)
Automatic Processor-specific Optimization (i32, i32em Only)
Interprocedural Optimizations (IPO)
Profile-guided Optimizations (PGO)
High-level Language Optimizations (HLO)
Vectorization Options (i32 only)
Auto Parallelization Options
Parallelization with OpenMP*
Precompiled Headers
PREDEFINED MACROS
ANSI/ISO Macros Included with the Compiler
gcc Predefined Macros
Suppress Macro Definition
ENVIRONMENT VARIABLES
GNU* Environment Variables
Compilation Environment Options
Standard OpenMP Environment Variables
Intel Extensions to OpenMP Environment Variables
PGO Environment Variables
EXAMPLES
TECHNICAL SUPPORT
SEE ALSO
COPYRIGHT INFORMATION

This document was created by man2html, using the manual pages.
Time: 15:32:26 GMT, May 17, 2006