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 represents a C/C++ source (.C .c .cc .cp .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 process C and C++ programs on Intel architecture based systems. You can preprocess, compile, assemble, and link these programs.

This document explains how information and instructions apply differently to IA-32 architectures, Intel(R) 64 architectures, and IA-64 architectures. If a description does not explicitly state a specific architecture, assume the description is applicable to all. See the Intel C++ Compiler Documentation for more detailed information than what is presented here.

Most language features are available on all supported systems; however, some language features are only available on certain processors or a certain operating system. Such language features are labeled within parenthesis as follows:

i32
Means the feature is available on IA-32 architecture.
i64em
Means the feature is available on Intel(R) 64 architecture.
i64
Means the feature is available on IA-64 architecture.
L*X
Means the feature is available on Linux* systems.
M*X
Means the feature is available on all Intel(R)-based systems running Mac OS* X. In a few circumstances, the underlying architecture has bearing, so in those cases:

M*X32 -- Means the feature is available on systems based on IA-32 architecture that are running Mac OS* X.

M*X64 -- Means the feature is available on systems using Intel(R) 64 architecture that are running Mac OS* X.

If a labeled feature is only available on certain processors or operating systems, you will see the word (only) within the label along with the appropriate abbreviation(s). If a labeled feature is not available on a certain processor or operating system, you will see the words (not on) within the label along with the appropriate abbreviation. If no label appears, the feature is available on all supported architectures and operating systems.  

GNU 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. Some GNU gcc* versions are not interoperable, some versions are interoperable. By default, the Intel compiler will generate code that is interoperable with the version of gcc it finds on your system. The Intel(R) C++ Compiler options that affect GNU gcc* interoperability include:

*
-cxxlib
*
-gcc-name
*
-gcc-version
*
-gxx-name
*
-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(R) C++ Compiler Documentation for more information.  

OPTION SUMMARIES

 

Option Alphabetic Summary

This section includes an alphabetic listing of available Intel(R) C++ Compiler options. After each listing is a reference to the Functional area where a detailed description of the option appears. See Deprecated and Removed Options for additional information.

-A-
see Preprocessor
-A<name>[(val)]
see Preprocessor
-[no-]alias-args
see Advanced Optimization
-[no-]alias-const
see Advanced Optimization
-[no]align
see Language
-ansi
see Language
-[no-]ansi-alias
see Advanced Optimization
-auto-ilp32
see Data
-ax<codes>
see Code Generation, Vectorization Options
-B<dir>
see Compatibility
-Bdynamic
see Linking/Linker
-Bstatic
see Linking/Linker
-c
see Output, Debug, PCH
-C
see Preprocessor
-[no-]c99
see Language
-[no-]check-uninit
see Preprocessor
-[no-]clomp-sharable-info
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-[no-]clomp-sharable-propagation
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-cluster-openmp
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-cluster-openmp-profile
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-[no-]complex-limited-range
see Advanced Optimization
-create-pch <file>
see Output, Debug, PCH, Precompiled Headers
-[no-]cxxlib[=<dir>]
see Linking/Linker
-cxxlib-nostd
see Linking/Linker
-D<name>[=<value>]
see Preprocessor
-dD
see Preprocessor
-debug <keyword>
see Output, Debug, PCH
-diag
see Output, Debug, PCH
-diag-dump
see Output, Debug, PCH
-diag-enable port-win
see Compiler Diagnostics
-diag-enable sv-include
see Output, Debug, PCH
-diag-<type> {<diag-list>}
see Output, Debug, PCH
-diag-file-append
see Output, Debug, PCH
-[no-]diag-id-numbers
see Output, Debug, PCH
-diag-length=<len>
see Output, Debug, PCH
-diag-stop-on-error
see Output, Debug, PCH
-dM
see Preprocessor
-dN
see Preprocessor
-dryrun
see Miscellaneous
-dumpmachine
see Miscellaneous
-dumpversion
see Miscellaneous
-dynamiclib
see Linking/Linker
-dynamic-linker <file>
see Linking/Linker
-E
see Preprocessor
-[no-]early-template-check
see Language
-EP
see Preprocessor
-export
see Language
-export-dir <dir>
see Language
-F<dir>
see Linking/Linker
-fabi-version=<val>
see Compatibility
-f[no-]alias
see Optimization
-f[no-]align-functions[=n]
see Data
-fargument-[no]alias
see Advanced Optimization
-fargument-noalias-global
see Advanced Optimization
-fast
see Optimization
-f[no-]builtin[-<func>]
see Optimization
-fcode-asm
see Output, Debug, PCH
-f[no-]common
see Data
-fdata-sections
see Optimization
-f[no-]exceptions
see Optimization
-f[no-]fnalias
see Optimization
-ffunction-sections
see Optimization
-f[no-]inline
see Optimization
-f[no-]inline-functions
see Optimization
-f[no-]jump-tables
see Compatibility
-finline-limit=<n>
see Optimization
-f[no-]instrument-functions
see Output, Debug, PCH
-f[no-]keep-static-consts
see Optimization
-f[no-]math-errno
see Data
-fminshared
see Data
-fmudflap
see Data
-fno-gnu-keywords
see Language
-fno-implicit-inline-templates
see Language
-fno-implicit-templates
see Language
-f[no-]non-lvalue-assign
see Language
-f[no-]omit-frame-pointer
see Optimization
-fno-operator-names
see Language
-fno-rtti
see Language
-[no-]fnsplit
see Profile Guided Optimization (PGO)
-fp
see Optimization
-fpack-struct
see Data
-fpascal-strings
see Language
-fpermissive
see Language
-f[no-]pic, -f[no-]PIC
see Data
-fp-model <keyword>
see Floating Point
-[no-]fp-port
see Floating Point
-fp-speculation=<mode>
see Floating Point
-fp-stack-check
see Floating Point
-fpstkchk
see Floating Point
-fr32
see Miscellaneous
-freg-struct-return
see Data
-fshort-enums
see Language
-fsource-asm
see Output, Debug, PCH
-f[no-]stack-security-check
see Data
-fsyntax-only
see Language
-ftemplate-depth-<n>
see Language
-ftls-model=<model>
see Advanced Optimization
-ftrapuv
see Output, Debug, PCH
-[no-]ftz
see Floating Point
-[no-]func-groups
see Profile Guided Optimization (PGO)
-funroll-all-loops
see Advanced Optimization
-funroll-loops[<n>]
see Advanced Optimization
-f[no-]unsigned-bitfields
see Language
-funsigned-char
see Language
-f[no-]verbose-asm
see Output, Debug, PCH
-fvisibility=<keyword>
see Data
-fvisibility-<keyword>=<file>
see Data
-g
see Output, Debug, PCH
-g0
see Output, Debug, PCH
-gcc-name=<dir>
see Compatibility
-[no-]gcc[-sys]
see Compatibility
-gcc-version=<version>
see Compatibility
-gdwarf-2
see Output, Debug, PCH
-gxx-name=<dir>
see Compatibility
-[no-]global-hoist
see Data
-H
see Preprocessor
-help [category]
see Help
-I<dir>
see Preprocessor
-[no-]icc
see Preprocessor
-idirafter<dir>
see Preprocessor
-i-dynamic
see Linking/Linker
-imacros <file>
see Preprocessor
-inline-debug-info
see Output, Debug, PCH
-[no-]inline-calloc
see Inlining
-[no-]inline-factor[=<n>]
see Inlining
-inline-forceinline
see Inlining
-inline-level=<n>
see Optimization
-[no-]inline-max-per-compile[=<n>]
see Inlining
-[no-]inline-max-per-routine[=<n>]
see Inlining
-[no-]inline-max-size[=<n>]
see Inlining
-[no-]inline-max-total-size[=<n>]
see Inlining
-[no-]inline-min-size[=<n>]
see Inlining
-ip
see Interprocedural Optimizations (IPO)
-[no-]IPF-fltacc
see Floating Point
-IPF-flt-eval-method0
see Floating Point
-[no-]IPF-fma
see Floating Point
-[no-]IPF-fp-relaxed
see Floating Point
-IPF-fp-speculation<mode>
see Floating Point
-ip-no-inlining
see Interprocedural Optimizations (IPO)
-ip-no-pinlining
see Interprocedural Optimizations (IPO)
-ipo[n]
see Interprocedural Optimizations (IPO)
-ipo-c
see Interprocedural Optimizations (IPO)
-ipo-jobs<n>
see Interprocedural Optimizations (IPO)
-ipo-S
see Interprocedural Optimizations (IPO)
-ipo-separate
see Interprocedural Optimizations (IPO)
-iprefix <prefix>
see Preprocessor
-iquote <dir>
see Preprocessor
-i-static
see Linking/Linker
-isystem<dir>
see Preprocessor
-ivdep-parallel
see OpenMP* and Parallel Processing
-iwithprefix <dir>
see Preprocessor
-iwithprefixbefore <dir>
see Preprocessor
-Kc++
see Language
-kernel
see Miscellaneous
-l<string>
see Linking/Linker
-L<dir>
see Linking/Linker
-long-double
see Data
-m32
see Code Generation
-m64
see Code Generation
-M
see Preprocessor
-malign-double
see Data
-malign-mac68k
see Data
-malign-natural
see Data
-malign-power
see Data
-map-opts
see Output, Debug, PCH
-march=<cpu>
see Code Generation
-mcmodel=<mem_model>
see Linking/Linker
-mcpu=<cpu>
see Code Generation
-MD
see Preprocessor
-mdynamic-no-pic
see Linking/Linker
-MF<file>
see Preprocessor
-mfixed-range=f12-f15,f32-f127
see Miscellaneous
-MG
see Preprocessor
-m[no-]ieee-fp
see Floating Point
-MM
see Preprocessor
-MMD
see Preprocessor
-mp
see Floating Point
-MP
see Preprocessor
-mp1
see Floating Point
-MQ<target>
see Preprocessor
-mregparm=<value>
see Data
-m[no-]relax
see Linking/Linker
-m[no-]serialize-volatile
see OpenMP* and Parallel Processing
-msse[<n>]
see Code Generation
-MT<target>
see Preprocessor
-mtune=<cpu>
see Code Generation
-[no-]multibyte-chars
see Compatibility
-nobss-init
see Data
-no-cpprt
see Linking/Linker
-nodefaultlibs
see Linking/Linker
-nolib-inline
see Advanced Optimization
-nostartfiles
see Linking/Linker
-nostdinc++
see Preprocessor
-nostdlib
see Linking/Linker
-O[<n>]
see Optimization
-o<file>
see Output, Debug, PCH
-Ob<n>
see Inlining
-openmp
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-openmp-lib
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-openmp-profile
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-openmp-report{0|1|2}
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-openmp-stubs
see OpenMP* and Parallel Processing, Parallelization with OpenMP*
-[no-]opt-class-analysis
see Optimization
-opt-malloc-options=<n>
see Advanced Optimization
-opt-mem-bandwidth<n>
see Optimization
-opt-multi-version-aggressive
see Advanced Optimization
-opt-ra-region-strategy[=keyword]
see Advanced Optimization
-opt-report[<n>]
see Optimization Reports
-opt-report-file<file>
see Optimization Reports
-opt-report-help
see Optimization Reports
-opt-report-level<level>
see Optimization Reports
-opt-report-phase<phase>
see Optimization Reports
-opt-report-routine<string>
see Optimization Reports
-opt-streaming-stores <keyword>
see Optimization
-Os
see Optimization
-p
see Profile Guided Optimization (PGO)
-P
see Preprocessor
-parallel
see OpenMP* and Parallel Processing, Auto Parallelization Options
-par-report{0|1|2|3}
see OpenMP* and Parallel Processing, Auto Parallelization Options
-[no-]par-runtime-control
see OpenMP* and Parallel Processing
-par-schedule-<keyword>[=<n>]
see OpenMP* and Parallel Processing
-par-threshold[n]
see OpenMP* and Parallel Processing, Auto Parallelization Options
-pc<n>
see Floating Point
-pch
see Output, Debug, PCH, Precompiled Headers
-pch-create <file>
see Output, Debug, PCH, Precompiled Headers
-pch-dir <dir>
see Output, Debug, PCH, Precompiled Headers
-pch-use <file>
see Output, Debug, PCH, Precompiled Headers
-pragma-optimization-level=<value>
see Preprocessor
-[no-]prec-div
see Floating Point
-[no-]prec-sqrt
see Floating Point
-[no-]prefetch
see Profile Guided Optimization (PGO)
-print-multi-lib
see Output, Debug, PCH
-prof-dir <dir>
see Profile Guided Optimization (PGO)
-prof-file <file>
see Profile Guided Optimization (PGO)
-prof-gen[x]
see Profile Guided Optimization (PGO)
-prof-gen-sampling
see Profile Guided Optimization (PGO)
-prof-use
see Profile Guided Optimization (PGO)
-pthread
see Linking/Linker
-Qinstall <dir>
see Component Control
-Qlocation,<tool>,<path>
see Component Control
-Qoption,<tool>,<optlist>
see Component Control
-qp
see Profile Guided Optimization (PGO)
-rcd
see Floating Point
-reserve-kernel-regs
see Miscellaneous
-[no-]restrict
see Language
-S
see Output, Debug, PCH
-[no-]save-temps
see Miscellaneous
-[no-]scalar-rep
see Advanced Optimization
-shared
see Linking/Linker
-shared-intel
see Linking/Linker
-shared-libgcc
see Linking/Linker
-[no-]sox
see Miscellaneous
-ssp
see Profile Guided Optimization (PGO)
-static
see Linking/Linker
-static-intel
see Linking/Linker
-static-libgcc
see Linking/Linker
-std=<value>
see Language
-strict-ansi
see Language
-T <file>
see Linking/Linker
-tcheck
see Optimization Reports
-tcollect
see Compiler Diagnostics
-tprofile
see Optimization Reports
-[no]traceback
see Compiler Diagnostics
-trigraphs
see Language
-u <symbol>
see Linking/Linker
-U<name>
see Preprocessor
-unroll[<n>]
see Advanced Optimization
-[no-]unroll-aggressive
see Advanced Optimization
-[no-]use-asm
see Output, Debug, PCH
-use-msasm
see Output, Debug, PCH
-use-pch {<file> | <dir>}
see Output, Debug, PCH, Precompiled Headers
-V
see Miscellaneous
-v
see Miscellaneous
-[no-]vec-guard-write
see Advanced Optimization
-vec-report[<n>]
see Optimization Reports
--version
see Miscellaneous
-w
see Compiler Diagnostics
-w<n>
see Compiler Diagnostics
-Wa,<o1>[,<o2>,...]
see Linking/Linker
-W[no-]abi
see Compiler Diagnostics
-Wall
see Compiler Diagnostics
-Wbrief
see Compiler Diagnostics
-Wcheck
see Compiler Diagnostics
-W[no-]comment[s]
see Compiler Diagnostics
-Wcontext-limit=<n>
see Compiler Diagnostics
-wd<L1>[,<L2>,...]
see Compiler Diagnostics
-W[no-]deprecated
see Compiler Diagnostics
-we<L1>[,<L2>,...]
see Compiler Diagnostics
-Weffc++
see Compiler Diagnostics
-Werror
see Compiler Diagnostics
-Wextra-tokens
see Compiler Diagnostics
-Winline
see Compiler Diagnostics
-Wl,<o1>[,<o2>,...]
see Linking/Linker
-W[no-]main
see Compiler Diagnostics
-W[no-]missing-declarations
see Compiler Diagnostics
-W[no-]missing-prototypes
see Compiler Diagnostics
-wn<n>
see Compiler Diagnostics
-Wnon-virtual-dtor
see Compiler Diagnostics
-wo<L1>[,<L2>,...]
see Compiler Diagnostics
-Wp,<o1>[,<o2>,...]
see Linking/Linker
-Wp64
see Compiler Diagnostics
-W[no-]pointer-arith
see Compiler Diagnostics
-Wpragma-once
see Compiler Diagnostics
-wr<L1>[,<L2>,...]
see Compiler Diagnostics
-Wreorder
see Compiler Diagnostics
-W[no-]return-type
see Compiler Diagnostics
-W[no-]shadow
see Compiler Diagnostics
-W[no-]strict-prototypes
see Compiler Diagnostics
-W[no-]trigraphs
see Compiler Diagnostics
-W[no-]uninitialized
see Compiler Diagnostics
-W[no-]unknown-pragmas
see Compiler Diagnostics
-W[no-]unused-function
see Compiler Diagnostics
-W[no-]unused-variable
see Compiler Diagnostics
-ww<L1>[,<L2>,...]
see Compiler Diagnostics
-Wwrite-strings
see Compiler Diagnostics
-X
see Preprocessor
-x <type>
see Language
-x<codes>
see Code Generation, Vectorization Options
-Xlinker <option>
see Linking/Linker
-Zp[<n>]
see Language
 

Vectorization Options (i32, i64em only)

The vectorizer is a component of the Intel C++ Compiler that automatically uses SIMD instructions in the MMX, SSE, SSE2, SSE3, SSSE3, and Intel(R) SSE4 instruction sets. The -x and -ax options enable the vectorizer. See the Intel(R) C++ Compiler Documentation 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[aq]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 [dq]OpenMP Application Program Interface Version 2.5[dq]. This single API now covers the C/C++ and Fortran languages. The compiler performs transformations to generate multithreaded code based on the user[aq]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 API.

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.

The Cluster OpenMP* options are available under a separate license for the Cluster OpenMP product (i64em, i64 only).  

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(R) C++ Compiler Documentation 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.  

Optimization

This section describes options that help you optimize code.

-f[no-]alias
Assume [do not assume] aliasing in the program (default = -falias).
-fast
The -fast option maximizes speed across the entire program. It sets command options that can improve run-time performance, as follows:

i32, i64em: The -fast option turns on -O3, -ipo, -static, -no-prec-div, and -xP. Program for IA-32 architecture compiled with -fast will execute on Intel(R) Pentium(R) 4 processors with Streaming SIMD Extensions 3 (SSE3) or later processors only. 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.

M*X: The -fast option turns on -O3, -ipo, -mdynamic-no-pic, and -no-prec-div.

-f[no-]builtin[-<func>]
This option enables [disables] inline expansion of one or more intrinsic functions. If -func is not specified, -fno-builtin disables inline expansion for all intrinsic functions.
-fdata-sections
Separate functions for the linker (COMDAT). Same as -ffunction-sections.
-f[no-]exceptions
Enables [disables] exception handling table generation, which can result 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.
-f[no-]fnalias
Assume [do not assume, but assume aliasing across calls] aliasing within functions (default = -ffnalias).
-ffunction-sections
Separate functions for the linker (COMDAT). Same as -fdata-sections.
-f[no-]inline
Enables [disables] inlining of functions declared with the __inline keyword. Also enables inlining according to the C++ language. Same as -Ob1.
-f[no-]inline-functions
Enables [disables] function inlining for single file compilation.
-finline-limit=<n>
Lets you specify the maximum size of a function to be inlined.
-f[no-]keep-static-consts
Preserve allocation of variables that are not referenced in the source.
-f[no-]omit-frame-pointer (i32, i64em only)
Enable [disable] whether EBP is used as a general-purpose register in optimizations. The negative version is the same as -fp.
-fp (i32, i64em only)
Disable using EBP as general purpose register. This option has been deprecated for this release. Suggested replacement -fno-omit-frame-pointer.
-inline-level=<n> (i64 only)
Control the level of inline expansion, where <n> may be:

0 -- disables inlining.

1 -- inline functions declared with __inline, and perform C++ inlining.

2 -- inline any function, at the compiler[aq]s discretion.

-opt-streaming-stores <keyword> (i32, i64em only)
Enables generation of streaming stores for optimization, where <keyword> may be:

always -- enables generation of streaming stores for optimization. The compiler optimizes under the assumption that the application is memory bound.

never -- disables generation of streaming stores for optimization. Normal stores are performed.

auto -- lets the compiler decide which instructions to use

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

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

-opt-mem-bandwidth<n> (i64 only) (L*X only)
Enables or disables performance tuning and heuristics that control memory bandwidth use among processors. It allows the compiler to be less aggressive with optimizations that might consume more bandwidth, so that the bandwidth can be well-shared among multiple processors for a parallel program. For values of <n> greater than 0, the option tells the compiler to enable a set of performance tuning and heuristics in compiler optimizations such as prefetching, privatization, aggressive code motion, and so forth, for reducing memory bandwidth pressure and balancing memory bandwidth traffic among threads. The <n> value is the level of optimizing for memory bandwidth usage. You can specify one of the following values for <n>:

0 -- Disables a set of performance tuning and heuristics in compiler optimizations for parallel code. This is the default for serial code.

1 -- Enables a set of performance tuning and heuristics in compiler optimizations for multithreaded code generated by the compiler. This is the default if compiler option -parallel or -openmp is specified, or Cluster OpenMP option -cluster-openmp is specified (see the Cluster OpenMP documentation).

2 -- Enables a set of performance tuning and heuristics in compiler optimizations for parallel code such as Windows Threads, pthreads, and MPI code, besides multithreaded code generated by the compiler.

-Os
Enable speed optimizations, but disable some optimizations that increase code size for small speed benefit.
 

Advanced Optimization

This section describes advanced optimization options that allow fine tuning of compilation or allow control over advanced features of the compiler.

-[no-]alias-args
Assume [do not assume] arguments may be aliased. (default = -alias-args). This option has been deprecated for this release. Suggested replacement -fargument-alias.
-[no-]alias-const
Enable a heuristic stating that if two arguments to a function have pointer type, a pointer to const does [does not] alias a pointer to non-const. Default -no-alias-const.
-[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[aq]t adhere to these rules, then it can cause the compiler to generate incorrect code.
-[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.
-[no-]opt-multi-version-aggressive (i32, i64em only)
Instructs the compiler to use aggressive multi-versioning to check for pointer aliasing and scalar replacement. This option may improve performance.
-[no-]scalar-rep
This option enables [disables] scalar replacement performed during loop transformation. To use this option, you must also specify -O3.
-[no-]unroll-aggressive (i32, i64em only)
Instructs the compiler to use aggressive, complete unrolling for loops with samll constant trip counts. This option may improve performance.
-[no-]vec-guard-write (i32, i64em only)
Instructs the compiler to perform a conditional check in a vectorized loop. Checking avoids unnecessary stores and may improve performance.
-fargument-[no]alias
Assume [do not assume] arguments may be aliased. (default = -fargument-noalias). Same as -[no-]alias-args.
-fargument-noalias-global
Arguments do not alias each other and do not alias global storage.
-ftls-model=<model>
Change thread-local storage model, where <model> can be the following:

global-dynamic

local-dynamic

initial-exec

local-exec

-funroll-loops
Unroll loops based on default heuristics.
-nolib-inline
Disables inline expansion of standard library or intrinsic functions.
-opt-malloc-options=<n> (ia32 and i64em only)
Lets you specify an alternate algorithm for malloc(). If you specify a non-zero value for n, it causes alternate configuration parameters to be set for how malloc() allocates and frees memory. It tells the compiler to insert calls to mallopt() to adjust these parameters to malloc() for dynamic memory allocation. This may improve speed. Valid values for n are:

0 -- Default. Tells the compiler to use the default algorithm for malloc().

1 -- Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=2 and M_TRIM_THRESHOLD=0x10000000.

2 -- Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=2 and M_TRIM_THRESHOLD=0x40000000.

3 -- Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=0 and M_TRIM_THRESHOLD=-1.

-opt-ra-region-strategy[=keyword]
Selects the method that the register allocator uses to partition each routine into regions. Specify strategies by entering following valid values:

routine -- Creates a single region for each routine.

block -- Partitions each routine into one region per basic block.

trace -- Partitions each routine into one region per trace.

region -- Partitions each routine into one region per loop.

default -- The compiler determines which method is used for partitioning.

-unroll<n> (i32, i64em 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. This option has been deprecated for this release. Suggested replacement -funroll-loops.
-unroll0 (i64 only)
Disable loop unrolling. For i64: the only allowed value is 0.
 

Code Generation

This section describes code generation options that optimize code for a particular architecture or processor.

-ax<processor> (i32 and i64em)
Tells the compiler to generate multiple, processor-specific code paths if there is a performance benefit. It also generates a generic IA-32 architecture code path. <processor> is a value used to target specific processors or microarchitectures for the optimized code paths. The following are -ax options:

-axS -- Can generate specialized code paths using Intel(R) Streaming SIMD Extensions 4 (SSE4) Vectorizing Compiler and Media Accelerators instructions for future Intel processors that support the instruction set and it can optimize for the architecture.

-axT -- Can generate specialized code paths for SSSE3, SSE3, SSE2, and SSE instructions for Intel processors, and it can optimize for the Intel(R) Core(TM)2 Duo processor family.

-axP -- Can generate specialized code paths for SSE3, SSE2, and SSE instructions for Intel processors, and it can optimize for Intel processors based on Intel(R) Core(TM) microarchitecture and Intel Netburst(R) microarchitecture.

-axB -- Can generate specialized code paths for SSE2 and SSE instructions for Intel processors, and it can optimize for Intel(R) Pentium(R) M processors. This is a deprecated option.

-axN -- Can generate specialized code paths for SSE2 and SSE instructions for Intel processors, and it can optimize for Pentium(R) 4 processors and Intel(R) Xeon(R) processors with SSE2.

-axW -- Can generate specialized code paths for SSE2 and SSE instructions for Intel processors, and it can optimize for Intel Pentium(R) 4 processors and Intel(R) Xeon(R) processors with SSE2.

-axK -- Can generate specialized code paths for SSE instructions for Intel processors and it can optimize for Intel(R) Pentium(R) III and Intel Pentium(R) III Xeon(R) processors.

This option enables the vectorizer and tells the compiler to find opportunities to generate separate versions of functions that take advantage of features of the specified Intel(R) processor.
On Linux* systems using Intel(R) 64 architecture, B, N, and K are not valid processor values.
On Mac OS* X systems using IA-32 architecture, S, T, and P are the only valid processor values. On Mac OS X systems using Intel(R) 64 architecture, S and T are the only valid processor values.
You can use more than one of the processor values by combining them. For example, you can specify -axTP to generate code for Intel(R) Core(TM)2 Duo processors and Intel(R) Pentium(R) 4 processors with SSE3.
If you specify both the -ax and -x options, the generic code will only execute on processors compatible with the processor type specified by the -x option.
By default, no processor specific code is generated, except as controlled by option -x.
-m32 (M*X only)
Intructs the compiler to generate code for IA-32 architecture.
-m64 (M*X only)
Intructs the compiler to generate code for Intel(R) 64 architecture.
-march=<cpu> (i32, i64em only)
Generate code exclusively for a given cpu. For this release, the <cpu> values of pentiumii and pentiumiii have been deprecated. For a given cpu, <cpu> is one of the following:

core2 -- Intel(R) Core(TM)2 processor family

pentium4 -- Intel Pentium 4 processors

pentium3 -- Intel Pentium III processors

-mcpu=<cpu>
Optimize for a specific cpu. For this release the mcpu option has been deprecated and the -mtune option is the suggested replacement. Possible values for <cpu> are 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 architecture) Optimize for Intel Pentium 4 processors.

pentium-mmx -- (i32 only) Optimizes for Intel(R) Pentium(R) with MMX(TM) technology

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

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

itanium2-p9000 -- (i64, L*X only) Optimize for Dual-Core Intel(R) Itanium(R) 2 Processor (9000 series).

-msse[<n>] (i32 only)
Generate code for Intel Pentium III and compatible Intel processors. The <n> value indicates the processor for which code is generated. Possible values are:

2 -- Generates code for Intel(R) Pentium(R) 4 and compatible Intel processors with Streaming SIMD Extensions 2 (SSE2).

3 -- Generates code for Intel Pentium 4 processors with Streaming SIMD Extensions 3 (SSE3).

Note: M*X only. -msse3 is the only supported value.

-mtune=<cpu> (i32, IA-64 only)
Optimize for a specific cpu, where <cpu> is one of the following:

core2 -- (i32 only;) Intel(R) Core(TM) 2 processor family.

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

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

pentium-mmx -- (i32 only) Optimizes for Intel(R) Pentium(R) with MMX(TM) technology.

pentium -- (i32 only) Optimize for Intel(R) Pentium(R) processors.

itanium2-p9000 -- (i64, L*X only) Optimize for Dual-Core Intel(R) Itanium(R) 2 Processors.

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

itanium -- (i64 only) Optimize for systems using IA-64 architecture.

-x<processor> (i32 and i64em)
Tells the compiler to generate optimized code specialized for the processor that executes your program. <processor> is a value used to target specific processors or microarchitectures. The following are -x options:

-xS -- Can generate Intel(R) Streaming SIMD Extensions 4 (SSE4) Vectorizing Compiler and Media Accelerators instructions for future Intel processors that support the instructions.

-xT -- Can generate SSSE3, SSE3, SSE2, and SSE instructions for Intel processors, and it can optimize for the Intel(R) Core(TM)2 Duo processor family. This is the default on Mac OS X systems using Intel(R) 64 architecture.

-xP -- Can generate SSE3, SSE2, and SSE instructions for Intel processors, and it can optimize for processors based on Intel(R) Core(TM) microarchitecture and Intel NetBurst(R) microarchitecture, like Intel(R) Core(TM) Duo processors, Pentium(R) 4 processors with SSE3, and Intel(R) Xeon(R) processors with SSE3. This is the default on Mac OS X systems using IA-32 architecture.

-xO -- Can generate SSE3, SSE2, and SSE instructions, and it can optimize for Intel processors based on Intel(R) Core(TM) microarchitecture and Intel Netburst(R) microarchitecture.

-xB -- Can generate SSE2 and SSE instructions for Intel processors, and it can optimize for the Intel(R) Pentium(R) M processors. This is a deprecated option.

-xN -- Can generate SSE2 and SSE instructions for Intel processors, and it can optimize for Intel(R) Pentium(R) 4 processors and Intel(R) Xeon(R) processors with SSE2.

-xW -- Can generate SSE2 and SSE instructions, and it can optimize for Intel(R) Pentium(R) 4 processors and Intel(R) Xeon(R) processors with SSE2. This is the default on Linux systems using Intel(R) 64 architecture. This option is the same as specifying -march=pentium4.

-xK -- Can generate SSE instructions and it can optimize for Intel(R) Pentium(R) III processors and Intel(R) Pentium III Xeon(R) processors. Generated code may operate on processors not made by Intel that support SSE instructions. This is the same as specifying -march=pentium3.

On Linux* systems using Intel(R) 64 architecture, B, N, and K are not valid processor values.
On Mac OS* X systems using IA-32 architecture, S, T, and P are valid processor values. On these systems, P is the default and is always set. On Mac OS X systems using Intel(R) 64 architecture, S and T are the only valid processor values. On these systems, T is the default and is always set.
If you specify more than one processor value, code is generated for only the highest-performing processor specified. The highest-performing to lowest-performing processor values are: S, T, P, O, B, N, W, K.
Do not use processor values S, T, P, O, W, N, B, or K to create binaries that will execute on a processor that is not compatible with the targeted processor. The resulting program may fail with an illegal instruction exception or display other unexpected behavior. For example, binaries produced with W may produce code that will not run on Intel(R) Pentium(R) III processors or earlier processors that do not support SSE2 instructions.
Compiling the main program with processor values S, T, P, N, or B produces binaries that display a fatal run-time error if they are executed on unsupported processors. For more information, see Optimizing Applications.
The binaries produced by these values will run on Intel processors that support all of the features for the targeted processor. For example, binaries produced with W will run on an Intel(R) Core(TM)2 Duo processor, because that processor completely supports all of the capabilities of the Intel(R) Pentium(R) 4 processor, which the W value targets. Specifying the T value has the potential of using more features and optimizations available to the Intel(R) Core(TM)2 Duo processor.
By default, the compiler does not generate optimized code specialized for the processor on Linux systems using IA-32 architecture.
-[no]align (i32, i64em only)
Analyze and reorder memory layout for variables and arrays.

Note: Programs compiled with -align must be linked with other objects and libraries that are also compiled with -align enabled. The default -no-align option matches the layout of gcc.

-ansi
Support all ANSI standard C programs, equivalent to the -ansi option of gcc.
-[no-]c99
Enable [disable] C99 support for C programs. This option deprecated for this release. Suggested replacement -std=c99.
-[no-]early-template-check
Lets you semantically check template function template prototypes before instantiation. On Linux platforms, gcc 3.4 (or newer) compatibility modes (i.e. -gcc-version=340 and later) must be in effect. For all Mac OS X platforms, gcc 4.0 (or newer) is required.
-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 [aq]typeof[aq] 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.
-f[no-]non-lvalue-assign
Allow [disallow] casts and conditional expressions to be used as lvalues. (default = allow)
-fno-operator-names
Disable support for operator name keywords.
-fno-rtti
Disable RTTI support.
-fpascal-strings
Allow Pascal strings to be used in the source code. Pascal strings begin with a [dq]-p[dq] in the source code.
-fpermissive
Allow more leniency with respect to the standard than the default dialect. The option attempts to be similar to the gcc -fpermissive option.
-fshort-enums
Allocate as many bytes as needed for enumerated types.
-fsyntax-only
Performs parsing and semantic checking, but produces no output.
-ftemplate-depth-<n>
Control the depth to which recursive templates are expanded.
-f[no-]unsigned-bitfields
Change default bitfield type to unsigned [signed]. Bitfields are signed by default on all supported architectures.
-funsigned-char
Change default char type to unsigned.
-Kc++
Compile all source or unrecognized file types as C++ source files. This option has been deprecated for this release. Suggested replacement -x c++.
-[no-]restrict
Enable [disable] the [dq]restrict[dq] keyword for disambiguating pointers. The default is -no-restrict.
-std=<value>
Conform to a specific language standard. Possible <value>[aq]s are:

c89 -- Conforms to the ISO/IEC 9899:1990 International Standard.

c99 -- Conforms to The ISO/IEC 9899:1999 International Standard.

gnu89 (L*X and M*X only) -- Conforms to ISO C90 plus GNU* extensions. (Default for C.)

gnu++98 (L*X and M*X only) -- Conforms to the 1998 ISO C++ standard plus GNU extensions. (Default for C++.)

c++0x -- Enable support for a number of C++0x features (see the Intel C++ Compiler Documentation for details).

-strict-ansi
Select strict ANSI C/C++ conformance dialect
-trigraphs
Support ISO C trigraphs. This support is also enabled in ANSI and C99 modes.
-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

-Zp[<n>]
Specify alignment constraint for structure and union types, where <n> is one of the following: 1,2,4,8,16.
 

Compatibility

This section describes options that affect language compatibility.

-B<dir>
Specifies the directory (dir) that can be used to find libraries, headers, and executables for the compiler itself.
-fabi-version=<val>
Instructs the compiler to select a specific ABI implementation, where <val> is the ABI implementation. Possible values are:.

0 -- Requests all the latest ABI fixes.

1 -- Requests the ABI used in gcc 3.3. Default if gcc version 3.2 or 3.3 is installed.

2 -- Requests the ABI used in gcc 3.4 and higher. Default if gcc version 3.4 or higher is installed.

-f[no-]jump-tables
Determines whether jump tables are generated for switch statements.
-gcc-name=<dir>
specify the location of the gcc compiler when the compiler cannot locate the gcc C++ libraries. <dir> is the full path of the gcc compiler. You must also specify the -cxxlib-gcc option along with this option. This option is helpful when you are referencing a non-standard gcc installation. When compiling using icpc, use compiler option -gxx-name instead of -gcc-name.
-[no-]gcc[-sys]
Defines or undefines certain GNU macros. The -[no-]gcc option define [undefines] the GNU macros __GNUC__, __GNUC_MINOR__, and __GNUC_PATCHLEVEL__. The -gcc-sys option defines GNU macros only during compilation of system headers.
-gcc-version=<version>
This option provides compatible behavior with GNU gcc*, where <version> indicates the gcc version. The required values for <version> are:

320 -- specifies gcc 3.2 compatibility

330 -- specifies gcc 3.3 compatibility

340 -- specifies gcc 3.4 compatibility

400 -- specifies gcc 4.0 compatibility

410 -- specifies gcc 4.1 compatibility

411 -- specifies gcc 4.11 compatibility

420 -- specifies gcc 4.2 compatibility

Note: The <version> version number follows a format where the first number represents the major version, the second number represents the minor version, and the third number is normally zero. For example, the 3.3.1 gcc version is represented as 330.

Note: The default <version> version number is determined by the Intel(R) C++ Compiler based on the gcc version in your path definition.

-gxx-name=<dir>
specify the g++ compiler that should be used to setup the proper environment for C++ compilations. <dir> is the full path of the g++ compiler. For C compilations, use compiler option -gcc-name. (When compiling a C++ file with icc, g++ is used to get the environment.)
-[no-]multibyte-chars
Provide [do not provide] support for multi-byte characters.
 

Compiler Diagnostics

This section describes options that affect diagnostic messages displayed by the compiler.

-diag-enable port-win
Enables warnings for GNU extensions that might cause errors when porting to Windows*.
-tcollect (L*X only)
Inserts instrumentation probes calling the Intel(R) Trace Collector API.
-[no]traceback
Tell 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. This is intended for use with C code that is to be linked into a Fortran program.
-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 [do not warn] if generated code is not C++ ABI compliant (Default = -Wno-abi).
-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 [do not 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 [do not print] warnings related to deprecated features.
-we<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to error.
-Weffc++
Enable warnings based on certain C++ programming guidelines (as defined in the Effective C++ books by Scott Meyers).
-Werror
Force warnings to be reported as errors.
-W[no-]extra-tokens
Warn about extra tokens at the end of preprocessor directives.
-Winline
Enable inline diagnostics.
-W[no-]main
Warn [do not warn] if return type of main is not expected.
-W[no-]missing-declarations
Warn [do not warn] for global functions and variables without prior declaration.
-W[no-]missing-prototypes
Warn [do not 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.
-Wnon-virtual-dtor
Issue a warning when a class appears to be polymorphic, yet it declares a non-virtual one. This option only applies to the C++ compiler.
-wo<L1>[,<L2>,...]
Tells the compiler to issue one or more diagnostic messages only once. Specifies the ID number of one or more messages. If you specify more than one <n>, each <n> must be separated by a comma.
-Wp64
Print diagnostics for 64-bit porting.
-W[no-]pointer-arith
Warn [do not warn] for questionable pointer arithmetic.
-W[no-]pragma-once
Warn [do not warn] about the use of #pragma once.
-wr<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to remark.
-Wreorder
Issue a warning when the order of member initializers does not match the order in which they must be executed. This option only applies to the C++ compiler.
-W[no-]return-type
Warn [do not 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 [do not warn] if a variable declaration hides a previous variable declaration.
-W[no-]strict-prototypes
Warn [do not warn] for functions declared or defined without specified argument types.
-W[no-]trigraphs
Warn [do not warn] if any trigraphs are encountered that might change the meaning of the program.
-W[no-]uninitialized
Warn [do not warn] if a variable is used before being initialized.
-W[no-]unknown-pragmas
Warn [do not warn] if an unknown #pragma directive is used (default).
-W[no-]unused-function
Warn [do not warn] if declared function is not used.
-W[no-]unused-variable
Warn if a local or non-constant static variable is unused after being declared.
-ww<L1>[,<L2>,...<LN>]
Change severity of diagnostics L1 through LN to warning.
-Wwrite-strings
This option issues a diagnostic message if const char * is converted to (non-const) char *.
 

Inlining

This section describes options that affect inlining.

-[no-]inline-calloc
Instructs the compiler to inline calls to calloc() as calls to malloc() and memset(). This enables additional memset() optimizations.
-[no-]inline-factor=<n>
Specifies the percentage multiplier that should be applied to all inlining options that define upper limits. The value <n> is a positive integer specifying the percentage value. The default value is 100 (or 1.00).
-inline-forceinline
Specifies that an inline routine should be inlined whenever the compiler can do so. (Default OFF)
-[no-]inline-max-per-compile=<n>
Specifies the maximum number of times inlining may be applied to an entire compilation unit. The value <n> is a positive integer that specifies the number of times inlining may be applied. (Default OFF)
-[no-]inline-max-per-routine=<n>
Specifies the maximum number of times the inliner may inline into a particular routine. The value <n> is a positive integer that specifies the maximum number of times the inliner may inline into a particular routine. (Default OFF)
-[no-]inline-max-size=<n>
Specifies the lower limit for the size of what the inliner considers to be a large routine. The value <n> is a positive integer that specifies the minimum size of what the inliner considers to be a large routine. (Default OFF)
-[no-]inline-max-total-size=<n>
Specifies how much larger a routine can normally grow when inline expansion is performed. The value <n> is a positive integer that specifies the permitted increase in the routine[aq]s size when inline expansion is performed. (Default OFF)
-[no-]inline-min-size=<n>
Specifies the upper limit for the size of what the inliner considers to be a small routine. The value <n> is a positive integer that specifies the maximum size of what the inliner considers to be a small routine. (Default OFF)
-Ob<n>
This option has been deprecated for this release. Suggested replacement is -inline-level. 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[aq]s discretion. Enables interprocedural optimizations and has the same effect as -ip.

 

Interprocedural Optimizations (IPO)

This section describes interprocedural optimization (IPO) options. 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 the IA-32 architecture, IPO also passes the arguments of a function in registers if the compiler can determine that only the user[aq]s code will make calls to that function.

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 theIntel(R) C++ Compiler Documentation for more complete information on IPO.

-ip
Enable additional interprocedural optimizations for single file compilation. These optimizations are a subset of full intra-file interprocedural optimizations.
-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, i64em only)
Disable partial inlining (requires -ip or -ipo)
-ipo[<n>]
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 [<n>] 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 [<n>] 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 [<n>] 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 [<n>], the default is 1.

-ipo-c
Generate a multi-file object file (ipo-out.o) that can be used in further link steps.
-ipo-jobs<n>
Specifies the number of commands (jobs) to be executed simultaneously during the link phase of Interprocedural Optimization (IPO). The <n> value is the number of commands (jobs) to run simultaneously. The number must be equal to or greater than 1.
-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].
 

Profile Guided Optimization (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(R) C++ Compiler Documentation for more complete information on PGO.

-[no-]fnsplit (i64 only)
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 -[no-]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 -no-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.

-[no-]func-groups (L*X, i64)
Enables [disables] function grouping if profiling information is enabled.
-p
Compile and link for function profiling with Linux gprof* tool. Same as -qp.
-[no-]prefetch
Enable prefetch insertion optimization. The goal of prefetching is to reduce cache misses by providing hints to the processor about when data should be loaded into the cache. On IA-64 architecture, this option is enabled by default if you specify option -O1, -O2, or -O3. To disable prefetching at these optimization levels, specify -no-prefetch. On IA-32 architecture and Intel(R) 64 architecture, this option enables prefetching when higher optimization levels are specified.
-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 and cause the compiler to generate source code mapping information. The application executables are prepared for hardware profiling by using the profrun tool followed by a recompilation with option -prof-use.
-prof-use
Instruct the compiler to produce a profile-optimized executable and merge available dynamic information (.dyn) files into a pgopti.dpi file. Use this option to compile the final application using the profile data.
-qp
Compile and link for function profiling with Linux gprof* tool. This option has been deprecated for this release. Suggested replacement is -p.
-ssp (i32 only) (L*X only)
Enable software-based speculative pre-computation.
 

Optimization Reports

This section describes options that affect the generation of optimization reports.

-opt-report[<n>]
Generate an optimization report and direct it to stderr. The <n> value defines the level of detail in the report where:

0 -- Generate no optimization report.

1 -- Generate a report with the minimum level of detail.

2 -- Default. Generate a report with the medium level of detail.

3 -- Generate a report with the maximum level of detail.

-opt-report-file<file>
Specify the filename for the generated report.
-opt-report-help
List the logical names of optimizers available for report generation.
-opt-report-level[<level>]
Specify the level of report verbosity. This option has been deprecated for this release. Suggested replacement is -opt-report. The <level> value 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>
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 report <name>s are supported:

ipo -- Interprocedural Optimizer

hlo -- High Level Optimizer

hpo -- High Performance Optimizer

pgo -- Profile-guided Optimizer

ilo -- Intermediate Language Scalar Optimizer

ecg -- Code Generator

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<string>
Generate reports from all routines with names containing <string> as part of their name. If <string> is not specified, reports from all routines are generated.
-tcheck (L*X only)
Enables analysis of threaded applications. To use this option, you must have Intel(R) Thread Checker installed, which is one of the Intel(R) Threading Tools. If you do not have the tool installed, the compilation will fail. Remove the option from the command line and recompile.
-tprofile (L*X only)
Generates instrumentation to analyze multi-threading performance. To use this option, you must have Intel(R) Thread Profiler installed, which is one of the Intel(R) Threading Tools.
-vec-report[<n>] (i32, i64em only)
Control the vectorizer[aq]s level of diagnostic messages, where <n> is one of the following:

0 -- No diagnostic information

1 -- report on vectorized loops (default)

2 -- report on vectorized/non-vectorized loops

3 -- report on vectorized/non-vectorized loops and prohibiting data dependence information

4 -- report on non-vectorized loops

5 -- report on non-vectorized loops and prohibiting data dependence information

The vectorizer report is sent stdout. The vectorizer is enabled when certain compiler options are specified, such as -ax, -x, or -fast.

 

OpenMP and Parallel Processing

This section describes OpenMP* and parallel processing options.

-[no-]clomp-sharable-info (i64em, i64 only)
Reports variables that the compiler automatically makes sharable for Cluster OpenMP*.
-[no-]clomp-sharable-propagation (i64em, i64 only)
Reports variables that need to be made sharable by the user with Cluster OpenMP*. When this option is used, the -ipo option must also be used.
-[no-]cluster-openmp (i64em, i64 only)
Compiles an OpenMP* program for execution on a cluster.
-[no-]cluster-openmp-profile (i64em, i64 only)
Compiles an OpenMP* program for execution on a cluster, and links with a performance statistics library.
-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.
-m[no-]serialize-volatile (i64 only)
Enable [suppress] 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-lib <type> (L*X only)
Allows you to specify an OpenMP* run-time library to use for linking. See the Compiler Options section of the Intel(R) C++ Compiler Documentation for more information. Valid values for type are as follows:

legacy -- tells the compiler to use the legacy OpenMP* run-time library (libguide). This setting does not provide compatibility with object files created using other compilers.

compat -- tells the compiler to use the compatibility OpenMP* run-time library (libiomp). This setting provides compatibility with object files created using Microsoft* and GNU* compilers.

-openmp-profile (L*X only)
Enables analysis of OpenMP* applications if Intel(R) Thread Profiler is installed.
-openmp-report[<n>]
Control the OpenMP parallelizer[aq]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).
-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). You might need to set the KMP_STACKSIZE environment variable to an appropriately large size, like 16m, to use this option.
-[no-]par-runtime-control
Instructs the compiler to generate code to perform run-time checks for loops that have symbolic loop bounds. If the granularity of a loop is greater than the parallelization threshold, the loop will be executed in parallel.
-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 [dq]LOOP AUTO-PARALLELIZED[dq] 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-schedule-<keyword>[=<n>]
Specifies a scheduling algorithm for DO loop iterations. The <keyword> specifies the scheduling algorithm. Possible values are:

static -- Divides iterations into contiguous pieces.

dynamic -- Gets a set of iterations dynamically.

guided -- Specifies a minimum number of iterations.

runtime -- Defers the scheduling decision until run time.

The <n> value is the size of the chunk or the number of iterations for each chunk. For more information, see the descriptions in the Intel C++ Compiler Documentation.

-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>=100)

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.

 

Floating Point

This section describes options that affect floating-point operations.

-fp-model <keyword>
Use a specific floating-point model. The <keyword> is the floating-point model to be used. Possible values are:

double -- Rounds intermediate results to 53-bit (double) precision and enables value-safe optimizations.

[no-]except -- Determines whether [or not] floating-point semantics are used.

extended -- Rounds intermediate results to 64-bit ([dq]extended[dq]) precision and enables value-safe optimizations.

fast[=1|2] -- Default is fast=1. Enables more aggressive optimizations on floating-point data.

precise -- Enables value-safe optimizations on floating-point data.

source -- Rounds intermediate results to source-defined precision and enables value-safe optimizations.

strict -- Enables [dq]precise[dq] and [dq]except[dq], disables contractions, and enables pragma [dq]stdc fenv_access[dq].

-[no-]fp-port (i32, i64em only)
Round floating-point results at assignments and casts (some speed impact).
-fp-speculation=<mode>
Tell the compiler the mode in which to speculate on floating-point operations. The <mode> values may be:

fast -- Tells the compiler to speculate on floating-point operations.

safe -- Tells the compiler to disable speculation if there is a possibility that the speculation may cause a floating-point exception.

strict -- Tells the compiler to disable speculation on floating-point operations.

off -- This is the same as specifying strict.

-fp-stack-check
Same as -fpstkchk.
-fpstkchk
Tell the compiler to generate extra code after every function call to ensure that the floating-point stack is in the expected state. This option has been deprecated for this release. Suggested replacement -fp-stack-check.
-[no-]ftz
Flush denormal results to zero. This is a performance option. Setting the options does not guarantee that all denormals in a program are flushed to zero. The option only causes denormals generated at runtime to be flushed to zero.
-[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.
-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-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

This option has been deprecated for this release. Suggested replacement -fp-speculation.

-m[no-]ieee-fp
Same as -mp.
-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.
-pc<n> (i32, i64em 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)

64: 53 bits (double precision)

80: 64 bits (extended precision)

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.

-[no-]prec-div (i32, i64em 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, sometimes the value produced by this transformation is not as accurate as full IEEE division. 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, i64em only)
Determine if certain square root optimizations are enabled.
-rcd (i32, i64em 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.
 

Preprocessor

The preprocessor options described in this section 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.
-[no-]check-uninit
Determines whether checking occurs for uninitialized variables.
-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.

-dD
Same as -dM, but outputs #define directives in preprocessed source.
-dM
Output macro definitions in effect after preprocessing (use with -E).
-dN
Same as -dD, but #define directives contain only macro names.
-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 [dq]include[dq] 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).
-[no-]icc
Predefine or undefine the -D__ICC and -D__INTEL_COMPILER macros.
-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.
-iquote<dir>
Add <dir> to the front of the include file search path for files included with quotes but not brackets. (default = OFF)
-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.
-nostdinc++
Do not search for header files in the standard directories for C++, but search the other standard directories.
-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.

-pragma-optimization-level=<value>
Specifies which interpretation of the optimization_level pragma should be used if no prefix is specified. The possible value[aq]s for -pragma-optimization-level are GCC or Intel (default = Intel).
-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.
 

Output, Debug, PCH

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 <file>
Manual creation of precompiled header file, <file>. This option has been deprecated for this release. Suggested replacement -pch-create.
-debug <keyword>
Specifies the type of debugging information generated by the compiler. The debug switches control emission of enhanced debug information. Enabling debugging disables optimization. Valid <keyword> values are follows;

extended -- Turns on the -debug options semantic-stepping, and variable-locations.

full -- Generates complete debugging information.

all -- Generates complete debugging information (same as full).

minimal -- Generates line number information for debugging.

none -- Default. Disables generation of debugging information.

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

-diag-<type> {<diag-list>}
Controls the display of diagnostic information. The <type> is action to perform on diagnostics. Possible values are:

enable -- Enables a diagnostic message or a group of messages.

disable -- Disables a diagnostic message or a group of messages.

error -- Tells the compiler to change diagnostics to errors.

warning -- Tells the compiler to change diagnostics to warnings.

remark -- Tells the compiler to change diagnostics to remarks (comments).

file [<file>] -- Tells the compiler to send diagnostics to name-of-the-first-source-file.diag in the current working directory. If argument file is specified, diagnostics are sent to file.diag.

The <diag-list> is a diagnostic group or ID value. Possible values are:

driver -- Specifies diagnostic messages issued by the compiler driver.

vec[<n>] -- Specifies diagnostic messages issued by the vectorizer. n can be any of the following: 1, 2, 3, 4, 5. For more details on these values, see below.

par[<n>] -- Specifies diagnostic messages issued by the auto-parallelizer (parallel optimizer). n can be any of the following: 1, 2, 3.

sv[<n>] -- Specifies diagnostic messages issued by the Static Verifier. n can be any of the following: 1, 2, 3. The number specifies that the severity level of the diagnostic: 1 = produces the diagnostics with severity level set to all critical errors; 2 (default) produces the diagnostics with severity level set to all errors; 3 produces the diagnostics with severity level set to all errors and warnings.

warn -- Specifies diagnostic messages that have a [dq]warning[dq] severity level.

error -- Specifies diagnostic messages that have an [dq]error[dq] severity level.

remark -- Specifies diagnostic messages that are remarks or comments.

cpu-dispatch (i32 and i64em) -- Specifies the CPU dispatch remarks for diagnostic messages. These remarks are enabled by default.

<n>[, <n>, ...] -- Specifies the ID number of one or more messages. If you specify more than one message number, they must be separated by commas; there can be no space between each id.

<tag>[, <tag>, ...] -- Specifies the mnemonic name of one or more messages. If you specify more than one mnemonic name, they must be separated by commas; there can be no space between each tag.

-diag-dump
Print all enabled diagnostic messages and stop compilation.
-diag-enable sv-include
Tells the Static Verifier to analyze include files and source files when issuing diagnostic messages. You must also specify -diag-enable sv to enable the Static Verifier diagnostics.
-diag-file
Causes the results of diagnostics analysis to be output to a file.
-diag-file-append
Causes the results of diagnostics analysis to be appended to a file.
-[no-]diag-id-numbers
Tells the compiler to display diagnostic messages by using their ID number values instead of their mnemonic names. If you specify -no-diag-id-numbers, mnemonic names are output for driver diagnostics only.
-diag-length=<len>
Tells the compiler to format diagnostic messages to fit within a certain number of lines where <len> is the number of lines (Default is 72).
-diag-stop-on-error
Stop when a diagnostic is produced that has an [dq]error[dq] severity level.
 
-fcode-asm
Produce an assembly listing with machine code annotations. The resulting file has a .cod extension.
-f[no-]instrument-functions
Instruments [does not instrument] function entry and exit points.
-fsource-asm
Produce an assembly listing with source code annotations.
-ftrapuv
Initializes stack local variables to an unusual value to help error detection.
-f[no-]verbose-asm
Produce [do not 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. This option turns off -O2 and makes -O0 the default unless -O2 (or another -O option) is explicitly specified in the same command line. Note: On Linux systems using Intel(R) 64 architecture, and on Linux and Mac OS X systems using IA-32 architecture, specifying the -g or -O0 option sets the -fno-omit-frame-pointer option.
-g0
Disable generation of symbolic debug information.
-gdwarf-2
enable generation of debug information using DWARF2 format.
-inline-debug-info
Preserve the source position of inlined code instead of assigning the call-site source position to inlined code.
-map-opts (L*X only)
Enable option mapping tool. Maps one or more compiler options to the equivalent option on other operating systems. Compiler options are mapped to their equivalent on the architecture you are using. For example, if you are using a processor with IA-32 architecture, you will only see equivalent options that are available on processors with IA-32 architecture.
-o<file>
This option specifies the name of an output file as follows:


       *
If the -c option is specified, it specifies the name of the generated object file.

       *
If the -S option is specified, it specifies the name of the generated assembly listing file.

       *
If the -P option is specified, it specifies the name of the generated preprocessor file.

Otherwise, it specifies the name of the executable 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-create <file>
Manual creation of precompiled header <file>. Use the -pch-create <file> option if you want the compiler to create a PCH file called <file>. 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 -pch-use filename. The -pch-create filename option is supported for single source file compilations only. The -create-pch option operates the same as this option.
-pch-dir <dir>
Directs the compiler to find and/or create a file for pre-compiled headers in dirname. Use the -pch-dir <dir> option to specify the path (dirname) to the PCH file. You can use this option with -pch, -create-pch filename, and -use-pch filename. The -use-pch option operates the same as this option when a dirname is specified.
-pch-use <file>
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 <file> or -pch-create <file>. The -use-pch <file> option supports full path names and supports multiple source files when all source files use the same .pchi file. The -use-pch option operates the same as this option when a filename is specified.
-print-multi-lib
Print information about libraries being used.
-S
Compile to an assemblable file (.s), then stop the compilation.
-[no-]use-asm
Produce [do not produce] objects through the assembler.

Note: GNU inline assembler (asm) code and Microsoft inline assembler (msasm) code cannot be used together in the same translation unit.

-use-msasm (i32, i64em only)
Support Microsoft* style assembly language insertion using MASM style syntax and, if requested, output assembly in MASM format.

Note: GNU inline assembler (asm) code and Microsoft inline assembler (msasm) code cannot be used together in the same translation unit.

-use-pch {<file> | <dir>}
Lets you use a specific precompiled header file. The <file> value is the name of the precompiled header file to use. The <dir> value is the path where the file is located, including file. The path must exist. Depending on whether the header file or the path is being specified, this option is the same as the -pch-use <file> or the -pch-dir <dir> option. This option has been deprecated for this release. Suggested replacement -pch-use <file> or -pch-dir <dir>.
 

Data

This section describes options that are related to interpretation of data in programs or the storage of data.

-auto-ilp32 (i64em, i64 only) (L*X only)
Instructs the compiler to analyze and transform the program so that 64-bit pointers are shrunk to 32-bit pointers, and 64-bit longs (on Linux) are shrunk into 32-bit longs wherever it is legal and safe to do so. In order for this option to be effective the compiler must be able to optimize using the -ipo option and must be able to analyze all library or external calls the program makes.

This option requires that the size of the program executable never exceeds 2 (to the 32nd power) bytes and all data values can be represented within 32 bits. If the program can run correctly in a 32-bit system, these requirements are implicitly satisfied. If the program violates these size restrictions, unpredictable behavior might occur.

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

-f[no-]align-functions[=n] (i64em, i64 only)
Instructs the compiler to align functions on an optimal byte boundary. If you do not specify n, the compiler aligns the start of functions on 16-byte boundaries, where n is the byte boundary for function alignment. Possible values are 2 or 16.
-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.
-fmudflap
Causes the compiler to instrument risky pointer operations to prevent buffer overflows and invalid heap use.
-fpack-struct
Pack structure members together.
-f[no-]pic, -f[no-]PIC
i32 and i64em: 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.

-freg-struct-return
Return struct and union values in registers when possible.
-f[no-]stack-security-check (i32, i64em only)
Enable overflow security checks.
-fvisibility=<keyword>
Specifies the visibility for global symbols. 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. Valid keyword values are as follows:

extern -- The symbol is treated as though it is defined in another component. It also means that the symbol can be overridden by a definition of the same name in another component.

default -- Other components can reference the symbol, and the symbol definition can be overridden (preempted) by a definition of the same name in another component.

protected -- Other components can reference the symbol, but it cannot be overridden by a definition of the same name in another component.

hidden -- Other components cannot directly reference the symbol. However, its address may be passed to other components indirectly.

internal -- The symbol cannot be referenced outside its defining component, either directly or indirectly.

-fvisibility-<keyword>=<file>
Specifies the visibility of symbols in a file where file is the full path name a file containing the list of symbols whose visibility you want to set. The symbols must be separated by whitespace (spaces, tabs, or newlines). Visibility specified by -fvisibility-keyword=file overrides visibility specified by -fvisibility=keyword for symbols specified in a file. If a symbol appears in more than one visibility file, the setting with the least visibility takes precedence. Valid keyword values the same as the -fvisibility option.
-[no-]global-hoist
Enables [disables] hoisting and speculative loads of global variables.
-long-double (i32, i64em only)
Enable 80-bit [aq]long double[aq]. The -long_double option is ON by default (80-bit) for L*X and M*X.
-malign-double (i32, i64em only)
Aligns double, long double, and long long types for better performance on systems based on IA-32 architecture.
-malign-mac68k (M*X only)
Aligns structure fields on 2-byte boundaries (m68k compatible).
-malign-natural (M*X only)
Aligns larger types on natural size-based boundaries (overrides ABI).
-malign-power (M*X only)
Aligns based on ABI-specified alignment rules.
-mregparm=<value>
Control the number registers used to pass integer arguments.
-nobss-init
Place variables that are initialized with zeroes in the DATA section instead of the BSS section. This option has been deprecated for this release. Suggested replacement -no-bss-init.
 

Miscellaneous

This section describes the miscellaneous options. The miscellaneous options cover a variety of tasks related to the compiler that do not fit in other categories.

-dryrun
Show driver tool commands but do not execute tools.
-dumpmachine
Display the target machine and operating system configuration.
-dumpversion
Return the version number of the compiler.
-fr32 (i64 only)
Disable use of high floating point registers. Use only lower 32 floating-point registers.
-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.
-mfixed-range=f12-f15,f32-f127 (i64 only)
Reserves certain registers (<range>=f12-f15, f32-f127) for use by the kernel.
-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.
-save-temps
Saves intermediate files created during compilation. The saved file names are based on the name of the source file. The files are saved in the current working directory.
-[no-]sox
Enable [disable, (default)] saving of compiler options and version number in the executable.
-V
Display compiler version information.
-v <file>
Show driver tool commands and execute tools.
--version
Display GCC style version information. Note that two [aq]-[aq]s are required.
 

Component Control

This section describes 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 ([dq][dq]). You must separate multiple arguments with commas.
 

Linking/Linker

This section describes options that affect the linking and/or linker operations.

-all_load (M*X only)
Loads all members of static archive libraries. This option does not apply to dynamic shared libraries.
-Bdynamic (L*X only)
Enables dynamic linking of libraries at run time.
-Bstatic (L*X only)
Enables static linking of a user[aq]s library.
-[no-]cxxlib[=<dir>]
Tells the compiler to link using certain C++ runtime libraries and header files provided by gcc. The <dir> value is an optional top-level location for the gcc binaries and libraries.
-cxxlib-nostd
Prevents linking to the standard C++ library for C++ compilations with icpc.
-dynamiclib (M*X only)
Invokes the libtool command to generate dynamic libraries.
-dynamic-linker <file> (L*X only)
Select a dynamic linker (<file>) other than the default.
-F<dir> (M*X only)
Add a framework directory to the head of the include file search path.
-i-dynamic
Link Intel provided libraries dynamically. This option has been deprecated for this release. Suggested replacement -shared-intel.
-i-static
Links Intel-provided libraries statically. This option has been deprecated for this release. Suggested replacement -static-intel.
-l<string>
Instruct the linker to search for a specified library <dir> when linking. Same as -L<dir>.
-L<dir>
Instruct the linker to search for a specified library <dir> when linking. Because the linker searches and processes libraries and object files in the order they are specified, specify this option following the last applicable object file.
-mcmodel=<mem_model> (i64em)
Tells the compiler to use a specific memory model to generate code and store data. Possible <mem_model> values are:

small -- Default. Restrict code and data to the first 2GB of address space. Use relative addressing.

medium -- Restrict code to the first 2GB. Code access uses IP-relative addressing, but data accesses require absolute addressing.

large -- Places no memory restriction on code or data. All accesses of code and data must be done with absolute addressing.

-mdynamic-no-pic (M*X only)
Generates code that is not position-independent but has position-independent external references.
-m[no-]relax (i64 only)
Pass [do not pass] -relax to the linker. (default = -mno-relax)
-no-cpprt
Link without using the C++ run-time libraries and header files provided by Intel or gcc. This option has been deprecated for this release. Suggested replacement -no-cxxlib.
-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.
-pthread
Use the pthreads library for multithreading support.
-shared (L*X only)
Produce a shared object.
-shared-intel
Link Intel provided libraries dynamically. This is the opposite of the -static-intel option.
-shared-libgcc
Link the libgcc C++ library dynamically, overriding the default behavior when -static is used. This option has the opposite effect of -static-libgcc. When this option is used, the libgcc C++ library is linked in dynamically, allowing the user to override the static linking behavior when the -static option is used.
-static (L*X only)
Prevent linking with shared libraries. Causes the executable to link all libraries statically, as opposed to dynamically.
-static-intel
Link the Intel provided libraries statically.
-static-libgcc
Link the libgcc C++ library statically. By default, the libgcc C++ library is linked in dynamically. Use -static-libgcc on the command line to link libgcc 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>,...]
Pass options <on> to the assembler.
-Wl,<o1>[,<o2>,...]
Pass options o1, o2, etc. to the linker for processing.
-Wp,<o1>[,<o2>,...]
Pass options <on> to the preprocessor.
-Xlinker <option>
Pass <option> directly to the linker for processing.
 

Help

This section describes displays all the available help categories, as follows:

-help [<category>]
Print list of compiler options. Valid categories are in the first column. The full category name is listed in the second column.
  advanced        |  Advanced Optimization
  codegen         |  Code Generation
  compatibility   |  Compatibility
  component       |  Component Control
  data            |  Data
  diagnostics     |  Compiler Diagnostics
  float           |  Floating Point
  help            |  Help
  inline          |  Inlining
  ipo             |  Interprocedural Optimizations (IPO)
  language        |  Language
  link            |  Linking/Linker
  misc            |  Miscellaneous
  openmp          |  OpenMP* and Parallel Processing
  opt             |  Optimization
  output          |  Output, Debug, PCH
  preproc         |  Preprocessor
  pgo             |  Profile Guided Optimization (PGO)
  reports         |  Optimization Reports
 

DEPRECATED AND REMOVED OPTIONS

Occasionally, compiler options are marked as [dq]deprecated.[dq] Deprecated options are still supported in the current release, but are planned to be unsupported in future releases.

Some compiler options are no longer supported and have been removed. If you use one of these options, the compiler issues a warning, ignores the option, and then proceeds with compilation.  

Deprecated Options

The following options are deprecated in this release of the compiler:

-alias-args
Suggested replacement -fargument-alias.
-axB
Suggested replacement -axN or -axW
-c99
Suggested replacement -std=c99.
-create-pch
Suggested replacement -pch-create.
-cxxlib-gcc[=dir]
Suggested replacement -cxxlib[=dir].
-fp
Suggested replacement -fno-omit-frame-pointer.
-fpstkchk
Suggested replacement -fp-stack-check.
-fwritable-strings
No suggested replacement.
-i-dynamic
Suggested replacement -shared-intel.
-i-static
Suggested replacement -static-intel.
-IPF-fp-speculation
Suggested replacement -fp-speculation.
-Kc++
Suggested replacement -x c++.
-march=pentiumii
No suggested replacement.
-march=pentiumiii
Suggested replacement -march=pentium3.
-mcpu
Suggested replacement -mtune.
-no-c99
Suggested replacement -std=c89.
-no-cpprt
Suggested replacement -no-cxxlib.
-nobss-init
Suggested replacement -no-bss-init.
-norestrict
Suggested replacement -no-restrict.
-Ob<n>
Suggested replacement is -inline-level.
-opt-report-level
Suggested replacement -opt-report.
-openmpP
Suggested replacement -openmp.
-openmpS
Suggested replacement -openmp-stubs.
-qp
Suggested replacement -p.
-shared-libcxa
No suggested replacement.
-static-libcxa
No suggested replacement.
-use-pch {<file> | <dir>}fR
Suggested replacement -pch-dir or -pch-use.
-xB
Suggested replacement -xN or -xW
 

Removed Options

The following options are removed in this release of the compiler:

-0f_check
No suggested replacement.
-axi
No suggested replacement.
-axM
No suggested replacement.
-cxxlib-icc
No suggested replacement.
-F
Suggested replacement -P.
-fdiv_check
No suggested replacement.
-ipo-obj, and -ipo_obj
No suggested replacement.
-Kpic, -KPIC
Suggested replacement -fpic.
-Knopic, -KNOPIC
Suggested replacement -fpic.
-pro-format-32
No suggested replacement.
-syntax
Suggested replacement -fsyntax-only.
-tpp1
Suggested replacement -mtune=itanium
-tpp2
Suggested replacement -mtune=itanium2
-tpp5
No suggested replacement.
-tpp6
No suggested replacement.
-tpp7
Suggested replacement -mtune=pentium4.
-xi
No suggested replacement.
-xM
No suggested replacement.
 

PREDEFINED MACROS

The predefined macros available for the Intel C++ Compiler are described in the Intel(R) C++ Compiler Documentation. This section provides a brief summary of the support.

The ANSI/ISO standard for C language requires that certain predefined macros be supplied with conforming compilers. The GNU gcc* predefined macros are all set depending on what version of gcc is found on the user[aq]s system. (This is overridden if the -gcc-version compiler option is passed on the command line.)

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

Suppress Macro Definition

Use the -U<name> 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.
DYLD_LIBRARY_PATH (M*X only)
Specifies the location for all Intel-provided shared dynamic libraries. At runtime, the linker will search the colon-separated list of directories defined by the DYLD_LIBRARY_PATH environment variable. A DYLD_* set of environment variables are all used by [dq]dyld[dq], the dynamic link editor. The full DYLD_* set is documented in [dq]man dyld[dq] on the Mac OS X.
GXX_ROOT
Specifies the location of the gcc binaries. Set this variable only when the compiler cannot locate the gcc binaries when using the -gcc-name option.
GXX_INCLUDE
Specifies the location of the gcc headers. Set this variable only when the compiler cannot locate the gcc headers when using the -gcc-name option.
IA32ROOT (i32, 132em 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.
ICCCFG
Specifies the configuration file for customizing compilations with the icc compiler.
ICPCCFG
Specifies the configuration file for customizing compilations with the icpc compiler.
INTEL_LICENSE_FILE
Specifies the location for the Intel license file.
LD_LIBRARY_PATH (L*X only)
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.
TMP, TMPDIR, 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. If a directory is not specified, the compiler stores temporary files in /tmp.
 

GNU* Environment Variables

The Intel C++ Compiler supports the following GNU environment variables:
C_INCLUDE_PATH
Specifies a list of directories to include for C compilations.
CPATH
Specifies a list of directories to include for C or C++ compilations.
CPLUS_INCLUDE_PATH
Specifies a list of directories to include for C++ compilations.
DEPENDENCIES_OUTPUT
If this variable is set, its value specifies how to output dependencies for Make based on the non-system header files processed by the compiler. System header files are ignored in the dependency output.
GCC_EXEC_PREFIX
This variable specifies alternative names for the linker (ld) and assembler (as).
LIBRARY_PATH
The value of LIBRARY_PATH is a colon-separated list of directories, much like PATH.
SUNPRO_DEPENDENCIES
This variable is the 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(R) C++ Compiler Documentation for more information.  

Standard OpenMP Environment Variables

OMP_NUM_THREADS
Sets the maximum number of threads to use for OpenMP* parallel regions if no other value is specified in the application. This environment variable applies to both -openmp and -parallel.

Default: Number of processors visible to the operating system.

OMP_DYNAMIC
Enables (1) or disables (0) the dynamic adjustment of the number of threads.

Default: 0

OMP_NESTED
Enables (1) or disables (0) nested parallelism.

Default: 0

OMP_SCHEDULE
Sets the run-time schedule type and an optional chunk size.

Default: STATIC, no chunk size specified

 

Intel Extensions to OpenMP Environment Variables

KMP_ALL_THREADS
Limits the number of simultaneously executing threads in an OpenMP program. If this limit is reached and another native operating system thread encounters OpenMP* API calls or constructs, then the program may abort with an error message. If this limit is reached at the time an OpenMP parallel region begins, a one-time warning message may be generated indicating that the number of threads in the team was reduced, but the program will continue execution. This environment variable is only used for programs compiled with -openmp or -openmp-profile.

Default: No limit is enforced

KMP_BLOCKTIME
Sets the time, in milliseconds, that a thread should wait, after completing the execution of a parallel region, before sleeping. Use the optional character suffixes: s (seconds), m (minutes), h (hours), or d (days) to specify the units. Specify infinite for an unlimited wait time.

Default: 200 milliseconds

KMP_LIBRARY
Selects the OpenMP run-time library execution mode. The options for the variable value are throughput, turnaround, and serial.

Default: throughput (execution mode)

KMP_MONITOR_STACKSIZE
Sets the number of bytes to allocate for the monitor thread, which is used for book-keeping during program execution. Use the optional suffixes: b (bytes), k (kilobytes), m (megabytes), g (gigabytes), or t (terabytes) to specify the units.

Default: max(32k, system minimum thread stack size)

KMP_STACKSIZE
Sets the number of bytes to allocate for each OpenMP thread to use as the private stack for the thread. Use the optional suffixes: b (bytes), k (kilobytes), m (megabytes), g (gigabytes), or t (terabytes) to specify the units. This variable does not affect the native operating system threads created by the user program nor the thread executing the sequential part of an OpenMP* program or parallel programs created using -parallel. Recommended size is 16m.

Default:

i32: 2m

i64em: 4m

i64: 4m

KMP_VERSION
Enables (1) or disables (0) the printing of OpenMP runtime library version information during program execution.

Default: 0 (disabled)

KMP_AFFINITY
Enables run-time library to bind threads to physical processing units.

Default: noverbose,respect,granularity=core

KMP_CPUINFO_FILE
Specifies an alternate file name for file containing machine topology description. The file must be in the same format as /proc/cpuinfo.

Default: none

 

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

EXAMPLES

The following examples demonstrate optimizing across multiple input files:
  1.  icc ax.cpp
      This command compiles the C++ file [aq]ax.cpp[aq] 
      producing executable file [aq]a.out[aq]. Optimizations 
      occur by default.
  2.  icc -o abc ax.cpp bx.cpp cx.cpp
      This command uses option -o to name the 
      executable file [aq]abc[aq] and compiles [aq]ax.cpp[aq], 
      [aq]bx.cpp[aq], and [aq]cx.cpp[aq] 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 [aq]ax.o[aq], [aq]bx.o[aq], and [aq]cx.o[aq]. Interprocedural 
      optimizations are prevented.
  4.  icc -c ay.c
      This command compiles the C file [aq]ay.c[aq] and the 
      -c option suppresses linking to produce of an 
      object file [aq]ay.o[aq].
  5.  icpc -c by.cpp
      This command compiles the C++ file [aq]by.cpp[aq] and 
      the -c option suppresses linking to produce an 
      object file [aq]by.o[aq].
  6.  icpc ay.o by.o
      This command links the two object files [aq]ay.o[aq] 
      and [aq]by.o[aq] and produces an executable 
      file [aq]a.out[aq].
  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 [aq]sub2[aq]; the second generates
      an object file of [aq]sub3[aq].
      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 information about Intel software products, see http://www.intel.com/software/products. For general support information, see http://www.intel.com/software/products/support. For additional support information, see the Technical Support section of the Product Release Notes.

See the Registration web site for licensing and registration guidance: https://registrationcenter.intel.com/regcenter/register.aspx.

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.  

SEE ALSO

The Intel(R) C++ Compiler Documentation is the definitive source for detailed information on using the Intel(R) C++ Compiler, including a complete listing of all compiler options and much more. In addition, see these other documents:
*
Product Release Notes
*
IA-64 Architecture Assembler User[aq]s Guide
*
IA-64 Architecture Assembly Language Reference Guide

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

COPYRIGHT INFORMATION

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL(R) PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.

Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.

The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.

Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.

Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or by visiting Intel's Web Site.

Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. See http://www.intel.com/products/processor_number for details.

BunnyPeople, Celeron, Celeron Inside, Centrino, Centrino logo, Core Inside, FlashFile, i960, InstantIP, Intel, Intel logo, Intel386, Intel486, Intel740, IntelDX2, IntelDX4, IntelSX2, Intel Core, Intel Inside, Intel Inside logo, Intel. Leap ahead., Intel. Leap ahead. logo, Intel NetBurst, Intel NetMerge, Intel NetStructure, Intel SingleDriver, Intel SpeedStep, Intel StrataFlash, Intel Viiv, Intel vPro, Intel XScale, IPLink, Itanium, Itanium Inside, MCS, MMX, Oplus, OverDrive, PDCharm, Pentium, Pentium Inside, skoool, Sound Mark, The Journey Inside, VTune, Xeon, and Xeon Inside are trademarks of Intel Corporation in the U.S. and other countries.

* Other names and brands may be claimed as the property of others.

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


 

Index

NAME
SYNOPSIS
DESCRIPTION
GNU gcc* Interoperability
OPTION SUMMARIES
Option Alphabetic Summary
Vectorization Options (i32, i64em only)
Auto Parallelization Options
Parallelization with OpenMP*
Precompiled Headers
Optimization
Advanced Optimization
Code Generation
Compatibility
Compiler Diagnostics
Inlining
Interprocedural Optimizations (IPO)
Profile Guided Optimization (PGO)
Optimization Reports
OpenMP and Parallel Processing
Floating Point
Preprocessor
Output, Debug, PCH
Data
Miscellaneous
Component Control
Linking/Linker
Help
DEPRECATED AND REMOVED OPTIONS
Deprecated Options
Removed Options
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: 22:45:37 GMT, June 24, 2019