The Intel® C++ Compiler for IA-32 based applications contains the following components:
<install-dir>/doc/Doc_Index.htm
The Intel® C++ Compiler for Intel EM64T-based applications contains the following components:
<install-dir>/doc/Doc_Index.htm
The Intel® C++ Compiler for Itanium-based applications contains the following components:
<install-dir>/doc/Doc_Index.htm
The Intel® C++ Compiler for Linux includes compiler integration with Eclipse* and the C/C++ Development Tools* (CDT). This functionality is an optional part of the compiler installation.
Eclipse is an open source software development project dedicated to providing a robust, full-featured, commercial-quality, industry platform for the development of highly integrated tools. It is an extensible, open source Integrated Development Environment (IDE).
The CDT (C/C++ Development Tools) project is dedicated to providing a fully functional C/C++ IDE for the Eclipse platform. CDT is layered on Eclipse, and provides a C/C++ development environment perspective.
The Intel C++ Compiler integration with the Eclipse/CDT IDE lets you develop, build, and run your Intel C/C++ projects in a visual, interactive environment.
See Also
The following section discusses new features and changes in the Intel C++ Compiler version 9.1 and updates to 9.1. Please see the separate release notes for the Intel Debugger. More detailed explanations are given below. Not all updates have feature changes. Please view the README.TXT from Intel® Software Development Products Registration Center Product Downloads for information on corrections to reported errors. Note: update numbers are shown for comparison: the actual update number may be higher.
9.1.052
9.1.051
9.1.049
9.1.047
The following is a listing of command line options that are new or have changed since the initial version 9.0 release. Please refer to the compiler documentation for more information on these options.
-axT-dD-dM, but outputs #define directives in preprocessed
source. (Default: off)-dM-dN-dD, but #define directives contain only macro names. (Default:
off)-early-template-check-fargument-alias-alias-args (Default: on) -finline-limit=n-f[no-]non-lvalue-assign-fnon-lvalue-assign)-fvisibility-inlines-hidden-inline-factor=<n>-inline-forceinline-inline-max-per-compile=<n>-inline-max-per-routine=<n>-inline-max-size=<n>-inline-max-total-size=<n>-inline-min-size=<n>-iquote <dir>-isystem <dir>-mcmodel=mem_model-mcmodel=small) -mtune itanium2-p9000-opt-mem-bandwidth<n>-xTFor information on command line options that are either deprecated (still functional but to be removed in a future version) or removed (no longer supported), please refer to the chapter Deprecated and Removed Compiler Options in the Intel® Fortran Compiler Options Manual.
Many command line options have an older spelling where underscores (“_”) instead of hyphens (“-“) connect the words in the option name. The older spelling is still a valid alternate option name.
-fp-model to Control ReassociationThe -fp-model option controls the semantics of floating point
operations. The default is -fp-model fast which allows the
compiler to perform aggressive optimizations including reassociations across
parentheses. To obtain the best performance while still strictly obeying
the language standard's rules for arithmetic reassociation, use -fp-model
precise.
We have extended our Gnu compatibility to closely match the language
semantics of different Gnu versions. For example, under -gcc-version=340 (which is automatically set if you have Gnu version 3.4 headers
and libraries installed on your system), you will see that the
compiler is more conformant to the ISO/ANSI C++ standard.
The specific changes are described in the Gnu documentation at http://gcc.gnu.org/gcc-3.4/changes.html (look under C++):
Variable length arrays in C++ no longer require the element type to be of POD (Plain Old Data) type.
The C++ copy constructor return value optimization will now be done in spite of cv-qualifier differences between the local variable and the return type and copy constructor calls in direct-initializations are now elided.
A compiler integration with Eclipse* and the C/C++ Development Tools* (CDT) is now provided for Intel Itanium-based systems.
crtxn.o Is Now crtend.o The file crtxn.o has been changed to crtend.o.
This only affects links in -cxxlib-icc mode. The change
was necessary because of changes made elsewhere in the compiler.
This name is used by the built-in linker script to order initialization
sections correctly and without this change, initialization of non-statically
initialized globals would not work correctly.
If you are using your own explicit link line in -cxxlib-icc mode,
you will need to make the corresponding change. If you are using icc or
icpc to do your links, no change is needed.
libimf Linking Change on Intel® 64-based
Systems In some earlier versions of Intel C++ Compiler, applications built
for Intel® 64 linked by default to the dynamic (shared object)
version of libimf, even though other libraries were linked
statically. In the current version, libimf is linked statically
unless -i-dynamic is
used. This matches the behavior on IA-32 systems. You should use -i-dynamic to
specify the dynamic Intel libraries if you are linking against
shared objects built by Intel compilers.
A side effect of this change is that users may see the following message from the linker:
warning: feupdateenv is not implemented and will always fail
This warning is due to a mismatch of library types and can be ignored.
The warning will not appear if -i-dynamic is used.
-early-template-check Switch Even though recent versions of g++ (3.4 and newer) parse template definitions,
they do very little semantic checking of such definitions. Most of the semantic
checking is delayed until an actual instantiation is done. As a result,
g++ accepts certain unusable templates provided they are not actually used
in the program. A new option is available (-early-template-check) to allow
Intel C++ users to check the semantics of function template prototypes before
instantiation.
Example:
class A {};
template <class T> struct B {
B () {}; // error with -early-template-check): no initializer for
// reference member "B<T>::a"
A& a;
};
Note that this switch will work in gcc 3.4 and later compatibility
modes only (i.e. -gcc-version=340 and later).
__m64 in Intel® 64-based Applications The __m64 data type used to be treated as a scalar, at least
to the extent ot being able to statically initialize __m64 data
with an integer literal. But for compatibility with directions
being taken by other compilers supporting MMX(TM), we are dropping
support for that feature. As a result, an initializer for a variable
of __m64 type
must be enclosed in braces. If your application uses a scalar to
initialize such variables, the compiler will give an error message
such as:
error: a value of type "unsigned long long" cannot be used to
initialize an entity of type "const __m64"
KMP_AFFINITY Environment Variable for OpenMP* Applications The KMP_AFFINITY environment variable can be used in an OpenMP*
application to specify how execution threads should be bound to processors
on the system. This setting's effect is to bind each thread, in order of
creation, in a round-robin fashion to a processor core in the system for
the duration of the program. The value of KMP_AFFINITY should
be of the form:
compact,<level>
where <level> is a non-negative integer. For
example:
compact,1
The argument <level> specifies the gap between
successive thread's bound cores in the machine topology map, which
is represented as a binary tree. A level of zero indicates that
threads will be bound to successive threading contexts for processors
which have Intel® Hyper-Threading Technology enabled,
or successive processors if not. The levels increase by one level
from threading contexts, to cores, to packages (processors) in
sequence. This setting is supported for processors supplied by
Intel Corporation only on systems where the required operating
system support for thread binding is present.
new Expression with Parenthesized TypeIn a new expression, a parenthesized type followed immediately
by an array index is not valid C++. For example:
int main()
{
char *p1 = new (char *)[20]; // array index is not allowed after ")"
return 0;
}
In previous versions, the Intel C++ compiler would accept this code and either interpret it as if the array index was part of the type being created:
new ((char*)[20])
or not:
(new (char *))[20]
depending upon the reference compiler and compatibility version target. The compiler has now been changed to always give an error if the compatibility version is gcc 3.4 or later. In gcc 3.3 and earlier compatibility modes the compiler assumes that the array index is part of the type (matching the gcc 3.3 behavior).
The Intel compilers will remove support for Red Hat Linux 7.3 and Red Hat Advanced Server 2.1 in the next major compiler release (version number higher than 9.1.) We recommend that customers plan accordingly.
Applications built to take advantage of Intel® 64 can be built with one of three memory models:
-mcmodel=medium)-mcmodel=large)IP-relative addressing requires only 32 bits, whereas absolute addressing requires 64-bits. This can affect code size and performance (IP-relative addressing is somewhat faster.)
Note: When the medium or large memory models are
specified, you must also specify -i-dynamic to ensure that the correct
dynamic versions of the Intel run-time libraries are used.
When shared objects (.so) are built, Position-Independent Code (PIC)
is specified (-fpic is added by the compiler driver) so
that a single .so can support all three memory models. However, code
that is to be placed in a static library, or linked statically, must
be built with the proper memory model specified. Note that there is
a performance impact to specifying the Medium or Large memory models.
Intel® compilers support three platforms: general combinations of processor and operating system type. This section explains the terms that Intel uses to describe the platforms in its documentation, installation procedures and support site.
The term "native" refers to building an application that will run on the same platform that it was built on, for example, building on IA-32 to run on IA-32. The term "cross-platform" or "cross-compilation" refers to building an application on a platform type different from the one on which it will be run, for example, building on IA-32 to run on Intel Itanium®. Not all combinations of cross-platform development are supported and some combinations may require installation of optional tools and libraries.
The following list describes the supported combinations of compilation host (system on which you build the application) and application target (system on which the application runs).
Note: Development for a target different from the host may require optional library components to be installed from your Linux Distribution.
Note: Intel® Cluster OpenMP* is a separately licensed feature and has different system requirements from that of the compilers. Please refer to the Intel Cluster OpenMP documentation for further details.
compat-libstdc++ providing libstdc++.so.5 compat-libstdc++ providing libstdc++.so.5 compat-libstdc++ providing libstdc++.so.5 The Intel compilers are tested with a number of different Linux distributions, with different versions of gcc. If you are using any of gcc 3.2.3, 3.3.3, 3.3, 2.96, 3.2, 3.4, 4.0, 4.1, you can expect to be successful. However the version of binutils can impact your experience: later ones are generally better and we recommend using at least 2.14. Some Linux distributions may contain header files different from those we have tested, which may cause problems. The version of glibc you use must be consistent with the version of gcc in use.
Notes:
-O3, -ipo and -openmp,
may require substantially larger amounts of RAM.Use of the Eclipse* Integrated Development Environment on Red Hat Enterprise Linux AS 2.1 has the following additional requirements:
Please see the separate Installation Guide for
information on installing the compiler and setting up the compiler
environment. The default installation directories, referred to elsewhere
in this document as <install-dir> and <idb-install-dir>, are:
/opt/intel/cc/9.1.xxx
(for IA-32 and Itanium)
/opt/intel/cce/9.1.xxx (for Intel EM64T)
/opt/intel/idb/9.1.xxx
(for IA-32 and Itanium)
/opt/intel/idbe/9.1.xxx (for Intel EM64T)
Programs compiled with the Intel Compiler version 9.0 using the -openmp switch
may not run after installing the Intel Compiler version 9.1. For such
programs, the loader may exit at run time with an error message about undefined
symbols beginning with the string _intel (for example, _intel_fast_memset).
If this occurs, please recompile the executable using the Intel Compiler
version 9.1 and the loader error message should disappear.
In Update 4 to Red Hat Enterprise Linux 3, inline assembly code was added
to the file /usr/include/c++/3.2.3/ia64_Red Hat-linux/bits/os_defines.h.
This causes the Intel C++ Compiler to fail to compile sources referencing
this header. Note that this problem is not known to exist for any
other version of Linux, including earlier versions of EL3 or beta versions
of the next major release of Red Hat Enterprise Linux.
This issue also affects SGI ProPack 3 Service Pack 5.
A modified header file which corrects this problem is available from http://www.intel.com/software/products/compilers/downloads/os_defines.h.90
A good place to put the modified file is in the substitute headers
directory of your installed compiler. For example,
<install-dir>/substitute_headers/c++/bits/os_defines.h.
The path
must end with bits/os_defines.h. If you place it there the compiler
will find it automatically. You should find an existing installer-created
directory
<install-dir>/substitute_headers and should
create
the sub-directory path c++/bits underneath it.
-cxxlib-gcc Is the default for C++ The STL and gcc* C++ libraries are used by default when linking
C++ applications, rather than those from Dinkumware* used in previous
releases. If you wish to use the Dinkumware libraries, specify
the switch -cxxlib-icc. (-cxxlib-icc is not
available when building for systems with Intel EM64T.) In a future release
of the Intel C++ Compiler, support for using the Dinkumware libraries
will be removed.
-ipo_obj option Is no longer supportedThe -ipo_obj option, which forced generation of direct object code, is no
longer supported. If the option is specified, a warning is given and
the effect is as if -ip was specified instead.
POSIX threaded programs that require a large stack size may not
run correctly on some versions of Linux because of hard-coded stack
size limits in some versions of the Linux POSIX threads libraries.
These limits also apply to OpenMP programs (-openmp) and automatically
generated parallel programs (-parallel ) with the
Intel compilers, because the Intel compilers use the POSIX threads
library to implement OpenMP based and automatically generated parallelism.
Threaded programs that exceed the stack space limit usually experience
segmentation violations or addressing errors.
To avoid these limitations, use a version of glibc built with
the FLOATING_STACKS parameter defined. For some distributions,
this implies using the shared rather than the static version of
the pthreads library. Then use the ulimit -s or limit
stacksize command to set the maximum shell stack size to
an explicit large value, in units of KBytes, (not unlimited),
and also set the KMP_STACKSIZE environment variable
to the needed thread stacksize in bytes. Note, in the bash shell, ulimit
-s can be used to set a large maximum stack size only once.
In the C shell (csh), limit stacksize , with no dash
before the argument, can be used to reset the maximum stacksize
repeatedly.
This solution has been tested on glibc version 2.2.4-13 for IA-32
and glibc 2.2.4-19 for the Itanium Processor Family as found in
the Red Hat 7.2 Linux distribution. For glibc 2.2.4-13 on IA-32,
the shared version of the POSIX threads library must be used, (there
should not be a -static flag in the compiler .cfg
file or on the command line).
It is noted that Linux thread local storage (TLS) is not fully supported
by the default installations of /usr/lib/libpthread.a and /usr/lib/libc.a on
certain versions of Linux (Red Hat Enterprise Linux 4 and earlier are
known examples). When using the Linux TLS mechanism and linking with -static,
the inclusion of -openmp or calls to libpthread may
trigger a runtime failure when trying to access thread local storage.
To fix this problem, install the nptl-devel.rpm package
(included on the Linux installation CD) and compile with -L/usr/lib/nptl.
-g and inlining
There will be an increase in compile time when -g is used together
with inlining. Inlining can happen if the user specifies -ipo, -ip
or compiles a C++/C99 program at option levels -O1 or
above. This is due to the generation of debug information. For many
applications, this combination of compiler options will not increase compile
time or compile-time memory use.
We have identified a problem with glibc version 2.2.4-26 that shipped with the original version of Red Hat AS2.1. This version causes a compiler hang on the command "icc -v or icc -V (with no files to compile). Upgrading to glibc 2.2.4-31.7 fixes the problem. If you have taken any updates to your AS2.1 you will not see this problem. There was also a respin of the original AS2.1 that fixed this problem so only if you have a very early installation of AS2.1 that has never been updated will you see this issue.
We have identified a problem with the gcc binutils linker in some Linux distributions for x86_64 (Intel® 64) systems. This problem manifests itself when running the SPEC* CPU2006* benchmark test 471.omnetpp, resulting in incorrect output, and has been reproduced using varying versions of the Intel C++ compiler as well as with gcc. Not all Linux distributions have the affected linker. The Bugzilla reports for this problem are http://sourceware.org/bugzilla/show_bug.cgi?id=2655 and http://sourceware.org/bugzilla/show_bug.cgi?id=2657
Please contact your Linux distributor to find out if your distribution has the affected linker.
-relax no longer passed to linker on Intel Itanium-based
systems As of version 9.1, the compiler driver no longer passes the -relax switch
to the linker on Itanium-based systems, as this conflicts with the -r option.
The -relax option is not needed as it is the default when using binutils 2.11.90.0.27
or later - 2.14 is recommended. If you must use an older binutils and
wish to specify the -relax option, use -Xlinker
-relax on the compile command which invokes the linker.
ld warning about libunwind.so.7 on SLES 10When applications are built using the Intel compiler on SUSE LINUX Enterprise Server 10, you may see a warning similar to the following:
ld: warning: libunwind.so.7, needed by /usr/lib/gcc/ia64-suse-linux/4.1.0/../../..//libgcc_s.so,
may conflict with libunwind.so.6
A workaround is to add the following line to icc.cfg:
-L /usr/lib
This issue is expected to be resolved in a future release of the Intel compiler.
(-ax*)Compilation using -ax{W|N|B|P|T} results in two copies
of generated code for each function. One for IA-32 generic code and
one for CPU specific code. The symbol for each function then refers
to an Auto CPU Dispatch routine that decides at run-time which one
of the generated code sections to execute. Debugger breakpoints that
are set on these functions by name cause the application to stop in
the dispatch routine. This may cause unexpected behavior when debugging.
This issue may be addressed in a future version of the Intel Debugger
and Compilers.
-fp
Compilation using -fp specifies that the IA-32 EBP register be used
as a frame pointer rather than a general purpose register. Debuggers and
traceback handlers may not be able to properly unwind through a stack that
contains a call to a function that is compiled without -fp in
effect. If you compile with -g or -O0, -fp
is implicitly enabled, but not if you specify a higher optimization level
explicitly (such as -O2). If you intend to use the debugger or
traceback on an application, and are using some level of optimization higher
than -O0, you should also specify -fp to ensure that
the debugger and traceback handler can use frame pointers.
-xP generated codeOlder versions of the GNU Assembler may not be able to process assembly code
generated by compiling with the -[a]xP option. Use binutils
version 2.14.90.0.4.1 or later, or FSFbinutils 2.15 or later if this is an
issue for you.
gdb versions with Intel Compilers
Intel compilers for Linux generate Dwarf2-format debugging information,
including several advanced features in Dwarf2 such as declarations nested
within classes. Older gdb debuggers, such as version 5.3.90-*, are
sometimes unable to correctly handle these Dwarf features. For best success on
source code which uses the full expressiveness of the C++ language, please
consider using gdb version 6.1 or newer.
idb with Extended Debug InformationIf you use the -debug keywords inline_debug_info, semantic_stepping, variable_locations or extended,
you should use the Intel Debugger (idb), as other debuggers may not understand
the extended information and may behave unpredictably. We are working with
the developers of other debuggers towards their adding support for the extended
debug information.
If you did not register your compiler during installation, please do so at the Intel® Software Development Products Registration Center. Registration entitles you to free technical support, product updates and upgrades for the duration of the support term.
For information about how to find Technical Support, Product Updates, Users Forums, FAQs, tips and tricks, and other support information, please visit: http://www.intel.com/software/products/support/clin.
Note: If your distributor provides technical support for this product, please contact them for support rather than Intel.
<package ID>_README (e.g. l_cc_p_9.1.xxx_README),
available for download along with each compiler update, to see which
issues have been resolved in the latest version of the compiler.
Compiler Error Source Reducer (CESR) is a set of utilities which are useful individually or collectively in gathering, reducing, pinpointing, protecting, documenting, and bundling test cases comprised of C/C++ or Fortran source code. It can be helpful if you have a large application for which you want to extract a small test case for submission to Intel® Premier Support. CESR can be downloaded from Intel® Software Development Products Registration Center Product Downloads. Select your product and in the version dropdown, select CESR. CESR is unsupported and should be considered experimental, but we welcome your feedback on it through Intel® Premier Support. CESR requires prior installation of Python* 2.2 or newer.
You can view the Intel compiler and related HTML-based documentation with your Web browser. You should use a Web browser that supports JavaScript (such as Firefox*), so it can which provide full navigation, search, index look-up, and hyperlink capabilities amongst the online help files PDF versions of most manuals are available online at http://developer.intel.com/software/products/compilers/clin/docs/manuals.htm .
The documentation is installed in the <install-dir>/doc directory.
An HTML index document can be found at <install-dir>/doc/Doc_Index.htm . The
Intel® Debugger
Manual is provided in HTML form in the Intel® Debugger
doc directory.
For information on the GNU glibc C language library, documentation can be obtained from the Linux OS vendor or from the GNU web site, www.gnu.org.
icc(1) manpage provides a list of command-line options and
related information for the icc and icpc compiler
commands. To display the icc(1) manpage, type the following
command after you set up your environment by using a source
command to execute the <install-dir>/bin/iccvars.*sh file:
$
man icc
The man command provides single keys or key
combinations that let you scroll through the displayed content,
search for a string, jump to a location, and perform other functions.
For example, type the
z to view the next screen or w to view
the previous screen. To obtain help about the man command,
type the h key; when you are done viewing help, type
the q key to
return to the displayed manpage. To search, type / character
followed by the search string (/string) and press Enter.
After viewing the man command text, type q to return
to the shell command prompt.
The HTML documentation format has been tested to work with web browsers shipped on supported Linux* distributions. PDF versions of the compiler documentation are available at: http://developer.intel.com/software/products/compilers/clin/docs/manuals.htm
Information on Intel software development products is available at http://www.intel.com/software/products.
Some of the related products include:
INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL(R) PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.
Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.
The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.
Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.
Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or by visiting Intel's Web Site.
Celeron, Centrino, Intel, Intel logo, Intel386, Intel486, Intel Core, Itanium, MMX, Pentium, VTune, and Xeon are trademarks of Intel Corporation in the U.S. and other countries.
* Other names and brands may be claimed as the property of others.
Copyright (C) 2007, Intel Corporation. All Rights Reserved.