Intel(R) C++ Compiler for Linux*
Release Notes, Version 6.0
Contents
[Overview]
[What's New]
[Package Contents]
[Documentation]
[System Requirements]
[Installation]
[Known Limitations]
[Resolved Issues]
[Technical Support and Feedback]
Overview
This product provides tools for Linux* software developers to create
applications to run on IA-32 and Intel(R) Itanium(TM)-based
systems. It consists of the following:
- The Intel(R) C++ compiler for IA-32 based applications: icc.
- The Intel C++ compiler for Itanium-based applications: ecc.
- The Linux Application Debugger: ldb.
- The Intel Itanium Assembler to produce Itanium-based applications: ias
- The product documentation.
The paper, Optimizing Applications with the Intel(R) C++ and
Fortran Compilers for Windows* and Linux , explains how to use
the Intel compilers to optimize for the Pentium(R) 4 and Itanium
processors and is available at
http://www.intel.com/software/products/compilers/c60l.
Additional information on the Intel Software Development Products is available
at
http://www.intel.com/software/products/.
Compatibility with the GNU Compilers
The compilers have substantial compatibility with the GNU gcc compiler although
this product release is not fully compatible. The paper
Intel Compilers for Linux - Compatibility with the GNU Compilers
provides additional details and is available at
http://www.intel.com/software/products/compilers/c60l.
- Source Compatibility: The Intel compilers support the
ANSI C and C++ standards. Some, but not all, of the GNU C language
extensions are supported.
- Linux Kernel Build:
The 6.0 Intel C++ compiler for Linux have been used internally to build
the linux kernel, including version 2.4.17, using a small number
of workarounds, and demonstrate that the built kernels can boot
and run with good stability on IA-32 and Itanium processor based
servers. There are three categories of workarounds that have been
employed to accomplish this. The first are workarounds
necessitated by gcc extensions used by the kernel not yet
implemented by icc/ecc at the time of this release. The second
apply to ecc where intrinsics have been implemented by the
compiler and used in the kernel in place of inline assembly, a
functionality that the Intel Itanium compiler does not support.
Inline assembly is only supported on IA-32. The third category are
to work around a small number of incorrect/non-standard code
constructs encountered in the kernel source that are flagged as an
error by the Intel compilers.
- C language Binary Compatibility: C language object files are
compatible with object files or libraries compiled with gcc and the GNU
glibc C language library is used in this product.
- C++ language Binary Compatibility:
C++ object files are not currently binary compatible with the GNU
g++ compiler. One cannot link applications with C++ modules
compiled with the Intel C++ compiler and the g++ compiler. The
Intel C++ compilers supports the
C++ ABI (Application
Binary Interface), available from
CodeSourcey*, which
describes agreed upon conventions for binary object code
interfaces between C++ code and the implementation-provided
system. When the C++ ABI is fully implemented by different
compiler vendors, C++ binary object files and libraries will be
largely compatible among the different compilers.
- Compiler Options Compatibility: Most of the common gcc
command line options are supported although not all are supported.
Additional details are available at
http://www.intel.com/software/products/compilers/c60l.
The compilers do not support all of the GNU C language
extensions. Since many standard GNU header files use these extensions,
modified versions of these headers files which do not use these GNU
extensions are redistributed with the compilers in the 'Substitute
Header' packages. These are provided in this distribution for your
convenience, and are not supported or maintained by Intel. The sources
for this build were obtained from http://www.redhat.com/. The package
and documentation may be redistributed and/or modified under the terms
of the GNU General Public License or the GNU Lesser General Public
License as published by the Free Software Foundation. Specific terms
are available online at
http://www.gnu.org or from the Free Software Foundation, Inc., 59
Temple Place, Suite 330, Boston, MA 02111-1307 USA.
Compiler Drivers
The C compiler drivers, icc for IA-32 applications and ecc for Itanium-based
applications, determine the language to use based on the filename extension.
However, when compiling preprocessed files (*.i
), the ecc and
icc
drivers assume the C language, whereas the C++ drivers, ecpc
and icpc,
assume the C++ language. It is recommended to use the C++
compiler drivers for C++ applications.
Related Products and Services
Information on Intel software development products is available at
http://www.intel.com/software/products. The Intel(R) Software
College provides interactive tutorials that run on IA-32 based systems,
documentation, and code samples that teach Intel architecture and
software optimization techniques. It
is not part of this product, but is available at
http://www.intel.com/software/products/college/index.htm.
The VTune(TM) Performance Analyzer allows you to evaluate how your
application is utilizing the CPU and helps you determine if there are
modifications you can make to improve your application's performance.
It is also not part of this product, but is available at
http://www.intel.com/software/products/vtune/.
The Intel(R) Performance Library Suite provides a set of routines
optimized for various Intel processors. It is also not part of this
product, but is available at
http://www.intel.com/software/products/perflib/index.htm.
What's New
The compiler has improved optimizations available with the -O3 compiler option,
and improved gcc compatibility including support for the GNU inline assembly
format. Also, the compiler has improved support for OpenMP* 1.0 for C++, and
auto-parallelization available with the -parallel compiler option.
POSIX threaded programs that require a large stack size may not run correctly
on some versions of Linux because of hard-coded thread stack size limits
in some versions of the Linux POSIX threads libraries. See the section
[Known Limitations] for additional details.
Version 6.0 of the Intel compilers for Linux does not include a cross
compiler for Itanium-based applications. Native compilers, that run on a
computer with an Itanium processor, are available. Direct object generation is
now enabled in the compiler for Itanium-based applications, that is, the
compiler will directly generate object files without automatically generating an
intermediate assembly file and subsequently invoke the assembler. Direct object
generation may be disabled using use the compiler option '-use_asm'.
The 6.0 Intel C++ compiler changed the IA-32 C++ ABI to conform to the
C++ ABI standard, requiring
object and library files to be recompiled if upgrading from the 5.0
versions of the Intel Compilers. The C++ ABI
, available from CodeSourcery
, describes agreed upon conventions for
binary object code interfaces between C++ code and the
implementation-provided system. The Itanium compiler had minor
changes to the C++ ABI, and also requires object and library files to
be recompiled if upgrading from the 5.0 versions of the Intel
Compilers. In addition, other files the compiler generates should be re-created,
such as PGO files (*.dyn, pgopti.dpi), if upgrading from the 5.0 version.
It is no longer necessary to run a script to create several new environment
variables at the start of each session. The only required variables are PATH and
LD_LIBRARY_PATH, which may be updated by the .login file. Refer the section
Compiler Environment and configuration scripts
for details.
The Intel Compiler's help content is available from the man
command
after setting up the compiler environment, see the
Compiler Environment and configuration scripts
section. Then, run man icc
or
man ecc.
Package Contents
Intel C++ Compiler for IA-32 Based Applications
The Intel C++ compiler for IA-32 based applications contains the following
components:
- Intel C++ Compiler for Linux for IA-32 applications: icc and icpc for C
and C++ source files, respectively.
- The C++ name demangler utility: iccfilt.
- Linux Application Debugger for IA-32 based applications: ldb
- Substitute headers for use with the Intel C++ compiler.
- The product documentation.
Intel C++ Compiler for Itanium-Based Applications
The Intel C++ compiler for Itanium-based applications contains the following
components:
- Native C++ compiler for Itanium-based applications: ecc and ecpc for C and
C++ source files, respectively. The native compiler runs on a computer with
an Itanium processor.
- The C++ name demangler utility: eccfilt.
- Linux Application Debugger for Itanium-based applications: ldb
- Itanium Assembler to produce Itanium-based applications: ias.
- Substitute headers for use with the Intel C++ compiler.
- The product documentation.
Documentation
The compiler and assembler documentation is presented in HTML format with full
navigation, search, and hypertext capabilities and is viewable with your web
browser. The documents also have PDF versions for easier printing via acroread*,
the Acrobat* Reader for Linux.
The documentation is installed in the <install-dir>/compiler60/docs
directory. Also, an HTML index document can be found at <install-dir>/compiler60/docs/ccompindex.htm
.
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.
Viewing HTML Documentation
To view the HTML documentation with the Netscape* browser, the following options
need to be enabled:
Edit-->Preferences-->Advanced-->enable Java
Edit-->Preferences-->Advanced-->enable JavaScript
Edit-->Preferences-->Advanced-->enable stylesheets
Viewing PDF Documentation Files
You can read the PDF files using the xpdf
utility or install acroread,
the Acrobat* Reader for Linux. It is recommended to view the PDF
documentation with Acrobat running within Netscape as this provides additional
navigation features. To enable Netscape to start acroread, acroread needs to be
installed in a directory searched by your PATH environment variable and you need
to edit the browser's preferences. NOTE: If acroread isn't configured
correctly, you can overwrite the PDF files, requiring you to reinstall them.
If improperly configured, the acroread browser may prompt you to Save-As file,
which if you click OK can overwrite the PDF documentation files. Perform these
steps needed to update your preferences for acroread:
Edit --> Preferences --> Navigator --> Applications --> new
Description: Portable Document Format
MIMEType: application/pdf
Suffixes: pdf
Application: acroread %s
Another method to configure acroread is to add the following entry in the file .mailcap
in your home directory:
application/pdf; acroread %s
Depending on your version of the Netscape browser, you might need to disable
(turn OFF) the "Automatically load images" option or the browser will
freeze when you open the HTML documentation files, this means that you will then
need to click on the images in the documentation if you want to see them while
paging through the documentation with the browser. Turn OFF this option by
clicking on: Edit-->Preferences-->Advanced-->Automatically load images
and other data types.
System Requirements
IA-32 Processor System Requirements
- A computer based on a Pentium processor or subsequent IA-32 based
processor. (Pentium 4 processor recommended)
- 128 MB of RAM (256 MB recommended).
- 100 MB of disk space
- Linux system with glibc 2.2.2 or 2.2.4 and kernel 2.4. The compiler has
been validated with Red Hat* Linux versions 7.1 and 7.2 .
Itanium Processor System Requirements
Note, the native compilers for Itanium-based systems run on an Itanium-based
system.
- A computer with an Itanium processor.
- 256 MB of RAM
- 100 MB of disk space
- Linux system with glibc 2.2.3 or 2.2.4 and kernel 2.4. The compiler has
been validated with Red Hat Linux versions 7.1 and 7.2 for Itanium-based
systems.
Installation Notes
The Intel compilers use the GlobeTrotter* FLEXlm* electronic licensing technology.
A valid license is needed to use the compilers. To install the compilers:
- Download the compiler package or insert the product CD-ROM.
- If you downloaded the compiler, untar the compiler package.
- Become the root user, needed to run rpm, and execute the install
script,
install
.
It's possible to install without root access
by unpacking the RPM files with rpm2cpio and editing the
compiler environment and configuration files, described below,
but this installation method is not supported.
- Select the compiler or debugger to install. The default RPM
options,
-U --replacefiles,
are recommended to update existing
files. The recommended installation directory is
/opt/intel
.
- After installation, the installed packages are listed. Enter
x
to exit.
- Execute the appropriate script to setup the compiler environment variables:
source <install-dir>/compiler60/ia32/bin/iccvars.sh(.csh)
source <install-dir>/compiler60/ia64/bin/eccvars.sh(.csh)
- Install the FLEXlm license: For electronic download, the license is
sent via email with install instructions. For the CD-ROM, read the
readme.txt file on the CD-ROM.
- Run the compiler.
To receive technical support and product updates for the tools
provided in this product you need to register
See Technical Support and Feedback
for registration instructions.
Compiler Environment and Configuration Scripts
The compilers use the environment variables and the install script
creates script files to correctly set the compiler environment. The
names and locations are:
<install-dir>/compiler60/ia32/bin/iccvars.sh(.csh)
for IA-32 applications, and
<install-dir>/compiler60/ia64/bin/eccvars.sh(.csh)
for Itanium processor-based applications.
The installation creates configuration files,
<install-dir>/compiler60/ia32/bin/icc.cfg
and
<install-dir>/compiler60/ia64/bin/ecc.cfg
.
They contain common settings and can be used to add additional default
options. Note, if you install a compiler update package, you need to
rename the config files to avoid being overwritten.
Installation Warnings
Installation Warning for RPM 4.0.2
RPM 4.0.2 cannot install to a non-default directory.
This has been resolved in RPM 4.0.3.
Installation of the Intel C++ and Fortran compilers
It is not recommended to install the Intel C++ compiler for Linux and the Intel
Fortran compiler for Linux in different directories. The two compiler packages
share common files and the default RPM options in the install
script prevent the compilers from working correctly when installed in different
directories. However, the compilers should still be untar-ed into separate
directories if you downloaded the electronic version.
When installing updates to either C++ or Fortran, we recommend that
the other one be updated. Otherwise there may be a library mismatch,
because there are certain libraries that are common between the Intel
C++ Compilers and the Intel Fortan Compilers, causing unexpected
behavior of the compiler(s) or the compiled code.
Uninstalling the compilers
To uninstall the compilers, you need to become the root user to run RPM. An uninstall
script is provided to uninstall the compiler packages.
- To uninstall the Intel compilers for IA-32 applications, run the script
<install-dir>/compiler60/ia32/bin/uninstall
- To uninstall the Intel compilers for Itanium-based applications, run the script
<install-dir>/compiler60/ia64/bin/uninstall
Known Limitations
POSIX threaded programs that require a large stack size (e.g. 2 MB for RedHat 6.2
on IA-32, 8 MB for RedHat 7.1 on Itanium Processor Family) 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, please use a version of glibc built with the
"FLOATING_STACKS" parameter defined, typically version 2.2.4 or later
for both IA-32 and Itanium Processor Family. Then use the ulimit -s ....
command to set the maximum shell stack size to an explicit large value (units of
KBytes) and also set the KMP_STACKSIZE environment variable to the needed thread
stacksize in bytes. A shell stacksize limit of "unlimited"
does not work - it causes a fixed hard limit to be imposed. Note : In the
bash shell, ulimit -s can be used to set a large maximum stack size only once.
In the C shell, limit -stacksize 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 Itanium Processor Family as found in the RedHat 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).
The Linux system libraries and the compiler libraries are not built
with the -align option. Therefore, if you compile with the -align
option and make a call to compiler distributed or system library, and
have long long, double, or long double in your interface, you will get
the wrong answer due to the difference in alignment. Any code built
with -align cannot make calls to libraries that use these types in
their interfaces unless they are built with -align (in which case they
will not work without -align).
Please click on the appropriate link below to see additional notes and known
limitations in the latest version of the compiler.
Resolved Customer Support Issues
Please click on the appropriate link below to see which issues have been
resolved in the latest version of the compiler.
Technical Support and Feedback
Your feedback is very important to us. To receive technical support and
product updates for the tools provided in this product
you need to register at
http://support.intel.com/support/performancetools/c/v6/linux/
and click on Register For Support. Compiler support information, including top technical
issues (FAQ's), product documentation, and product errata is also available
at this URL.
Submitting Issues
To submit an issue via the Intel Premier Support website, perform the following
steps:
- Go to https://premier.intel.com/.
You need to have Java* and Javascript* enabled in your web browser to submit
an issue.
- Type in your Login and Password. Both are case-sensitive.
- Click the "Submit" button.
- Read the Confidentiality Statement and click the "I Accept"
button.
- Click on the "Go" button next to the "Product"
drop-down list.
- Click on the "Submit Issue" link in the left navigation bar.
- Choose "Development Environment (tools,SDV,EAP)" from the
"Product Type" drop-down list.
- If this is a software or license-related issue choose " Intel(R)
C++ Compiler, Linux* " from the "Product Name" drop-down
list.
- Enter your question and complete the fields in the windows that follow to
successfully submit the issue.
Please follow these guidelines when submitting your problem report or product
suggestion:
- Describe your difficulty or suggestion. For problem reports please be as
specific as possible, so we may reproduce the problem. For compiler problem
reports, please include the compiler options and a small test case.
- Describe your system configuration information. Be sure to include
specific information that may be applicable to your setup: operating system,
versions of glibc and kernel, name and version number of installed
applications, and anything else that may be relevant to helping us address
your issue.
- Include the package ID for the component your support issue concerns. A
package ID utility is available,
icid
. When icid
is executed, the package ID is written to standard output.
See the Installation
section for details on setting up the compiler environment.
- If you have an error installing the compiler package, create a Customer
support issue on the Intel Premier Support website and select
install
error
for the issue type. See Technical
Support and Feedback for instructions on how to register for support. If
you were not able to install the compiler or cannot run icid
to
determine the package ID, enter the filename you downloaded as the package
ID if you downloaded the compiler and explain in the issue that you were not
able to run icid.
A technical support engineer will respond within one (1) Intel business day.
Copyright and Legal Information
Intel, Pentium and Itanium are trademarks or registered trademarks of Intel
Corporation or its subsidiaries in the United States and other countries.
* Other names and brands may be claimed as the property of others.
Copyright (C) 2000, 2001, 2002 Intel Corporation. All Rights Reserved.