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 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. 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 Itanium-Based Applications

The Intel C++ compiler for Itanium-based applications contains the following components:

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

Itanium Processor System Requirements

Note, the native compilers for Itanium-based systems run on an Itanium-based system.

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:
  1. Download the compiler package or insert the product CD-ROM.
  2. If you downloaded the compiler, untar the compiler package.
  3. 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.
  4. 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.
  5. After installation, the installed packages are listed. Enter x to exit.
  6. 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)
  7. 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.
  8. 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.

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:
  1. Go to https://premier.intel.com/. You need to have Java* and Javascript* enabled in your web browser to submit an issue.
  2. Type in your Login and Password. Both are case-sensitive.
  3. Click the "Submit" button.
  4. Read the Confidentiality Statement and click the "I Accept" button.
  5. Click on the "Go" button next to the "Product" drop-down list.
  6. Click on the "Submit Issue" link in the left navigation bar.
  7. Choose "Development Environment (tools,SDV,EAP)" from the "Product Type" drop-down list.
  8. If this is a software or license-related issue choose " Intel(R) C++ Compiler, Linux* " from the "Product Name" drop-down list.
  9. 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:

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.