Intel(R) C++ Compiler

NAME
       Intel(R) C++ Compiler

SYNOPSIS
       icc [options] file1 [file2 ...] where:

       options represents zero or more compiler options

       fileN  is  a  C/C++  source  (.C .c .cc .cpp .cxx .i), assembly (.s), object (.o), static
       library (.a), or other linkable file

       NOTE:  Commonly used options may be placed in the icc.cfg file.

DESCRIPTION
       Intel(R)  C++  Compiler Options. This compiler is designed to preprocess, compile, assem-
       ble, and link C and C++ programs on IA-32 systems.

Compiler Option List
   Performance
       -O1            Enable optimizations

       -O2            Same as -O1 (DEFAULT)

       -O3            Enable -O2 plus more aggressive optimizations that may not improve perfor-
                      mance for all programs

       -O0            Disable optimizations

       -O             Same as -O1

       -Ob<n>         Control inline expansion:

                      n=0 -- Disables inlining

                      n=1 -- Inline functions declared with __inline, and perform C++ inlining

                      n=2 -- Inline any function, at the compiler's discretion (same as -ip)

       -falias        Assume aliasing in program (DEFAULT)

       -fno-alias     Assume no aliasing in program

       -nolib_inline  Disable inline expansion of intrinsic functions

       -mp            Maintain floating point precision (disables some optimizations)

       -mp1           Improve floating-point precision (speed impact is less than -mp)

       -fp            Disable using EBP as general purpose register

       -prec_div      Improve precision of floating-point divides (some speed impact)

       -fp_port       Round fp results at assignments & casts (some speed impact)

       -pc32          Set internal FPU precision to 24 bit significand

       -pc64          Set internal FPU precision to 53 bit significand (DEFAULT)

       -pc80          Set internal FPU precision to 64 bit significand

       -rcd           Enable fast float-to-int conversions

       -tpp5          Optimize for Pentium(R) processor

       -tpp6          Optimize for Pentium(R) Pro, Pentium(R) II and Pentium(R) III processors

       -tpp7          Optimize for Pentium(R) 4 processor

       -ax<codes>     Generate  code  specialized  for processor extensions specified by <codes>
                      while also generating generic IA-32 code. <codes> includes one or more  of
                      the following characters:

                      i -- Pentium Pro and Pentium II processor instructions

                      M -- MMX(TM) instructions

                      K -- Streaming SIMD Extensions

                      W -- Pentium(R) 4 New Instructions

       -x<codes>      Generate  specialized code to run exclusively on processors supporting the
                      extensions indicated by <codes> as described above.

       -march=<cpu>   Generate code excusively for a given <cpu>

                      pentiumpro -- Pentium(R) Pro and Pentium(R) II processor instructions

                      pentiumii -- MMX(TM)instructions

                      pentiumiii -- Streaming SIMD Extensions

                      pentium4 -- Pentium(R) 4 New Instructions

       -mcpu=<cpu>    Optimize for a specific cpu

                      pentium -- Optimize for Pentium(R) processor

                      pentiumpro -- Optimize for Pentium(R) Pro, Pentium(R)  II  and  Pentium(R)
                      III processors

                      pentium4 -- Optimize for Pentium(R) 4 processor

   Advanced Performance
       Enable and specify the scope of Interprocedural (IP) Optimizations:

       -ip            Enable single-file IP optimizations (within files)

       -ipo           Enable multi-file IP optimizations (between files)

       -ipo_c         Generate a multi-file object file (ipo_out.o)

       -ipo_S         Generate a multi-file assembly file (ipo_out.s)

       Modify the behavior of IP:

       -ip_no_inlining
                      Disable full and partial inlining (requires -ip or -ipo)

       -ip_no_pinlining
                      Disable partial inlining (requires -ip or -ipo)

       -ipo_obj       Force generation of real object files (requires -ipo)

       Other Advanced Performance Options:

       -unroll[n]     Set maximum number of times to unroll loops. Omit n to use default heuris-
                      tics. Use n=0 to disable loop unroller.

       -prof_dir <d>  Specify directory for profiling output files (*.dyn and *.dpi)

       -prof_file <f> Specify file name for profiling summary file

       -prof_gen[x]   Instrument program for profiling; with the x qualifier, extra  information
                      is gathered

       -prof_use      Enable use of profiling information during optimization

       -qp, -p, -pg   Compile and link for function profiling with UNIX prof tool

       -vec           Enable(DEFAULT) the vectorizer

       -vec_report[n] Control amount of vectorizer diagnostic information:

                      n=0 -- No diagnostic information

                      n=1 -- Indicate vectorized loops (DEFAULT)

                      n=2 -- Indicate vectorized/non-vectorized loops

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

                      n=4 -- Indicate non-vectorized loops

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

       -opt_report    Generate an optimization report to stderr

       -opt_report_file<file>
                      Specify the filename for the generated report

       -opt_report_level[level]
                      Specify the level of report verbosity (min|med|max)

       -opt_report_phase<name>
                      Specify the phase that reports are generated against

       -opt_report_routine<name>
                      Reports on routines containing the given name

       -opt_report_help
                      Display the optimization phases available for reporting

       -openmp        Enable  the  compiler  to generate multi-threaded code based on the OpenMP
                      directives

       -openmp_stubs  Enables the user to compile OpenMP programs in sequential mode. The openmp
                      directives are ignored and a stub OpenMP library is linked (sequential)

       -openmp_report{0|1|2}
                      Control the OpenMP parallelizer diagnostic level

       -parallel      Enable  the  auto-parallelizer  to  generate multi-threaded code for loops
                      that can be safely executed in parallel

       -par_report{0|1|2|3}
                      Control the auto-parallelizer diagnostic level

       -par_threshold[n]
                      Set threshold for the auto-parallelization of loops where n is an  integer
                      from 0 to 100

       -ansi_ansi[-]  Enable(DEFAULT)[disable]  stating  ANSI compliance of the compiled program
                      and that optimizations can be based on the ANSI rules

   Output, Debug
       -c             Compile to object (.o) only, do not link

       -S             Compile to assembly (.s) only, do not link (*I)

       -use_asm       Produce objects through assembler

       -use_msasm     Support Microsoft style assembly language insertion using MASM style  syn-
                      tax and, if requested, output assembly in MASM format

       -o<file>       Name output file

       -g             Produce symbolic debug information in object file

       -inline_debug_info
                      Preserve  the  source  position  of  inlined code instead of assigning the
                      call-site source position to inlined code

   C Preprocessor
       -A<name>[(val)]
                      Create an assertion 'name' having value 'val'

       -A-            Remove all predefined macros

       -C             Don't strip comments

       -D<name>[{=|#}<text>]
                      Define macro

       -E             Preprocess to stdout

       -EP            Preprocess to stdout omitting #line directives

       -P, -F         Preprocess to file

       -I<dir>        Add directory to include file search path

       -U<name>       Remove predefined macro

       -X             Remove standard directories from include file search path

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

       -M             Generate makefile dependency information

       -MD            Preprocess and compile. Generate output  file  (.d  extension)  containing
                      dependency information.

       -MF<file>      Generate  makefile  dependency  information  in <file>. Must specify -M or
                      -MM.

       -MG            Similar to -M, but treats missing header files as generated files.

       -MM            Similar to -M, but does not include system header files.

       -MMD           Similar to -MD, but does not include system header files.

       -MX            Generate dependency file (.o.dep extension)  containing  information  used
                      for the Intel wb tool.

       -MM            Similar to -M, but do not include system header files

       -MG            Similar to -M, but treat missing header files as generated files

       -MD            Preprocess  and  compile,  generating  output  file  containing dependency
                      information ending with extension .d

       -MMD           Similar to -MD, but do not include system header files

       -MF<file>      Generate makefile dependency information in file (must specify -M or -MM)

       -MX            Generate dependency file ending with extension .o.dep containing  informa-
                      tion used for the Intel wb tool

       -dM            Output macro definitions in effect after preprocessing (use with -E)

       -idirafter<dir>
                      Add directory (dir) to the second include file search path (after -I)

   Component Control
       -Qoption,<str>,<opts>
                      Pass options <opts> to tool specified by <str>

       -Qlocation,<str>,<dir>
                      Set <dir> as the location of tool specified by <str>

       -Qinstall <dir>
                      Set <dir> as root of compiler installation

   Language
       -ansi          Enable(DEFAULT) assumption of ANSI conformance

       -restrict      Enable the 'restrict' keyword for disambiguating pointers

       -Xa            Select extended ANSI C dialect

       -Xc            Select strict ANSI conformance dialect

       -c99[-]        Enable(DEFAULT) [disable] C99 support for C programs

       -std=c99       Enable C99 support for C programs.

       -XU            C++ compilation follows ARM and cfront with anachronisms

       -Timplinc      Enable implicit inclusion of source files for finding template defs

       -Tnoauto       Disable automatic instantiation of templates

       -Tused         Instantiate template functions used in this compilation

       -Tlocal        Instantiate template functions used in this compilation, make local

       -Knovtab       Suppress definition of vftables for classes without non-inline vfns

       -Kc++          Compile all source or unrecognized file types as C++ source files

       -Krtti         Enable C++ RTTI (DEFAULT)

       -Zp[n]         Specify alignment constraint for structures (n=1,2,4,8,16)

       -syntax        Perform syntax check only

       -fno-rtti      Disable RTTI support

       -fshort-enums  Allocate as many bytes as needed for enumerated types

       -fsyntax-only  Same as -syntax

       -funsigned-char
                      Change default char type to unsigned

       -funsigned-bitfields
                      Change default bitfield type to unsigned

   Compiler Diagnostics
       -w             Disable all warnings

       -w<n>          Control diagnostics:

                      n=0 -- Display errors (same as -w)

                      n=1 -- Display warnings and errors (DEFAULT)

                      n=2 -- Display remarks, warnings, and errors

       -wn<n>         Print a maximum of n errors

       -wd<L1>[,<L2>,...]
                      Disable diagnostics L1 through LN

       -we<L1>[,<L2>,...]
                      Change severity of diagnostics L1 through LN to error

       -ww<L1>[,<L2>,...]
                      Change severity of diagnostics L1 through LN to warning

       -wr<L1>[,<L2>,...]
                      Change severity of diagnostics L1 through LN to remark

       -Wall          Enable all warnings

       -Werror        Force warnings to be reported as errors

   Miscellaneous
       -help          Prints list of compiler options

       -V             Display compiler version information

       -sox[-]        Enable(DEFAULT)  [disable]  saving  of compiler options and version in the
                      executable

       -Kpic, -KPIC   Generate position independent code

       -long_double   Enable 80-bit 'long double'

       -nobss_init    Disable placement of zero-initialized variables in BSS (use DATA)

       -0f_check      Enable the patch for the Pentium 0f erratum

       -v             Show driver tool commands and execute tools

   Linking/Linker
       -L<dir>        Instruct linker to search <dir> for libraries

       -i_dynamic     Link Intel provided libraries dynamically

       -no_cpprt      Do not link in C++ runtime libraries

       -nodefaultlibs Do not use standard libraries when linking

       -nostartfiles  Do not use standard startup files when linking

       -nostdlib      Do not use standard libraries and startup files when linking

       -static        Prevents linking with shared libraries

       -shared        Produce a shared object

       -u <symbol>    Pretend the <symbol> is undefined

       -Xlinker <val> Pass <val> directly to the linker for processing

       -Wl,<o1>[,<o2>,...]
                      Pass options o1, o2, etc. to the linker for processing

       -dynamic-linker<filename>
                      Selects a dynamic linker (filename) other than the default

Copyright(C) 2002                       Intel Corporation                                 ICC(1)