This product provides tools for Mac OS* X software developers to create Fortran applications that deliver outstanding performance on Intel®-based Mac* systems running Mac OS* X . Intel® Fortran is a full-language Fortran 95 compiler with many features from the Fortran 2003 standard, plus a wide range of popular language extensions. Intel® Compilers support multi-threaded code development through auto-parallelism and OpenMP* support.
This product is available in two editions.
The Standard Edition contains the following components:
<install-dir>/doc/Doc_Index.html
The Professional Edition includes all of the Standard Edition and adds the Intel® Math Kernel Library, which contains highly optimized, extensively threaded, mathematical functions for engineering, scientific, and financial applications that require maximum performance..
Note: The installation path for the Intel® Fortran
Compiler is /opt/intel/fc/10.1.xxx (32-bit) or
/opt/intel/fce/10.1.xxx (64-bit), where xxx represents
a 3-digit update number. The term <install-dir> is used
in throughout this document to refer to the default installation
path.
Installation of the Intel® Math Kernel Library is separate from that of the compiler. Please see the Intel® Math Kernel Library Installation Guide for details.
To receive technical support and product updates for the tools provided in this product you need to register. For how to register, please see Technical Support section below.
The following section discusses new features and changes in the Intel Fortran Compiler since version 10.0. Please see the separate release notes for the Intel Debugger.
The following is a listing of command line options that are new or have changed since the initial version 9.1 release. Please refer to the compiler documentation for more information on these options.
-assume [no]old_boz -assume noold_boz) -assume [no]old_unit_star -assume old_unit_star) -assume protect_parensREAL and COMPLEX expression evaluations by not reassociating operations.-assume [no]realloc_lhs -assume [no]std_mod_proc_name -check [no]pointerALLOCATABLE variables. (Default: off)-cxxlib-nostd-diag-<type> <diag-list>-diag-dump-diag-enable sv[1|2|3] -diag-enable sv-include-diag-file[=file] -diag-file-append[=file]-[no-]diag-id-numbers -f[no-]align-functions[=n]-fast-f[no-]instrument-functions-f[no]-keep-static-consts-fp-speculation=<mode>-gdwarf-2-heap-arrays[-]-help [category]-ipo-jobs<n>-m32-m64-msse3 -[no-]opt-multi-version-aggressive-opt-ra-region-strategy [=keyword]default) -opt-streaming-stores keywordauto) -[no-]par-runtime-control-par-schedule-<keyword>[[]n]-save-temps[-]-shared-intel-static-intel-std or -stand-std03 or -stand f03. Note that this is a change from previous
versions. (Default: off)-std03 or -stand f03 -tcheck [<mode>]-[no-]unroll-aggressive-[no-]vec-guard-writeFor information on command line options that are either deprecated (still functional but to be removed in a future version) or removed (no longer supported), please refer to the section Compiler Options > Deprecated and Removed Compiler Options in the on-disk documentation.
-fast Changed The -fast option is a shorter way of specifying a set of options
that generally improve run-time performance. As documented, the set
of options may change over time. In version 10.0, -fast sets -xT,
whereas in earlier versions it set -xP. If this change is not
appropriate for you, you must specify the individual options you want
instead of using -fast. Please see the Compiler Options
section of the on-disk documentation for further information.
-stand ChangedIn version 10.1, the meaning of the -stand option, when specified
without a following keyword, is changed to mean -stand f03,
or checking for conformance to Fortran 2003. You can select checking against
Fortran 90 or Fortran 95 by specifying -stand f90 or -stand
f95. -std is an alternate spelling of -stand.
Note that the Intel® Fortran Language Reference still highlights Fortran 2003
features as extensions to Fortran 95.
Many command line options have an older spelling where underscores (“_”) instead of hyphens (“-“) connect the words in the option name. The older spelling is still a valid alternate option name.
This version includes two compilers, one that generates code for Mac* systems based on Intel® 64 architecture processors, and one that generates code for Mac* systems based on IA-32 architecture processors.
Fortran 2003 defines behaviors for language features that were either extensions to previous standards or left unspecified in earlier standards. While version 10.1 of the Intel Fortran Compiler does not yet support all of Fortran 2003, the compiler now selects the Fortran 2003 behavior in some cases where earlier compiler versions chose a different behavior. In some other cases, the compiler defaults have not yet changed. These are described below.
In Fortran 95, assignment to an allocatable array required that the left
and right hand side of the assignment match in shape and length
parameters. In Fortran 2003, if the shapes and length parameters
do not match, the variable being assigned to is deallocated and
then reallocated to shape and length parameters matching the expression
being assigned. As of version 10.1, the compiler can perform the
extra actions specified by Fortran 2003, but as these can significantly
hurt performance, the default is to retain the Fortran 95 behavior requiring
that the shapes and length parameters match. If you want the Fortran
2003 behavior that deallocates and reallocates the variable on a shape
mismatch, specify -assume realloc_lhs
In Fortran 95, binary, octal and hexadecimal constants ("BOZ constants") were allowed in DATA statements only and were restricted to initializing scalar integer variables. As an extension to Fortran 95, the Intel Fortran Compiler allowed BOZ constants in any context, with the type interpretation determined by the context. Fortran 2003 expands the use of BOZ constants permitting them to initialize any numeric type and in arguments to the INT, REAL, DBLE and CMPLX intrinsics.
The Fortran 2003 semantics for use of BOZ constants match the previous extended implementation of Intel Fortran except for the case of a BOZ constant as an argument to INT, REAL, DBLE and CMPLX. Fortran 2003 specifies that in these contexts a BOZ constant is interpreted as a binary value which is interpreted directly as the data type returned by the intrinsic, whereas the previous Intel Fortran interpretation was to treat the BOZ constant as a signed integer value which was then converted.
For example:
print *, real(Z'40490FDB')
with the old behavior (-assume old_boz) prints 1.0785300E+09
and with the new behavior (-assume noold_boz) prints 3.141593.
As of version 10.0, the default behavior for Intel Fortran is that of
Fortran 2003, to transfer the binary value without conversion. If your
application needs the old behavior, compile with the option -assume
old_boz.
In the Intel Fortran Compiler, I/O unit * and the implied units used
by the ACCEPT, PRINT and TYPE statements,
are by default associated with unit numbers distinct from those that could
be specified in an OPEN statement, such as unit 5 or 6. Fortran
2003 requires that the programmer be able to OPEN these default units,
which is incompatible with the current Intel Fortran behavior.
In version 10.0, the -assume [no]old_unit_star compile command
option has been added to control this behavior. The default, -assume
old_unit_star, retains the current and past behavior with unit
* being distinct from units 5 and 6. If you want to use the Fortran 2003
behavior, or if you will be using the Fortran 2003 intrinsic module ISO_FORTRAN_ENV and
its defined constants INPUT_UNIT and OUTPUT_UNIT,
specify -assume noold_unit_star to have unit * (and ACCEPT, PRINT and TYPE)
use units 5 (input) and 6 (output).
The default for this behavior may change in a future release.
RECL= unit for unformatted filesIn version 10.0, as in versions 8.x and 9.x of Intel Fortran, when opening
a file for unformatted I/O, the value specified for the RECL= keyword
in OPEN is in four-byte units, the size of a default integer.
Previous Fortran standards have said that the RECL= unit
was "implementation-dependent", but Fortran 2003 "recommends" that
it be single bytes. To specify that the RECL= unit for unformatted
I/O be bytes, use the existing compiler option -assume byterecl.
You must also use this option if your application uses the FILE_STORAGE_SIZE named
constant from the intrinsic module ISO_FORTRAN_ENV.
.XOR. Intrinsic OperatorThe Intel Fortran compiler defines, as an extension, an intrinsic operator .XOR..
This can cause conflicts with a user-defined operator of the same
name as the intrinsic operator has a different precedence than user-defined
operators. If you are definining your own operator .XOR. you
can specify -assume no_old_xor to disable the compiler's
definition of .XOR. as an intrinsic operator.
The Intel Fortran compiler constructs the global name for module procedures
and variables by joining the module name with the procedure or variable
name, separated with the string "_mp_", and then
applying the standard name decoration rules. For example, a procedure SUB in
module MYMOD would have a global name of MYMOD_mp_SUB.
This method could conflict with a user procedure whose name contains the
string _mp_. If your application has this conflict, specify
the option -assume noold_mod_proc_name which will switch
the case of the separator to be the opposite of the default name case.
You must specify the same option for the entire application so that the
names are consistent.
As of version 10.1, the compiler supports the Fortran 2003 Stream I/O
feature, which provides the ability to read and write files as a stream
of bytes. To enable stream access, open the file specifying ACCESS='STREAM'.
The READ and WRITE statements support a POS= keyword
to specify file position. For more information, please refer to the Intel
Fortran Compiler Language Reference.
Intel Fortran has supported, as an extension, the RECORDTYPE values STREAM, STREAM_CR and STREAM_LF in the OPEN statement. In previous versions, neither the documentation nor the implementation were correct and the two were inconsistent. The old behavior was as follows:
Furthermore, if CARRIAGECONTROL='NONE' was specified, the behavior changed.
In version 10.1, the behavior changes as follows:
A new option is defined as follows:
CARRIAGECONTROL no longer affects the behavior of RECORDTYPE.
On Windows, the default formatted record delimiter is CR-LF; on Linux and Mac OS it is LF. With these changes, it is now possible to specify a particular delimiter type on all three operating systems in a consistent fashion.
If you wish to change the run-time behavior of an application without
editing the source, a new environment variable FOR_FMT_TERMINATOR can
be defined. The value of this environment variable takes the form:
mode[:ulist][;mode[:ulist]...]
where mode is one of CR, LF or CRLF and
ulist is an optional range of unit numbers to which that mode applies,
for example, 2,17-20, 91
The following features from the Fortran 2003 standard have been added since the initial release of version 9.1. Some of these features first appeared in updates to version 9.1. For additional details, please see the Intel® Fortran Language Reference.
/assume:byterecl and /assume:noold_unit_star for
correct values) COMMAND_ARGUMENT_COUNT intrinsic procedureFor details on the following new language features, please see the Intel® Fortran Language Reference
Two new environment variables are available to change the run-time behavior
of applications: FORT_FMT_RECL and FORT_UNFMT_RECL.
FORT_FMT_RECL is used to specify a default RECL (Record
Length) value for all Fortran units opened for formatted I/O. If defined
with an unsigned decimal integer value, the environment variable value is
used as if that value had been specified for RECL= for OPEN when
the RECORDTYPE is not 'FIXED'. The most common
use of this is to change the line length for list-directed output, which
has a default of 80 columns.
FORT_UNFMT_RECL is used to specify a default RECL (Record
Length) value for all Fortran units opened for unformatted I/O. If defined
with an unsigned decimal integer value, the environment variable value is
used as if that value had been specified for RECL= for OPEN when
the RECORDTYPE is not 'FIXED'. The most common
use of this is to change the maximum segment length for files opened with RECORDTYPE='SEGMENTED',
which has a default of 2040 bytes.
KMP_AFFINITY Environment Variable for OpenMP* Applications The KMP_AFFINITY environment variable can be used in
an OpenMP* application to specify how execution threads should be bound
to processors on the system. This setting's effect is to bind each
thread, in order of creation, in a round-robin fashion to a processor
core in the system for the duration of the program. The value of KMP_AFFINITY should
be of the form:
compact,<level>
where <level> is a non-negative integer. For example:
compact,1
The argument <level> specifies the gap between
successive thread's bound cores in the machine topology map, which
is represented as a binary tree. A level of zero indicates that threads
will be bound to successive threading contexts for processors which
have Intel® Hyper-Threading Technology enabled, or successive processors
if not. The levels increase by one level from threading contexts, to
cores, to packages (processors) in sequence. This setting is supported
for processors supplied by Intel Corporation only on systems where
the required operating system support for thread binding is present.
This version features a complete redesign of the optimizer that integrates
parallelization and vectorization
at O2 and O3 optimization
levels with memory and loop optimizations.
Performance can be substantially improved by:
Loop Transformation (HLO) Optimization reports tell you why the compiler was unable to apply loop interchange transformations on a set of loops and suggests loop interchange if the reported bottlenecks can be removed by source changes. These reports have been enhanced to provide more detailed information and to be easier to understand.
Static Verifier is a new compiler feature which performs static analysis
of a program across multiple source files. It can detect different
kinds of defects and doubtful or inconsistent uses of language features
in user code and report them according to their severity level. Static
Verifier understands C/C++ and Fortran code and can also perform analysis
of OpenMP directives.
In this release, when Static Verifier is enabled the linker is not invoked so
an executable or static/dynamic link library is not produced, object files that
were produced as a result of invocation of Static Verifier are not valid and
should not be used for generating of real executable or static/dynamic link libraries.
The current usage model is that Static Verifier is added as an alternate build
option to produce a diagnostic report.
For more information, please refer to the section on Building Applications > Error Handling > Handling Compile Time Errors > using Static Verification Diagnostic Options in the on-disk documentation.
When Static Verifier support is enabled within the IDE, the customary final build target (e.g. an executable image) is not created. As such, we recommend that a separate "Static Verification" configuration be created, by cloning the existing Debug (development) configuration, for use when static verification is desired.
The Intel Fortran Compiler supports many features that are new to the latest revision of the Fortran standard, Fortran 2003. Additional Fortran 2003 features will appear in future versions. Fortran 2003 features supported by the current compiler include:
Notes:
Please see the separate Installation Guide for information on installing the compiler and setting up the compiler environment.
In some cases, enabling run-time checks using the -check or -C option
may cause the compiler to issue diagnostics for the requested condition at
compile-time, if it can be diagnosed then. For example, an array bounds violation
with a constant subscript may result in a compile-time error if -check
bounds or -CB is specified.
.o files must be saved for debuggingStarting with Xcode 2.3, the Dwarf debugging information is stored in the
object (.o) files. These object files are accessed by debuggers
to obtain information related to the application being debugged and thus
must be available for symbolic debugging.
In cases where a program is compiled and linked in one command, such as:
ifort -g -o hello.exe hello.f90
the object files are generated by the compiler but deleted after the executable is created.
To make such an application debuggable, do the compilation and link separately, as follows:
ifort -c -g -o hello.o hello.f90
ifort -g -o hello.exe hello.o
An alternative is to use the -save-temps option, as follows:
ifort -g -o hello.exe -save-temps hello.f90
Use of -save-temps will keep the prevent the object files from
being deleted after linking.
When linking an application compiled with the Intel compiler, you may receive
numerous warnings from ld of the form:
ld: warning suggest use of -bind_at_load, as lazy binding may result
in errors or different symbols being used
symbol _fdim used from dynamic library /usr/lib/system/libmathCommon.A.dylib(single
module) not from earlier dynamic library libimf.dylib(fdim_stub.o)
[…]
This warning occurs for 16 symbols found in both libimf.dylib and libmathCommon.A.dyblib.
It happens only in the case where Intel libraries are linked dynamically
(the default); linking Intel libraries statically will not yield these
warnings. In cases we have evaluated, the symbols in question were
properly linked from libimf.dylib in the executable or dynamic
library being linked. These warning messages can be ignored.
You can use "otool -vH <executable>" to verify
which dynamic libraries the symbols are resolved from.
Library not loaded error when running applicationWhen running an application built with the Intel compiler, you may see an error of the form:
dyld:Library not loaded:libsvml.dylib
reason: image not found
This error occurs when the Intel dynamic libraries cannot be located. To resolve this, follow these steps:
Groups & files pane expand Executables. Info, and navigate to the Arguments dialog
box. DYLD_LIBRARY_PATH environment variable
to include the path /opt/intel/fc/10.1.xxx/lib If you did not register your compiler during installation, please do so at the Intel® Software Development Products Registration Center. Registration entitles you to free technical support, product updates and upgrades for the duration of the support term.
For information about how to find Technical Support, Product Updates, Users Forums, FAQs, tips and tricks, and other support information, please visit: http://www.intel.com/software/products/support/fmac.
Note: If your distributor provides technical support for this product, please contact them for support rather than Intel.
Go" button next to the "Product"
drop-down list.
Submit Issue" link in the left navigation bar.
Development Environment (tools,SDV,EAP)" from the "Product
Type" drop-down list.
Intel(R)
Fortran Compiler for
Mac OS* X" from the "Product Name"
drop-down list.
Note: Please notify your support representative prior to submitting source code where access needs to be restricted to certain countries to determine if this request can be accommodated.
Get the Intel Fortran Compiler's Package ID with the following command:
> ifort -V
and copy the "Package ID" (e.g. m_fc_x_10.1.xxx) from
the output into the corresponding Intel® Premier Support field.
Please include any other specific information that may be
relevant to helping us to reproduce and address your concern.
Please review <package ID>_README (e.g. m_fc_x_10.1.xxx_README),
available for download from Intel® Software Development Products Registration Center Product Downloads, to see which issues have been resolved in
the latest version of the compiler.
Compiler Error Source Reducer (CESR) is a set of utilities which are useful individually or collectively in gathering, reducing, pinpointing, protecting, documenting, and bundling test cases comprised of C/C++ or Fortran source code. It can be helpful if you have a large application for which you want to extract a small test case for submission to Intel® Premier Support. CESR can be downloaded from Intel® Software Development Products Registration Center Product Downloads. Select your product and in the version dropdown, select CESR. CESR is unsupported and should be considered experimental, but we welcome your feedback on it through Intel® Premier Support. CESR requires prior installation of Python* 2.2 or newer.
The Intel® Fortran Compiler includes extensive user’s guide and reference documentation. You can view the list of available documentation by locating and opening the file alias in the <install-dir> folder; the file alias is Intel(R) Fortran Compiler Documentation. (The alias target file is <install-dir>/doc/Doc_Index.html.)
You can gain a quick understanding of compiler operation by executing the procedures
in the Getting Started with the Intel(R) Fortran Compiler 10.1 for
Mac OS* X document.
You can view the getting started information by locating and opening
the file alias in the <install-dir> folder; the file alias is Getting
Started with the Intel(R) Fortran Compiler. (The alias target
file is <install-dir>/doc/Getting_Started.html.)
Information on Intel software development products is available at http://www.intel.com/software/products.
INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL(R) 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. UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.
Intel may make changes to specifications and product descriptions at any time, without notice. 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 information here is subject to change without notice. Do not finalize a design with this information.
The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.
Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.
Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or by visiting Intel's Web Site.
Celeron, Centrino, Intel, Intel logo, Intel386, Intel486, Intel Core, Itanium, MMX, Pentium, VTune, and Xeon are trademarks of Intel Corporation in the U.S. and other countries.
* Other names and brands may be claimed as the property of others.
Copyright (C) 2007, Intel Corporation. All Rights Reserved.