Intel® Fortran Compiler 8.1 for Linux*
Release Notes

For Intel IA-32 and Itanium® Processors


System Requirements
Known Limitations
Technical Support
Additional Information
Copyright and Legal Information


This product provides tools for Linux* software developers to create applications that run at top speeds on all Intel® IA-32 processors and the Intel Itanium® processors. Optimizations include support for Streaming SIMD Extensions 2 (SSE2) in the Intel Pentium® 4 and Pentium M processors, Streaming SIMD Extensions 3 (SSE3) in the Intel Pentium 4 processors with SSE3 support, and software pipelining in the Intel Itanium® 2 processor. Inter-procedural optimization (IPO) and profile-guided optimization (PGO) can provide greater application performance. Intel Compilers support multi-threaded code development through autoparallelism and OpenMP* support.

The paper, Optimizing Applications with the Intel® C++ and Fortran Compilers for Windows* and Linux, explains how to use the Intel compilers to optimize for the Pentium 4 and Itanium processors and is available at . Additional information on the Intel Software Development Products is available at .

Product Contents

Intel® Fortran Compiler for IA-32 Based Applications

The Intel® Fortran compiler for IA-32 based applications contains the following components:

Intel® Fortran Compiler for Itanium-Based Applications

The Intel® Fortran compiler for Itanium-based applications contains the following components:


You must recompile all Fortran sources that were compiled with compilers earlier than version 8.0, including those that create .mod files. Third-party libraries built with versions earlier than 8.0 will also need to be rebuilt - if you are using third-party libraries that do not support Intel Fortran 8.0, please let us know which ones through Intel® Premier Support at Fortran sources built with Intel Fortran 8.0 do not need to be recompiled for use with version 8.1.

Changes in Version 8.1

Version 8.1 is a minor update to Intel Fortran. The primary focus of this release is improvement in compiler stability and run-time performance.

New Predefined Preprocessor Symbol

The following new predefined preprocessor symbol is now available:

-zero Now Implemented

The -zero option is now implemented - this causes the compiler to initialize the value of local (not in COMMON nor a MODULE), static (not allocatable nor automatic), scalar (not array nor derived type) variables to zero when the program is run. It is the same is if the variables had been named in a DATA statement with an initial value of zero

Duplicate Unnamed BLOCK DATA Subprograms No Longer Permitted

The compiler now gives an error for more than one unnamed BLOCK DATA subprogram in a compilation, in accordance with the Fortran standard.

Change in Meaning of -fast

As of the 8.1 release, specifying -fast implies the following options: -O3 -ipo -static -xP

New -ipoN Option to Create Multiple Objects

In previous versions, when -ipo was specified to perform multifile interprocedural optimization, one object file was generated as input to the linker; this is still the default for version 8.1. New in version 8.1 is the ability to request that the compiler create multiple object files for input to the linker; this can, in some cases, reduce link time for large applications. To specify the maximum number of object files to be produced, use the -ipoN form of the option where N is the maximum number of object files to be created. For example, -ipo4 specifies a maximum of 4 object files. The compiler may choose to create fewer files than the maximum depending on the application size. If -ipo0 is specified, the compiler will choose an appropriate number of object files based on the total application size.

KMP_SCHEDULE Environment Variable for OpenMP Scheduling Control

