Intel(R) C++ Compiler for Linux*
Release Notes, Version 6.0

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

Intel C++ Compiler to produce IA-32 applications. Note, this file is available only if the compiler for IA-32 applications is installed.
Intel C++ Compiler to produce Itanium-based applications. Note, this file is available only if the compiler for Itanium-based applications is installed.
The Linux Application Debugger: ldb. Note, this file is available only if ldb is installed.

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.

Intel C++ Compiler to produce IA-32 applications. Note, this file is available only if the compiler for IA-32 applications is installed.
Intel C++ Compiler to produce Itanium-based applications. Note, this file is available only if the compiler for Itanium-based applications is installed.
The Linux Application Debugger: ldb. . Note, this file is available only if ldb is installed.

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.

Intel(R) C++ Compiler for Linux* Release Notes, Version 6.0

Contents