/Intel(R) Fortran Compiler 9.0 for Linux*
Release Notes/
Contents
* Overview
* Changes
* System Requirements
* Installation
* Known Issues
* Technical Support
* Documentation
* Additional Information
* Disclaimer and Legal Information
Overview
This product provides tools for Linux* software developers to create
applications that run at top speeds on all Intel(R) IA-32 processors,
Intel processors with Intel(R) Extended Memory 64 Technology (Intel(R)
EM64T) and the Intel Itanium(R) 2 processors. Optimizations include
support for Streaming SIMD Extensions 2 (SSE2) in the Intel Pentium(R) 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(R) 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(R) 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 http://www.intel.com/software/products/compilers/
. Additional
information on the Intel Software Development Products is available at
http://www.intel.com/software/products/
.
Product Contents
Intel(R) Fortran Compiler for IA-32 Based Applications
The Intel(R) Fortran compiler for IA-32 based applications contains the
following components:
* Intel(R) Fortran Compiler for Linux for IA-32 applications, version 9.0
* Intel(R) Debugger for IA-32 applications, version 9.0
* Intel(R) Compilers code-coverage tool
* Intel(R) Compilers test-prioritization tool
* The product documentation, version 9.0
o The documentation index is provided for easy access of all
the documents. It is located at
|/doc/doc_index.htm|
o A training tutorial /Enhancing Performance with Intel
Compilers/ is also included
Intel(R) Fortran Compiler for Intel EM64T-Based Applications
* Intel(R) Fortran Compiler for Linux for Intel EM64T-Based
applications, version 9.0
* Intel(R) Debugger for Intel EM64T-based applications, version 9.0
* Intel(R) Compilers code-coverage tool
* Intel(R) Compilers test-prioritization tool
* The product documentation, version 9.0
o The documentation index is provided for easy access of all
the documents. It is located at
|/doc/doc_index.htm|
o A training tutorial /Enhancing Performance with Intel
Compilers/ is also include
Intel(R) Fortran Compiler for Itanium-Based Applications
The Intel(R) Fortran compiler for Itanium-based applications contains the
following components:
* Intel(R) Fortran compiler for Itanium-based applications, version 9.0
* Intel(R) Debugger for Itanium-based applications, version 9.0
* Intel(R) Itanium Assembler to produce Itanium-based applications,
version 8.0
* Intel(R) Compilers code-coverage tool
* Intel(R) Compilers test-prioritization tool
* The product documentation, version 9.0
o The documentation index is provided for easy access of all
the documents. It is located at
|/doc/doc_index.htm|
o A training tutorial /Enhancing Performance with Intel
Compilers/ is also included
Compatibility
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, please let us know which ones through Intel(R)
Premier Support at https://premier.intel.com
. Fortran sources built with Intel Fortran
8.0 or later do not need to be recompiled for use with version 9.0.
Please also see the section below on "Change in Linking Mixed
Fortran-C/C++ Applications".
Changes in Version 9.0
The following section discusses new features and changes in the Intel
Fortran Compiler version 9.0 and updates to 9.0. Please see the separate
release notes for the Intel Debugger.
Compiler
New Compiler Options
Some compiler options are only available on certain systems, as
indicated by these labels:
i32
The option is available on IA-32 based systems
i32em
The option is available on IA-32-based systems with Intel(R) Extended
Memory 64 Technology (Intel(R) EM64T)
i64
The option is available on Itanium(R)-based systems
If no label appears, the option is available on all supported systems.
If "only" appears in the label, the option is available on the
identified system(s) only.
For more details on the options, refer to the Alphabetical Compiler
Options section of the Intel Fortran Compiler for Linux User's Guide.
-assume [no]2underscores
Specifies whether or not the compiler appends two underscores to
external names containing an underscore, for compatibility with g77
naming behavior. (Note that this does not provide object
compatibility with g77.)
-B
Specifies where to find libraries, headers and executables for the
compiler itself.
-debug [no]inline_debug_info
Specifies whether enhanced source position information is produced
for inlined code.
-debug [no]semantic_stepping
Specifies whether enhanced debug information useful for breakpoints
and stepping is produced.
-debug extended
Enables all -debug options except inline_debug_info.
-f[no-]math-errno
Tells the compiler that errno can be reliably tested after calls to
standard math library functions.
-f[no-]omit-frame-pointer ( i32 only)
Indicates whether the compiler should use the frame pointer for
IA32. -fno-omit-frame-pointer is a synonym for -fp.
-ftrapuv
Initializes stack local variables to an unusual value that may help
detect uninitialized variables.
-funroll-loops
Tells the compiler to unroll user loops based on the default
optimization heuristics. Synonym for -unroll.
-[no]gen-interfaces
Tells the compiler to generate an interface block for each routine
in a source file.
-[no-]global-hoist
Determines whether certain optimizations are enabled that can move
memory loads to a point earlier in the program execution than where
they appear in the source.
-i-dynamic
Links Intel-provided libraries dynamically (required if using
-mcmodel=medium or -mcmodel=large for EM64T)
-i-static
Links Intel-provided libraries statically.
-map-opts
Enables a tool that maps a command line to another platform
(Windows* to Linux* or vice versa).
-m[no-]ieee-fp
Controls whether the compiler uses IEEE floating point comparisons.
-mtune=
Performs optimizations for a particular CPU.
-[no-]prec-sqrt ( i32, i32em only)
Determines whether or not to disable certain optimizations that
improve performance of square root operations while slightly
reducing precision.
-print-multi-lib
Displays information about libraries being used.
-prof-gen-sampling
Asks the compiler to prepare the code for use with the
sample-gathering tool profrun.
-sox
Causes the compiler to save compiler version and compilation options
in the object and executable files (new for i64)
-ssp (i32 only)
Enables the software-based speculative pre-computation (SSP)
optimization to generate prefetching helper threads.
--version
Displays compiler version information.
-warn [no]interfaces
Lets you check the interfaces of all SUBROUTINEs called and
FUNCTIONs invoked in your compilation - used in conjunction with
-gen-interfaces.
-WB
Turns a compile-time bounds check error into a warning.
New Language Features
The following features from the Fortran 2003 standard are now supported
by the Intel Fortran Compiler
* COMMAND_ARGUMENT_COUNT intrinsic returns the number of command
arguments
* GET_COMMAND intrinsic returns the entire command
* GET_COMMAND_ARGUMENT intrinsic returns a command argument
* GET_ENVIRONMENT_VARIABLE intrinsic obtains the value of an
environment variable
The following is a list of additional new and changed language features.
Please see the Intel Fortran Language Reference for more information.
* The AUTOMATIC, EXTERNAL, INTRINSIC, SAVE, STATIC and VOLATILE
statements may now be used with Fortran 95 attribute-style double
colon syntax
* The intrinsic subroutine DATE_AND_TIME is now generic based on the
kind of the VALUES argument
* The intrinsic subroutine RANDOM_SEED is now generic based on the
kind of the arguments
* The INQUIRE statement now has the ability to ask if a directory
exists. New specifiers are DIRECTORY and DIRSPEC
* The OPEN statement now has a new specifier NOSHARED
* The new MEMREF_CONTROL directive lets you provide cache hints for
prefetches, loads and stores (Itanium-only)
Loop Directives May Now Be Used For Array Assignments
Loop directives such as |IVDEP| and |NOUNROLL| may now be placed
preceding array assignments and will apply to loops generated by the
compiler for such assignments. For more information, see the Language
Reference section "Rules for Loop Directives that Affect Array
Assignment Statements" in the chapter on Directives.
OpenMP |WORKSHARE| Directive Supported
The OpenMP* 2.0 |WORKSHARE| directive is now supported.
IF and DO Nesting Maximum Level Increased to 256
The maximum nesting level for IF and DO constructs (combined) has been
increased from 128 to 256.
Automatic Interface Checking
The compiler is now able to perform some degree of consistency checking
between call and called routine in an application in the absence of
explicit interfaces, even across multiple source files. The new
|-gen-interfaces| option instructs the compiler to generate and compile
a Fortran module source with an explicit interface for all global
procedures not in a module. The names of the generated files are based
on the procedure name with a suffix of "|_mod|" and the file type |.f90|
and |.mod|. The generated interface includes name, type and rank of each
dummy argument. It does not include other attributes such as |INTENT
|and| OPTIONAL |that may have been specified in the procedure.
The new |-warn interfaces| option instructs the compiler to look for a
generated module of the appropriate name when it sees a reference to a
procedure lacking an explicit interface. If it finds one, it behaves as
if a |USE| of that module had been specified for the program unit being
compiled. If the call is inconsistent with the implicitly imported
interface, the compiler issues a diagnostic message as if the same
interface had been explicitly specified.
For best results, specify both |-gen-interfaces| and |-warn interfaces|.
The compiler will ensure that all calls within a source file are
properly verified. Calls to procedures in separately compiled source
files will be verified if the defining source is compiled first.
Additional Optimization at |-O2|
When the default optimization level (|-O2|) is specified, the compiler
now performs certain interprocedural and loop optimizations that were
formerly performed only when |-ip| or |-O3| were specified. We invite
your comments as to the effect of this change on performance (both
run-time and compile-time) as well as application results.
Optimization Improvements
The compiler is now able to vectorize loops made parallel through the
use of OpenMP directives. Additional optimization improvements have been
made that could lead to improved performance. Examples are loop blocking
for better cache utilization; runtime dependency checking and loop
versioning.
Loop Optimization Reports Improved
A number of improvements have been made to the optimization reports. For
example, loop optimization reports, selected with |-opt_report_phase
hlo|, now have more detailed line number information for unrolled loops,
and identifiers for multiple versions of loops.
Multiple Object Default for |-ipo|
When - |ipo| is specified, the compiler now, by default, can produce
multiple intermediate object files for input to the linker, rather than
a single file. This can improve performance of the link phase. You can
adjust this behavior by specifying a value for |-ipo|. Please refer to
the Compiler Options Guide for more information.
Software-based Speculative Pre-Computation (IA-32 Only)
The new |-ssp| option enables Software-based Speculative Pre-computation
(SSP) optimization, which is also called Helper-Threading optimization.
This feature provides a way to dynamically prefetch data cache blocks to
reduce the impact of memory latency. It exploits the properties of
source code constructs (such as delinquent loads and pointer-chasing
loops) in applications.
SSP directly executes a subset of the original program instructions,
called a slice, on separate threads alongside the main computation
thread, in order to compute future memory accesses accurately. The
helper threads run ahead of the main thread and trigger cache misses
earlier on its behalf, thereby hiding the memory latency.
To be effective, SSP techniques require construction of efficient helper
threads and processor-level support, such as Hyper-Threading Technology
(HT Technology) support, which allows multiple threads to run
concurrently with a shared cache. These techniques include:
* Delinquent load identification
* Loop selection
* Program slicing
* Helper-thread code generation
The results of SSP vary because each program has a different profile and
different opportunities for SSP optimizations. For guidelines to help
you determine if you can benefit by using SSP, see the topic
"Software-based Speculative Precomputation (IA-32)" in the
Profile-Guided Optimization section of your Optimizing Applications guide.
CALL of Function with Implicit Interface No Longer Allowed
In previous versions of the compiler, a |CALL| to a name given a type,
thus making it a function with an implicit interface, was allowed in
some cases. For example:
|REAL F
CALL F(X)|
This is not allowed by the Fortran language, and, depending on the
platform and the actual or declared datatype of the function, could
cause corruption of the floating point stack. As of version 9.0,
attempting to |CALL| a typed identifier will give an error. If your
application took advantage of this feature, replace the |CALL| with a
function reference assigned to a variable. Note that a |CALL| to a
function with an explicit interface has not been allowed in the past -
that behavior has not changed.
Mismatch of Argument |KIND| Now Diagnosed
In previous versions, the compiler would silently allow a mismatch of
KIND for an argument when calling a routine that had an explicit
interface. For example, consider the following:
|interface
subroutine sub (x)
real(8) :: x
end subroutine sub
end interface
...
call sub(3.0)|
The |3.0| in the call is of type "default real", or |real(4)|.
Previously, the compiler would accept this and convert the value on the
call and return. Now, the compiler will give an error such as:
|Error: The type of the actual argument differs from the type of the
dummy argument. [3.0]
call sub(3.0)
---------^|
This issue also arises for mismatches of integer and logical kinds. If
your application took advantage of the earlier compiler's failure to
diagnose this error, you can correct the problem by making sure that the
argument is the correct kind. For constants, you can add the kind
specifier suffix, such as |3.0_8| or |50_2|. For constants or
expressions, use the |COMPLEX|, |INT|, |LOGICAL| or |COMPLEX| intrinsics
with the second |KIND| argument to convert the argument to the proper
kind. For variables, you will need to correct the declaration of the
variable to make sure that it matches the expected kind.
Change in Behavior of |FLUSH| Library Routine
In versions 8.0 and 8.1 of the Intel Fortran Compiler, the |FLUSH|
library routine from module |IFPORT| waited until the data was written
to disk before returning control to the application. In version 9.0,
|FLUSH| empties the internal buffers and waits for the operating system
to acknowledge receipt of the data, but it does not wait for the disk to
be updated, thus improving performance. If your application requires
that the data be written to the physical disk file, use the |COMMITQQ|
library routine instead.
Change in Linking Mixed Fortran-C++ Applications
Fortran applications are no longer linked against a C++ runtime library.
If the Intel Fortran driver ( |ifort|) is used to link mixed C++ and
Fortran applications, the appropriate C++ runtime libraries must be
added explicitly to the command line. If the Intel C++ driver (|icc|) is
used to link mixed C++ and Fortran applications, the appropriate Fortran
runtime libraries must be added to the command line. The runtime
libraries supplied with the Intel Fortran compiler are listed in the
"Libraries Provided by Intel Fortran" section of the Fortran Compiler
User's Guide. It is possible to see which runtime libraries would be
linked by either of the compiler drivers by using the |-dryrun| command
line option.
For example, if you were to use the ifort driver to link a
mixed-language application, your command line might be:
|ifort prog.f90 prog_cpp_code.o -cxxlib-gcc
-L/usr/lib/gcc/i386-redhat-linux/3.4.3 -lstdc++|
The -cxxlib-gcc flag will add certain platform dependent options and
libraries. The path to libstdc++ and the reference to the library itself
are required.
|GCC_EXEC_PREFIX| Environment Variable
If you specify a value for the |GCC_EXEC_PREFIX| environment variable,
the compiler uses the value as a prefix to the following:
* gcc tools, such as |ld| and |as|
* Default include paths
* Default library paths
If the value specified is a directory, the compiler treats it as a path.
For example, if |GCC_EXEC_PREFIX=/my/path/| then gcc tool |ld| becomes
|/my/path/ld| and the compiler treats it as a path to the tool. Note
that the tool must exist in the specified path or the path is ignored
and the compiler searches for the tool in default directories.
Library search paths are modified to include the specified prefix for
|crt*.o| objects. The prefix is also used as an |-L| search path.
This feature is useful if you want to use an alternate set of gcc tools
and libraries.
Note that if |?Ldir| or |?Bdir| is specified on the command line, they
take precedence for library search paths over the environment variable.
The order of precedence is as follows (highest to lowest):
* |-Ldir|
* |-Bdir|
* |GCC_EXEC_PREFIX| environment variable
Small, Medium and Large Memory Models on EM64T
Applications built to take advantage of Intel EM64T can be built with
one of three memory models:
Small (default)
Code and data is restricted to the first 2GB of address space, so
that all accesses of code and data can be done with Instruction
Pointer (IP)-relative addressing
Medium (|-mcmodel=medium|)
Code is restricted to the first 2GB, no restriction on data; code
can be accessed with IP-relative addressing, but access of data must
use absolute addressing
Large (|-mcmodel=large|)
No restrictions on code or data; accesses to both code and data use
absolute addressing
IP-relative addressing requires only 32 bits, whereas absolute
addressing requires 64-bits. This can affect code size and performance
(IP-relative addressing is somewhat faster.)
*Note: *When the medium or large memory models are specified, you must
also specify -i-dynamic to ensure that the correct dynamic versions of
the Intel run-time libraries are used.
When shared objects (.so) are built, Position-Independent Code (PIC) is
specified (|-fpic| is added by the compiler driver) so that a single .so
can support all three memory models. However, code that is to be placed
in a static library, or linked statically, must be built with the proper
memory model specified. Note that there is a performance impact to
specifying the Medium or Large memory models.
System Requirements
Supported Host and Target Combinations
The following list describes the supported combinations of compilation
host (system on which you build the application) and application target
(system on which the application runs).
IA-32 Host
Supported targets: IA-32 and Intel(R) EM64T
Intel(R) EM64T Host
Supported targets: IA-32 and Intel(R) EM64T
Intel(R) Itanium(R) Host
Supported target: Intel(R) Itanium(R)
*Note:* Development for a target different from the host may require
optional library components to be installed from your Linux Distribution.
Requirements to develop IA-32 applications
* A system based on an IA-32 processor (minimum 450 MHz Intel
Pentium(R) II processor or greater - Intel Pentium(R) 4 or Pentium(R) D
or Intel(R) Xeon(TM) processor recommended), or a system based on an
Intel processor with Intel EM64T, or a system based on an AMD*
Athlon* or AMD Opteron* processor
* 128 MB (256MB recommended).
* 100 MB of disk space, plus an additional 200 MB during
installation for the download and temporary files.
* Linux system with glibc 2.2.4, 2.2.5, 2.2.93, 2.3.2 or 2.3.3 and
the 2.4.X or 2.6.X Linux kernel as represented by the following
distributions. *Note:* Not all distributions listed are validated
and not all distributions are listed.
o Red Hat* Linux 7.3, 8, 9
o Red Hat Enterprise Linux* 2.1, 3, 4
o SUSE* LINUX 8.2, 9.1
o SUSE LINUX Enterprise Server* 8, 9
* Linux Developer tools component installed, including gcc, g++ and
related tools.
Requirements to Develop Applications for Systems with Intel
EM64T or AMD Opteron Processors
* A system based on an Intel processor with Intel EM64T or based on
an AMD Opteron processor
* 256 MB of RAM (512 MB recommended)
* 300 MB free hard disk space, plus an additional 300 MB during
installation for download and temporary files.
* 100 MB of hard disk space for the virtual memory paging file. Be
sure to use at least the minimum amount of virtual memory
recommended for the installed distribution of Linux
* Linux system with glibc 2.3.2 or 2.3.3 and the 2.4.X or 2.6.X
Linux kernel as represented by the following Linux distributions,
running in 64-bit mode. *Note:* Not all distributions listed are
validated and not all distributions are listed.
o Red Hat* Enterprise Linux 3, 4
o SUSE* LINUX 9.1 Professional
o SUSE LINUX Enterprise Server 9
* Linux Developer tools component installed, including gcc 3.3.3,
g++ and related tools.
* 32-bit (IA-32) C and C++ runtime libraries: libm.so.6,
libpthread.so.0, libc.so.6, libstdc++.so.5 and libgcc_s.so.1
*Note:* The requirement for the 32-bit (IA-32) libraries is due to the
compiler and other tools being 32-bit applications that dynamically link
to these libraries. If these libraries are not installed, the following
error may be displayed when the compiler is invoked:
|error while loading shared libraries: libstdc++.so.5: cannot open
shared object file: No such file or directory|
The error message is confusing as it does not indicate that the IA-32
version of libstdc++.so.5 is required. To avoid this problem, be sure
that the 32-bit (IA-32) versions of these libraries are installed. Most,
but not all, Linux distributions for Intel EM64T will install these by
default.
Requirements to Develop Itanium-based Applications
* A system based on an Intel(R) Itanium(R) 2 processor.
* 512 MB (1GB recommended).
* 150 MB of disk space, plus an additional 200 MB during
installation for the download and temporary files.
* Linux system with glibc 2.2.4, 2.2.5, 2.3.2 or 2.3.3 and the 2.4.X
or 2.6.X Linux kernel as represented by the following
distributions. *Note:* Not all distributions listed are validated
and not all distributions are listed.
o Red Hat Linux 7.2
o Red Hat Enterprise Linux AS 2.1, 3, 4
o SUSE LINUX Professional* 9.1
o SUSE LINUX Enterprise Server 8, 9
o United Linux* 1.0
* Linux Developer tools component installed, including gcc, g++ and
related tools.
We recommend using binutils 2.14 or later, especially if using shared
libraries as there are known issues with binutils 2.11.
We are unable to install on the unsupported configuration of Red Hat
Enterprise Linux 4 beta systems without 32-bit support in the kernel. If
you encounter this limitation please contact Intel(R) Premier Support for
a workaround.
*Notes:*
* 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.
* The above lists of processor model names are not exhaustive -
other processor models correctly supporting the same instruction
set as those listed are expected to work. Please contact Intel(R)
Premier Support if you have questions regarding a specific
processor model
* Some optimization options have restrictions regarding the
processor type on which the application is run. Please see the
documentation of these options for more information.
Installation
Please see the separate Installation Guide for information
on installing the compiler and setting up the compiler environment. The
default installation directories, referred to elsewhere in this document
as || and ||, are:
* |/opt/intel/fc/9.0| (for IA-32 and Itanium)
* |/opt/intel/fce/9.0| (for Intel EM64T)
* |/opt/intel/idb/9.0 | (for IA-32 and Itanium)
* |/opt/intel/idbe/9.0| (for Intel EM64T)
Known Issues
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.
-debug parameters Not Yet Functional
The -debug parameters switch, described in the documentation, is not
functional in this release. It will be made available in a future
update. We apologize for the inconvenience.
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 2GB 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.
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 9.0, specifying |-shared| will
automatically set |-i_dynamic| and |-nofor_main|.
|-ipo_obj| option is no longer supported
The |-ipo_obj| option, which forced generation of direct object code, is
no longer supported. If the option is specified, a warning is given and
the effect is as if |-ip| was specified instead.
|-relax| no longer passed to linker on Itanium-based systems
As of version 9.0, the compiler driver no longer passes the |-relax|
switch to the linker on Itanium-based systems, as this conflicts with
the |-r| option. The -relax option is not needed as it is the default
when using binutils 2.11.90.0.27 or later - 2.14 is recommended. If you
must use an older binutils and wish to specify the |-relax| option, use
|-Xlinker -relax| on the compile command which invokes the linker.
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 2.14.90.0.4.1 or later, or FSFbinutils 2.15 or later if this is
an issue for you.
Use |idb| with Extended Debug Information
If you use the |-debug |keywords |inline_debug_info|,
|semantic_stepping|, |variable_locations| or |extended|, you should use
the Intel Debugger (idb), as other debuggers may not understand the
extended information and may behave unpredictably. We are working with
the developers of other debuggers towards their adding support for the
extended debug information.
|-auto_ilp32| Option Not Supported
The |-auto_ilp32| option which specifies that that an application cannot
exceed a 32-bit address space, and which is mentioned in the
documentation, is not supported.
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(R)
Premier Support account on our secure web site,
https://premier.intel.com . Please register
at https://registrationcenter.intel.com/
.
* Registering for support varies for release products or pre-release
products (alpha, beta, etc) - only released products have support
web pages on http://support.intel.com/ .
* If you are having trouble registering or are unable to access your
Intel(R) Premier Support account, please let Intel know of the
problem at https://registrationcenter.intel.com/support.
*Note:* If your distributor provides technical support for this product,
please contact them for support rather than Intel.
For information about the Intel Fortran Compiler's Users Forums, FAQ's,
tips and tricks, and other support information, please visit:
http://support.intel.com/support/performancetools/fortran/linux/
. For
general support information please visit
http://www.intel.com/software/products/support/
.
Submitting Issues
Steps to submit an issue:
1. Go to https://premier.intel.com/.
2. Log in to the site. Note that your username and password are
case-sensitive.
3. Click on the "|Go|" button next to the "|Product|" drop-down list.
4. Click on the "|Submit Issue|" link in the left navigation bar.
5. Choose "|Development Environment (tools,SDV,EAP)|" from the
"|Product Type|" drop-down list.
6. If this is a software or license-related issue, choose "|Intel(R)
Fortran Compiler for Linux*|" from the "|Product Name|" drop-down
list.
7. 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
command:
| > ifort -what|
and copy the "Package ID" (e.g. |*l_fc_p_9.0.xxx*|) 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 |_README| (e.g. |l_fc_p_9.0.xxx_README|),
available for download from Intel(R) Premier Support,
https://premier.intel.com , to see which
issues have been resolved in the latest version of the compiler.
Documentation
You can view the Intel compiler and related HTML-based documentation
with your Web browser. You should use a Web browser that supports
JavaScript (such as Firefox*), so it can which provide full navigation,
search, index look-up, and hyperlink capabilities amongst the online
help files PDF versions of most manuals are available online at
http://developer.intel.com/software/products/compilers/flin/docs/manuals.htm
.
The documentation is installed in the |/doc| directory. An
HTML index document can be found at |/doc/doc_index.htm| .
A training tutorial /Enhancing Performance with Intel(R) Compilers/ is
also available from links in the documentation index. /The Intel(R)
Debugger Manual/ is provided in HTML form in the Intel(R) Debugger doc
directory.
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
|/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 Documentation
The HTML documentation format has been tested to work with web browsers
shipped on supported Linux* distributions. PDF versions of the compiler
documentation are available at:
http://developer.intel.com/software/products/compilers/flin/docs/manuals.htm
Additional Information
Related Products and Services
Information on Intel software development products is available at
http://www.intel.com/software/products
.
Some of the related products include:
* The Intel(R) Software College
provides training for
developers on leading-edge software development technologies.
Training consists of online and instructor-led courses covering
all Intel architectures, platforms, tools, and technologies.
* The Intel(R) VTune? Performance Analyzer
enables 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.
* The Intel(R) C++ and Fortran Compilers
are
an important part of making software run at top speeds with full
support for the latest Intel IA-32 and Itanium(R) processors.
* The Intel(R) Performance Library Suite
provides a set of routines optimized for various Intel processors.
The Intel(R) Math Kernel Library
, which
provides developers of scientific and engineering software with a
set of linear algebra, fast Fourier transforms and vector math
functions optimized for the latest Intel Pentium(R) and Intel
Itanium processors. The Intel(R) Integrated Performance Primitives
consists of
cross-platform tools to build high performance software for
several Intel architectures and several operating systems.
Disclaimer and Legal Information
The information in this document is subject to change without notice and
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. This document and the
software described in it are furnished under license and may only be
used or copied in accordance with the terms of the license. No license,
express or implied, by estoppel or otherwise, to any intellectual
property rights is granted by this document. The information in this
document is provided in connection with Intel products and should not be
construed as a commitment by Intel Corporation.
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, life sustaining, critical
control or safety systems, or in nuclear facility applications.
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 document may contain software defects
which may cause the product to deviate from published specifications.
Current characterized software defects are available on request.
Intel, the Intel logo, Intel SpeedStep, Intel NetBurst, Intel
NetStructure, MMX, Intel386, Intel486, Celeron, Intel Centrino, Intel
Xeon, Intel XScale, Itanium, 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 (C) 2005, Intel Corporation.