A new environment variable, KMP_SCHEDULE, can be used to fine tune the load balancing of parallel loops that are statically scheduled under OpenMP with no chunk size specification. The default value is KMP_SCHEDULE="static,greedy". This results in (#iterations/#threads) iterations, rounded to the next higher integer, being allocated to most threads, but the final thread(s) may be allocated much fewer, or even zero, iterations. This corresponds to previous compiler behavior. The alternative, KMP_SCHEDULE="static,balanced", results in (#iterations/#threads) iterations, rounded to the next lower integer, being allocated to most threads, with at most one additional iteration being allocated to some threads. Although the largest number of iterations assigned to any thread remains the same, this results in a more even sharing of iterations between threads, which may sometimes lead to a performance improvement.

For example, consider a loop of 9 iterations running on 4 threads:


Number of iterations


Thread 0

Thread 1

Thread 2

Thread 3











Additional New Options

For information on these options, please see the New Options section of the on-disk Compiler Options Quick Reference Guide.

Changes in Version 8.0

This is a new generation of Intel Fortran that combines the best technology from both Intel Fortran and Compaq* Visual Fortran. The "front-end" of the compiler, which provides Fortran language features and Fortran-specific optimizations, is now derived from that of Compaq Visual Fortran. The Fortran run-time library (I/O and non-math intrinsics) also derives from Compaq Visual Fortran. The "back-end" is from the latest generation of Intel's high-performance code generation and optimization technology to achieve the best performance on Intel processors.

Optimization support for Intel Pentium 4 Processors with SSE3 Instruction Set

A new generation of Intel Pentium 4 processors supports the Streaming SIMD Extensions 3 (SSE3) instruction set, which can improve performance of vectorized loops containing complex data types, float-to-integer conversions, and horizontal adds.

Version 8.0 adds the ability to optimize for Intel processors that support SSE3. To do so, specify the -xP or -axP options. For further details, please consult the sections on optimizations in the Intel Fortran Compiler User's Guide.

New IA-32 Optimization Options

This release includes two new code generation options. -xB and /QaxB direct the compiler to generate code for best performance on the Intel Pentium M processor. The new -xN and -axN options enable additional optimizations for all Intel Pentium 4 processors. Intel recommends the use of -xN and -axN for best performance with Pentium 4 processors, and suggests trying -xB or -axB to see if it helps your application on the Pentium M processor. For more information, please refer to the sections on optimization in the Intel Fortran Compiler User's Guide

Obsolete and Obsolescent Optimization Options

The optimization options -[a]xi (optimize for Pentium Pro and Pentium II) and -[a]xM (optimize for MMX instruction set) are no longer supported by the Intel Fortran compiler. If these options are present on the compile command line, an informational message is displayed and the options are ignored. If you use -[a]xi or -[a]xM, you should discontinue their use. The default is to generate generic code that will run on Pentium processor as well as newer IA-32 processors.

The-[a]xW (lower optimization level for Pentium 4) may be removed in a future compiler version. If you use -[a]xW, use -[a]xN as a replacement when generating code for Intel Pentium 4 processors.

For more information, please refer to the sections on optimization in the Intel Fortran Compiler User's Guide.

Changes to Default Linking Behavior

The compiler configuration files, <install-dir>/bin/ifort.cfg and <install-dir>/bin/icpc.cfg, have been modified to remove the RPATH command to the linker. This was used in previous releases to set the location of the Intel shared libraries in the executable. The disadvantage of putting the RPATH directive in the configuration file is that just typing the compiler, ifort, would result in a cryptic error:

/usr/lib/crt1.o: In function `_start': /usr/lib/crt1.o(.text+0x18): undefined reference to `main'

Which would confuse users, thinking that there is a problem with their compiler or installation. The current release removes the RPATH directive, and typing ifort gives a more informative error:

ifort: Command line error: no files specified; for help type "ifort -help"

However, as executables no longer contain the location of the Intel shared libraries, you need to specify the location of the shared libraries. Any of the following techniques can be used to do this:

  1. Modify the LD_LIBRARY_PATH environment variable to contain the location of the Intel shared libraries. For sh type shells, enter: export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<install-dir>/lib.
  2. Use the ldconfig system utility. Note: this requires root user privileges to run.
  3. Modify the compiler configuration files, <install-dir>/bin/ifort.cfg

If you see an error message such as this:

error while loading shared libraries: cannot open shared object file: No such file or directory

you need to apply one of the three methods listed above to set the location of the Intel shared libraries.

Intel® Compilers code-coverage tool

The Intel Compilers code-coverage tool leverages the Intel Compilers profile-guided optimization technology to present developers a complete picture of the coverage of their application code on a particular workload. To find the application's code coverage the tool combines static profile information generated by the compiler with dynamic profile information generated by running the user's instrumented binaries on the workload. The coverage tool uses this information together with the application sources to create HTML pages with color annotations that highlight the coverage of the code. Navigation is through frames that make it particularly easy to sort the application's files and functions and see the least-covered modules and functions. Developers can then use their favorite browser to display the coverage of their code.

The Intel Compilers code coverage tool can be used in a number of ways to improve development efficiency, reduce defects, and improve application performance. When applied to the profile of the application on its test space, the tool can be used to measure the overall quality of testing based on the coverage information. Similarly, when applied to the profile of a performance workload, the code-coverage information indicates how well the workload exercises the application's critical code. High coverage of performance-critical modules is essential to taking full advantage of the profile-guided optimizations that Intel Compilers offer. The tool also provides an option, useful for both coverage and performance tuning, through which the users can display the dynamic execution count of each basic block of the application. Lastly, the coverage tool provides the ability to compare the profile of two different runs of the application. This feature can be used to find the portion of the application's code that is not covered by the application's tests but is exercised when the application is used outside the test space, such as by a customer.

The Intel Compilers code-coverage tool is supported on Intel Architecture IA-32 and the Itanium Processor Family on both Windows and Linux and seamlessly supports C, C++, and Fortran.

Intel® Compilers test-prioritization tool

The Intel Compilers test-prioritization tool leverages the Intel Compilers profile-guided optimizations technology to select and prioritize application tests based on prior execution profiles of the application. Using this tool, users can select and prioritize the tests that are more relevant for any subset of the application's code. When certain modules of an application are changed, the Intel Compilers test-prioritization tool suggests the tests that are most probably affected by the given change set. The tool mines the profile data from previous runs of the application, discovers the dependency between the application's components and its tests, and uses this information to guide the process of testing. The tool can be used for devising an effective hierarchical testing based on the application's code coverage. For instance, the tool may be used to find the smallest subset of the application tests that achieve exactly the same code coverage as the entire set of tests. The tool can also be used to dramatically reduce the turn-around time of testing. Instead of spending a large amount of time and finding a possibly-large number of failures, the tool may enable the users to quickly find a small number of tests that expose the defects associated with the regressions caused by a change set. The tool offers the potential of significant time saving in testing and development of large-scale applications where testing is major bottleneck. The tool can be used to minimize the number of tests that are required to achieve a given overall coverage for any subset of the application. Moreover, when the execution times of the tests are available, the tool may also be used to select and prioritize the tests to achieve certain level of code coverage in a minimum amount of time.

The Intel Compilers test-prioritization tool is supported on Intel Architecture IA-32 and the Itanium Processor Family on both Windows and Linux and seamlessly supports C, C++, and Fortran.

Please refer to the following link for additional details:

Intel Debugger Graphical User Interface

The Intel Debugger idb now offers an optional graphical user interface. For more information, including known problems and restrictions, please see the Intel Debugger Release Notes.

Versioned Intermediate files (.il) during interprocedural optimization (IPO)

Each .il file generated by IPO will have a version number. The compiler will only accept .il files with matching versions. The version numbers will be automatically generated and updated as part of the build process.

The following additional features are new in version 8.0

The following behavior changes are new in version 8.0

System Requirements

IA-32 Processor System Requirements

Itanium Processor System Requirements

We recommend using binutils 2.14 or later, especially if using shared libraries as there are a known issues with binutils 2.11.

Note: Compiling very large source files (several thousands of lines) using advanced optimizations such as -O3, -ipo and -openmp, may require substantially larger amounts of RAM.


If you have Intel Fortran Compiler 8.0 or 8.1 installed, you must uninstall it prior to installing Intel Fortran Compiler 8.1. Please refer to the Uninstalling the Compiler and Debugger below for details on uninstallation.

The installation script of the Intel Fortran Compiler uses the system utility RPM to install files. But RPM 4.0.2 and RPM 4.1 have a limitation, please see Known Limitations below for details.

Installing the license

The Intel Fortran Compiler uses Macrovision Corporation's FLEXlm* electronic licensing technology. License management is transparent. The installation program of the Intel Fortran Compiler 8.1 checks for a valid license before installing any component of the product. Also, the license must remain in place on the system in order to use the Intel Fortran Compiler 8.1 to compile and build programs.

The FLEXlm license daemon for Intel software, used for floating and node-locked licenses only, is available for many popular platforms. The daemon may be installed on any supported platform accessible on your local network. The compiler CD contains license daemons for several Linux distributions. If you do not have the CD, or need a license daemon for an additional platform, you can find all available license daemons in the Downloads section of your Intel® Premier Support account.

Note: Your existing license for Intel Fortran Compiler for Linux will work with the 8.1 compiler provided your support services have not expired.

Here is how to setup the license file before installation.

For details about the support service license, please see .

Installing the Intel Fortran Compiler

Perform the following steps to install the compiler.

  1. Download the compiler package.
  2. Unpack the compiler package in a directory to which you have write access.
    > tar -xvf l_fc_p[c]
    > tar -zxvf l_fc_p[c]
  3. Run the installation script
    Become the root user, needed to run the rpm command, and execute the install script in the directory where the tar file was extracted.
    > source ./
    If you do not have access to the root account, it is possible to install the compiler without root access by manually unpacking the RPM files with rpm2cpio and editing the (.csh) file to include the directory where the compiler is installed. The install script automates this procedure.
  4. Enter the directory for the license file
    It is the directory where you saved the license file (*.lic) above. The installation program will validate the license before installing any Intel Fortran Compiler for Linux component.
  5. After the license checking, the installation program will display the Intel software products that are already installed, and the following menu items for you to install:
  6. Select a package to install.
    The suggested order is to Before installation begins, the End-User License Agreement (EULA) is displayed. Type "accept" to accept this license agreement.
    All necessary packages needed to use the product will also be installed. If an RPM package has already been installed, the install script will report this and ask you to verify that you want to overwrite the existing installation. It will then continue to the next RPM package that needs to be installed to use the product. The default RPM options -U --replacefiles --force are recommended to force the update of existing files.
    The default installation directory is /opt/intel_fc_80/ for the Intel Fortran Compiler, and /opt/intel_idb_80/ for the Intel Debugger.
  7. After installation, the Intel packages installed will be redisplayed, followed by a redisplay of the install menu. Enter 'x' to exit the install script.

Environment Variables

The Intel Fortran compiler now supports the following environment variables, if defined:

Setting Up The Compiler Environment

The installation script ( creates compiler environment script files ( that set some environment variables such as PATH, LD_LIBRARY_PATH and MANPATH. It is strongly recommended that you add those script files into your login script (.login file). So once the variables are set in the ".login" file there is no need to run the script files for each session.

Source the script to setup the compiler environment:

The installation program also creates compiler configuration files named <install-dir>/bin/ifort.cfg that contain common settings for all compilations. You can edit these files to add additional default options. Note, if you install a compiler update package, you need to rename the configuration file to another filename if you have modified it so that the installation doesn't overwrite your modified file.

If you want to use both Intel Fortran and Intel C++, you must also run the Intel C++ environment script from its installed location.

Please register for support after you install this product. See Technical Support for registration instructions.

Uninstalling the Compiler and Debugger

Please follow the steps below to uninstall the Intel Compiler and Debugger.
  1. become the root user
  2. to uninstall the compiler:
    > source <compiler-install-dir>/bin/
    or if you've installed the compiler to the default directory, use
    > source /opt/intel_fc_80/bin/
  3. to uninstall the debugger:
    > source <debugger-install-dir>/bin/
    or if you've installed the debugger to the default directory, use
    > source /opt/intel_idb_80/bin/

Known Limitations

Installation Warning for RPM 4.0.2 and RPM 4.1

RPM 4.0.2 cannot install to a non-default directory. This has been resolved in RPM 4.0.3. RPM 4.1 cannot install to a non-default directory. This has been resolved in RPM 4.11 to 4.2.

Note about installing the Intel Debugger

When installing the Intel Debugger version 8.1 for IA-32 or Itanium-based applications from the Intel Fortran Compiler 8.1 package, if an earlier version of the Intel Debugger is already installed on the system, it will be upgraded to the Intel Debugger version 8.1.

Segmentation Violation with static link to libpthreads

Applications built with libpthreads.a statically linked, (libpthreads.a is used by default when -static is used), may fail with a segmentation violation on some versions of Linux when the applications use more than 2MB of stack space. This is a known limitation of Linuxthreads. If you encounter this problem, link libpthreads dynamically. As an alternative, on Red Hat Linux 9 and Red Hat Enterprise Linux 3.0, you can install the nptl-devel package and pass "-I/usr/include/nptl -L/usr/lib/nptl" on the ifort command line. This will create a statically-linked binary which will run under nptl only, but which does not have the stack size limitation.

Dynamic Shared Objects on Itanium Systems

On Itanium systems, when the -shared switch is used to specify that a Dynamic Shared Object (.so) is to be created, ld may issue diagnostic messages referring to "@gprel relocation against dynamic symbol". To correct this problem, add the -i_dynamic and -nofor_main switches to the command line used to build the .so. A future version of Intel Fortran may set these options automatically when -shared is specified.

OpenMP Limitations

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

In addition, if a common block is declared as THREADPRIVATE with an OpenMP directive, the common block must have the same length in all the source files in which it is declared.

Itanium Floating Point Software Assistance Handler 1.12 Error on Red Hat Linux 7.2

On Itanium-based systems, the Floating Point Software Assistance handler (FPSWA), part of the system BIOS, performs software completion of floating point operations that generate exceptional values such as NaNs and Infinities. Version 1.12 of the FPSWA has an error which can be revealed on Red Hat Linux 7.2 systems as an unexpected segmentation violation fault when an application runs. Intel is not aware that this issue affects other distributions or versions of Linux on Itanium systems.

To correct this problem, upgrade the system BIOS to one that includes FPSWA version 1.18 or later. Please contact your system manufacturer for BIOS update information.

gprel relocation Error Messages on Itanium-based Linux Systems

On Itanium-based systems running Linux, when the -shared switch is used to create a Dynamic Shared Object (.so), there may be some "relocation against dynamic symbol" messages generated during the ld phase, similar to:

/usr/bin/ld: for_init.o: @gprel relocation against dynamic symbol for__segv_default_msg
/usr/bin/ld: for_init.o: @gprel relocation against dynamic symbol for__l_fpe_mask
/usr/bin/ld: for_init.o: @gprel relocation against dynamic symbol for__l_undcnt

To fix this problem, add the switches -i_dynamic and -nofor_main to the command line. As of version 8.1, specifying -shared will automatically set -i_dynamic and -nofor_main.

Issues relating to Multiple Object File Interprocedural Optimization

The following issues are expected to be resolved in a future update:

-ipo1 doesn't guarantee only one object file

Specifying an explicit number of files object files to be generated with -ipoN doesn't turn off the compiler heuristic for dividing and object file into two object files when it gets too big.

Because of this, you cannot currently turn off IPO multiple objects by explicitly specifying one object file using -ipo1.

-qipo_separate is not recognised by xild

The -qipo_separate option is not recognized by xild. This causes IPO compilations using this option to fail.

Explicit naming of .o and .s files ignored with -ipo multiple objects

When using -ipo_c or -ipo_S (explicit .o or .s files, respectively), options to explcitly name these files are ignored by the compiler for when generating multiple objects.

s files generated by -ipo_S fail to assemble with multiple object IPO

There are two classes of errors:

Limited Debug Information with Automatic CPU Dispatching (-ax*)

Compilation using -ax{W|N|B|P} 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.

Cannot Debug or View Traceback for IA-32 Programs Built Without -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.

GNU* Assembler May Not Recognize -xP Generated Code

Older versions of the GNU Assembler may not be able to process assembly code generated by compiling with the -[a]xP option. Use binutils version or later, or FSFbinutils 2.15 or later if this is an issue for you.

Stack Usage Increases Compared to Version 7.x

Version 8.x of the Intel Fortran compiler can generate code that uses more stack space than did earlier versions. You may find that it is necessary to increase the stacksize limit using the appropriate limit, unlimit or ulimit shell command.


The !DEC$ ATTRIBUTES ALIGN directive is currently ignored for variables with the ALLOCATABLE or POINTER attributes.

Missing Features

The following features of the Intel Fortran Compiler 7.1 are not currently available in Intel Fortran 8.1:

Other issues

Please click on the appropriate link below to see additional notes and known limitations in the latest version of the compiler.

Technical Support

Your feedback is very important to us. To receive technical support for the tools provided in this product and technical information including FAQ's and product updates, you need to be registered for an Intel® Premier Support account on our secure web site, Please register at and click on "Registration Center".

For information about the Intel Fortran Compiler's Users Forums, FAQ's, tips and tricks, and other support information, please visit: For general support information please visit

Submitting Issues

Steps to submit an issue:

  1. Go to
  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® Fortran Compiler for 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.

Guidelines for problem report or product suggestion:

  1. Describe your difficulty or suggestion.
    For problem reports please be as specific as possible, so that we may reproduce the problem. For compiler problem reports, please include the compiler options and a small test case if possible.
  2. Describe your system configuration information.
    Get the version of glibc and kernel with following commands:
        > uname -a
        > rpm -qa | grep glibc
    If you don't have rpm installed, use the command below:
        > ls /lib/libc*
    And copy the information into the corresponding Premier Support fields.

    Get the Intel Fortran Compiler's Package ID with the following commands:
        > ifort -V
    And copy the "Package ID" (e.g. l_fc_p[c] from the output into the corresponding Premier Support field. Please include any other specific information that may be relevant to helping us to reproduce and address your concern.

  3. If you were not able to install the compiler or cannot get the Package ID, enter the filename you downloaded as the package ID.

Resolved Issues

Please review <package ID>_README (e.g. l_fc_p[c]_8.1.xxx_README), available for download from Intel® Premier Support,, to see which issues have been resolved in the latest version of the compiler.


You can view the Intel compiler and related HTML-based documentation with your Web browser, which provide full navigation, index look-up, search, and hyperlink capabilities. The documents also have PDF versions for easier printing via Adobe Acrobat Reader*.

The documentation is installed in the <install-dir>/doc (default /opt/intel_fc_80/doc) directory. An HTML index document can be found at <install-dir>/doc/fcompindex.htm (default /opt/intel_fc_80/doc/fcompindex.htm). A training tutorial Enhancing Performance with Intel Compilers is also available from links in the documentation index. The Intel® Debugger Manual is provided in HTML form in the Intel® Debugger doc directory (default /opt/intel_idb_80/doc).

The document Intel® Fortran Compiler User's Guide is provided as HTML-based documentation you can view in your Web browser. It is now organized into separate parts:

The following documents are provided in Adobe Acrobat* form (PDF files):

The Enhancing Performance with Intel Compilers provides an interactive HTML-based tutorial on using compiler options that help you optimize your application for IA-32 and Itanium-based systems. Documents that describe the Itanium Assembler are also provided.

Viewing Manpages

The ifort(1) manpage provides a list of command-line options and related information for the ifort compiler command. To display the ifort(1) manpage, type the following command after you set up your environment by using a source command to execute the <install-dir>/bin/ifortvars.*sh file:

$ man ifort

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.

Viewing HTML Documentation

To view the compiler User's Guide HTML-based documentation, you no longer need to use a Java*-enabled or Javascript-enabled Web browser. The documentation format has been tested to work with Web browsers shipped on standard Red Hat* distributions. To allow the HTML-based User's Guide help to be browser-neutral and not require java support, the Search capability has been removed. If you need to search the User's Guide, please use the supplied User's Guide PDF files (same content as HTML-based User's Guide).

Viewing PDF Documentation Files

You can read the PDF files using the xpdf utility (provides search capability), or use the gv or ghostview command. On some Linux distributions, using mozilla will display PDF files using a PDF helper.

Additional Information

Related Products and Services

Information on Intel software development products is available at

Some of the related products include:

Copyright and Legal Information

Information in this document is provided in connection with Intel 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. Intel products are not intended for use in medical, life saving, or life sustaining applications.

This Release Note, as well as the software described in it, is furnished under license and may only be used or copied in accordance with the terms of the license. The information in this manual is furnished for informational use only, is subject to change without notice, and should not be construed as a commitment by Intel Corporation. Intel Corporation assumes no responsibility or liability for any errors or inaccuracies that may appear in this document or any software that may be provided in association with this document.

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 software described in this Release Note may contain software defects which may cause the product to deviate from published specifications. Current characterized software defects are available on request.

Intel SpeedStep, Intel Thread Checker, Celeron, Dialogic, i386, i486, iCOMP, Intel, Intel logo, Intel386, Intel486, Intel740, IntelDX2, IntelDX4, IntelSX2, Intel Inside, Intel Inside logo, Intel NetBurst, Intel NetStructure, Intel Xeon, Intel XScale, Itanium, MMX, MMX logo, Pentium, Pentium II Xeon, Pentium III Xeon, Pentium M, and VTune 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 © 2004, Intel Corporation. All rights reserved.