ICC(1)			Intel(R) C++ Compiler Options		       ICC(1)



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 com-
       mand. 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,  assem-
       ble, and link these programs.


       This  document explains how information and instructions apply differ-
       ently 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;	 how-
       ever,  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 oper-
       ating 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 abbrevia-
       tion. 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	 ver-
       sions  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* interoperabil-
       ity 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 ver-
       sions greater than or equal to 3.2. See the Intel(R) C++ Compiler Doc-
       umentation 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 Func-
       tional 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 automati-
       cally 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	 com-
       plete information on the vectorizer.

   Auto Parallelization Options
       The  auto-parallelization  feature of the Intel C++ Compiler automati-
       cally translates serial portions of the input program into  equivalent
       multithreaded code. The auto-parallelizer analyzes the dataflow of the
       program's loops and generates multithreaded code for those loops which
       can  be	safely and efficiently executed in parallel. This enables the
       potential exploitation of the parallel architecture found in symmetric
       multiprocessor (SMP) systems.
       The  parallel  run-time	support	 provides  the same run-time features
       found in OpenMP*, such as handling the details of loop iteration modi-
       fication, 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	trig-
       gered  by  the  -parallel  option  automatically identifies those loop
       structures that contain parallelism. During compilation, the  compiler
       automatically  attempts	to decompose the code sequences into separate
       threads for parallel processing. No other effort by the programmer  is
       needed.

   Parallelization with OpenMP*
       The Intel C++ Compiler supports the "OpenMP Application Program Inter-
       face Version 2.5". This single API now covers the  C/C++	 and  Fortran
       languages.  The	compiler  performs transformations to generate multi-
       threaded code based on the user's placement of  OpenMP  directives  in
       the  source  program making it easy to add threading to existing soft-
       ware. The Intel compiler supports all of the current industry-standard
       OpenMP  directives,  except  WORKSHARE, and compiles parallel programs
       annotated with OpenMP 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 sig-
       nificantly 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 com-
       pile times.  See the Intel(R) C++ Compiler Documentation for more com-
       plete 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	 com-
		 piled	with -fast will execute on Intel(R) Pentium(R) 4 pro-
		 cessors with Streaming SIMD Extensions	 3  (SSE3)  or	later
		 processors  only.   Programs  compiled with this option will
		 detect non-compatible processors and generate an error	 mes-
		 sage 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  -ffunc-
	      tion-sections.


       -f[no-]exceptions
	      Enables  [disables]  exception handling table generation, which
	      can result in smaller code. Any use of exception handling	 con-
	      structs  -  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] alias-
	      ing 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  compila-
	      tion.


       -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 reg-
	      ister 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'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 opti-
		 mization. The compiler optimizes under the  assumption	 that
		 the application is memory bound.

		 never	--  disables generation of streaming stores for opti-
		 mization. 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 recom-
	      mended 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 aggres-
	      sive optimizations such as loop and memory  access  transforma-
	      tion,  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 con-
	      trol memory bandwidth use among processors.  It allows the com-
	      piler  to be less aggressive with optimizations that might con-
	      sume 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 opti-
	      mizations 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	-par-
		 allel	or  -openmp  is	 specified,  or Cluster OpenMP option
		 -cluster-openmp is specified (see the Cluster	OpenMP	docu-
		 mentation).

		 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'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 accept-
	      able 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 vec-
	      torized  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 stor-
	      age.


       -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 configura-
	      tion 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  alloca-
	      tion. This may improve speed. Valid values for n are:

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

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

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

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


       -opt-ra-region-strategy[=keyword]
	      Selects  the  method that the register allocator uses to parti-
	      tion 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	-fun-
	      roll-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 opti-
		 mize  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) proces-
		 sors with SSE2.

		 -axK -- Can generate specialized code paths for SSE instruc-
		 tions	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) pro-
	      cessor.

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


       -march=<cpu> (i32, i64em only)
	      Generate code exclusively for a given cpu.  For  this  release,
	      the  <cpu>  values of pentiumii and pentiumiii have been depre-
	      cated.  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  follow-
	      ing:

		 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) Opti-
		 mize 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) proces-
		 sor

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

		 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	 pro-
	      cessors.	 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  follow-
	      ing:

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

		 pentium4  -- (i32 only; default on IA-32 architecture) Opti-
		 mize 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)	 pro-
		 cessors.

		 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  instruc-
		 tions	for future Intel processors that support the instruc-
		 tions.

		 -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) pro-
		 cessors 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 pro-
		 cessors, 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 pro-
		 cessors, and it can optimize for Intel(R) Pentium(R) 4	 pro-
		 cessors 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 architec-
	      ture,  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 high-
	      est-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  compati-
	      ble with the targeted processor. The resulting program may fail
	      with an illegal instruction exception or	display	 other	unex-
	      pected behavior. For example, binaries produced with W may pro-
	      duce code that will not run on Intel(R) Pentium(R) III  proces-
	      sors  or	earlier	 processors that do not support SSE2 instruc-
	      tions.

	      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 proces-
	      sors that support all of the features for the targeted  proces-
	      sor.  For	 example,  binaries  produced  with  W will run on an
	      Intel(R) Core(TM)2 Duo processor, because that  processor	 com-
	      pletely  supports	 all of the capabilities of the Intel(R) Pen-
	      tium(R) 4 processor, which the W value targets. Specifying  the
	      T	 value has the potential of using more features and optimiza-
	      tions available to the Intel(R) Core(TM)2 Duo processor.

	      By default, the compiler does not generate optimized code	 spe-
	      cialized	for the processor on Linux systems using IA-32 archi-
	      tecture.


       -[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	 dep-
	      recated for this release.	 Suggested replacement -std=c99.


       -[no-]early-template-check
	      Lets  you	 semantically check template function template proto-
	      types 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 'typeof' as a keyword.


       -fno-implicit-inline-templates
	      Do  not  emit  code  for implicit instantiations of inline tem-
	      plates.


       -fno-implicit-templates
	      Never emit code for non-inline templates which are instantiated
	      implicitly (i.e. by use); only emit code for explicit instanti-
	      ations.


       -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 "-p" 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.	 Sug-
	      gested replacement -x c++.


       -[no-]restrict
	      Enable [disable]	the  "restrict"	 keyword  for  disambiguating
	      pointers.	 The default is -no-restrict.


       -std=<value>
	      Conform  to  a  specific language standard.  Possible <value>'s
	      are:

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

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

		 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  recog-
	      nized 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 prepro-
		 cessed

		 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 ver-
		 sion 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 state-
	      ments.


       -gcc-name=<dir>
	      specify the location of the gcc compiler when the compiler can-
	      not 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 repre-
		 sented 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 dis-
       played 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 Col-
	      lector API.


       -[no]traceback
	      Tell the compiler to generate [not generate] extra  information
	      in  the  object file to allow the display of source file trace-
	      back 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,  repre-
	      sents  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, com-
	      pilation 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 func-
	      tion.


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


       -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 con-
	      verted 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()	opti-
	      mizations.


       -[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 con-
	      siders 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'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 con-
	      siders 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'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, inter-
       procedural constant propagation, monitoring module-level static	vari-
       ables, 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'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 informa-
       tion 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 opti-
	      mizations.


       -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  applica-
	      tions, 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 simulta-
	      neously  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 trav-
       eled 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 informa-
       tion 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 con-
	      tain the cold or very infrequently executed code, and one	 sec-
	      tion 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	 rou-
		 tine 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 fre-
		 quently 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	opti-
	      mization	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 sup-
	      ported 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  applica-
	      tion 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 optimiza-
       tion 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	 gen-
	      eration.


       -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 gener-
	      ated. 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 opti-
	      mizers.  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 speci-
		 fied  for <name>, all reports from that optimizer are gener-
		 ated.


       -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  perfor-
	      mance.  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'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 prohibit-
		 ing 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  optimiza-
	      tion  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	 com-
		 patibility  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'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 sec-
		 tions 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  -paral-
	      lel  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 granu-
	      larity 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	"LOOP  AUTO-PARALLELIZED" message for
		 parallel loops.

		 2 -- indicates successfully auto-parallelized loops as	 well
		 as unsuccessful loops.

		 3  -- same as 2 plus additional information about any proven
		 or  assumed  dependencies  inhibiting	 auto-parallelization
		 (reasons for not parallelizing).


       -par-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  paral-
	      lel.  This option is used for loops whose computation work vol-
	      ume cannot be determined at compile-time. The threshold is usu-
	      ally  relevant  when  the	 loop  trip  count is unknown at com-
	      pile-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
		 ("extended") 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 pre-
		 cision and enables value-safe optimizations.

		 strict	 -- Enables "precise" and "except", disables contrac-
		 tions, and enables pragma "stdc fenv_access".


       -[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.	 Sug-
	      gested 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 accu-
	      racy.  By	 default  (-IPF-fltacc-) the compiler may apply opti-
	      mizations 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 vari-
	      able 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  opera-
	      tions  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 condi-
	      tions:

		 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  optimiza-
	      tions). 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 optimiza-
	      tions 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  interven-
		 tion)	may affect the results returned by some of the mathe-
		 matical 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	main-
	      tain  the	 value of 1/B, use -no-prec-div to disable the float-
	      ing-point division-to-multiplication optimization.  The  result
	      of  -no-prec-div	is  more  accurate, with some loss of perfor-
	      mance.


       -[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. How-
	      ever, the C language requires floating point values to be trun-
	      cated  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 conver-
	      sions to integer will not conform to C semantics.



   Preprocessor
       The preprocessor options described in this section control preprocess-
       ing 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 fol-
	      lowing 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 direc-
	      tives in the output. -EP is equivalent to -E -P.


       -H     Print "include" file order and continue compilation.


       -I<dir>
	      Add directory <dir> to include file search path.	For  multiple
	      search directories, multiple  I<dir> commands must be used. The
	      compiler searches directories for include files in the  follow-
	      ing  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  prepro-
	      cessing 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 spec-
	      ify -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 direc-
	      tives.  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'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 com-
	      piler 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 out-
       put, 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 informa-
		 tion.

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

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

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

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

		 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 com-
		 piler driver.

		 vec[<n>] -- Specifies diagnostic messages issued by the vec-
		 torizer.  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  "warning"
		 severity level.

		 error	-- Specifies diagnostic messages that have an "error"
		 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 "error" 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  assem-
	      blable  file will not.  The -g option changes the default opti-
	      mization 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 com-
	      mand line.

	      Note:  On Linux systems using Intel(R) 64 architecture, and  on
	      Linux  and Mac OS X systems  using IA-32 architecture, specify-
	      ing 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 assign-
	      ing 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	 com-
	      piler  to	 use  appropriate  PCH files.  If none are available,
	      they are created as sourcefile.pchi. This option supports	 mul-
	      tiple 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-cre-
	      ate <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-com-
	      piled 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  effec-
	      tive  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	 val-
		 ues  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 preemp-
	      tion.  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 com-
		 ponent.

		 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 compo-
		 nents 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 vis-
	      ibility  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 sym-
	      bol  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 'long double'.  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 per-
	      formance 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 depre-
	      cated 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 ver-
	      sion 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 '-'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 ("").
	      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'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++ compila-
	      tions 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	posi-
	      tion-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 allow-
	      ing 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 "deprecated."  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'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 func-
       tion as an #undef preprocessor directive.



ENVIRONMENT VARIABLES
       You can customize your environment by setting the  following  environ-
       ment  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-sepa-
	      rated list of  directories  defined  by  the  DYLD_LIBRARY_PATH
	      environment  variable.   A  DYLD_* set of environment variables
	      are all used by "dyld", the  dynamic  link  editor.   The	 full
	      DYLD_* set is documented in "man dyld" 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 exe-
	      cutable 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	vari-
       ables:


       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++  compi-
	      lations.


       CPLUS_INCLUDE_PATH
	      Specifies	 a  list  of  directories to include for C++ compila-
	      tions.


       DEPENDENCIES_OUTPUT
	      If this variable is set, its  value  specifies  how  to  output
	      dependencies for Make based on the non-system header files pro-
	      cessed 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 directo-
	      ries, 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 num-
	      ber 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	 con-
	      structs,	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-pro-
	      file.


	      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 suf-
	      fixes: 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 pro-
	      filing process.


       PROF_DUMP_INTERVAL
	      Initiate Interval Profile Dumping in an  instrumented  applica-
	      tion. 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 ini-
	      tiating 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 warn-
	      ing 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 'ax.cpp'
	     producing executable file 'a.out'. Optimizations
	     occur by default.

	 2.  icc -o abc ax.cpp bx.cpp cx.cpp

	     This command uses option -o to name the
	     executable file 'abc' and compiles 'ax.cpp',
	     'bx.cpp', and 'cx.cpp' as one program.

	 3.  icc -c ax.cpp bx.cpp cx.cpp

	     This command uses option -c to suppress
	     linking and produce individual object
	     files 'ax.o', 'bx.o', and 'cx.o'. Interprocedural
	     optimizations are prevented.

	 4.  icc -c ay.c

	     This command compiles the C file 'ay.c' and the
	     -c option suppresses linking to produce of an
	     object file 'ay.o'.

	 5.  icpc -c by.cpp

	     This command compiles the C++ file 'by.cpp' and
	     the -c option suppresses linking to produce an
	     object file 'by.o'.

	 6.  icpc ay.o by.o

	     This command links the two object files 'ay.o'
	     and 'by.o' and produces an executable
	     file 'a.out'.

	 7.  icc -c -O1 sub2.cpp
	     icc -c -O1 sub3.cpp
	     icc -o main.exe -g -O0 main.cpp sub2.o sub3.o

	     The first two commands show incremental
	     compilation with minimal optimization.
	     The first command generates an object
	     file of 'sub2'; the second generates
	     an object file of 'sub3'.

	     The last command uses option -O0 to
	     disable all compiler default optimizations.
	     It uses option -g to generate symbolic
	     debugging information and line numbers in
	     the object code, which can be used by a
	     source-level debugger.



TECHNICAL SUPPORT
       The Intel C++ Compiler product web site offers timely  and  comprehen-
       sive  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 informa-
       tion, see  http://www.intel.com/software/products/support.  For	addi-
       tional  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	 Sup-
       port  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'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	aris-
       ing  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/prod-
       ucts/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	 Sin-
       gleDriver, Intel SpeedStep, Intel StrataFlash, Intel Viiv, Intel vPro,
       Intel XScale, IPLink, Itanium, Itanium Inside, MCS, MMX, Oplus,	Over-
       Drive, PDCharm, Pentium, Pentium Inside, skoool, Sound Mark, The Jour-
       ney Inside, VTune, Xeon, and Xeon Inside are trademarks of Intel	 Cor-
       poration 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.



Copyright(C) 2002 - 2007      Intel Corporation			       ICC(1)