ifort

NAME

SYNOPSIS

options

Are zero or more compiler options.

fileN

Is a Fortran source file, assembly file, object file, object library, or other linkable file.

DESCRIPTION

The ifort command interprets input files by their filename suffix as follows:

*

Filenames with the suffix .f90 are interpreted as free-form Fortran 95/90 source files.

*

Filenames with the suffix .f, .for, or .ftn are interpreted as fixed-form Fortran source files.

*

Filenames with the suffix .fpp, .F, .FOR, .FTN, or .FPP are interpreted as fixed-form Fortran source files, which must be preprocessed by the fpp preprocessor before being compiled.

*

Filenames with the suffix .F90 are interpreted as free-form Fortran source files, which must be preprocessed by the fpp preprocessor before being compiled.

*

Filenames with the suffix .s are interpreted as assembler files and are passed to the assembler.

*

Filenames with the suffix .S are interpreted as assembler files and are preprocessed by the fpp preprocessor before being passed to the assembler.

*

Filenames with the suffix .a are interpreted as object libraries and are passed to ld(1).

*

Filenames with the suffix .o are interpreted as compiled object files and are passed to ld(1).

You can override some options specified on the command line by using the OPTIONS statement in your Fortran source program. An OPTIONS statement affects only the program unit in which the statement occurs. For more information, see the Intel(R) Fortran Language Reference.

Most language features are available on all supported systems. However, some language features are only available on certain processors or a certain operating system. Such language features are labeled within parentheses as follows:

i32

Means the feature is available on IA-32-based systems.

i32em

Means the feature is available on IA-32-based systems with Intel(R) Extended Memory 64 Technology (Intel(R) EM64T).

i64

Means the feature is available on Itanium(R)-based systems.

L*X

Means the feature is available on Linux* systems.

M*X32

Means the feature is available on Intel(R)-based systems running Mac OS*.

If a labeled feature is only available on one processor or one operating system, you will see the word [dq]only[dq] within the label. If no label appears, the language feature is available on all supported systems.  

Performance Enhancing Options

*

On IA-32-based systems (including those with Intel(R) EM64T): -ax<p>, -ftz, -ip, -ipo, -O[n], -openmp, -parallel, -prof-use, -tpp<n>, -x<p>.

*

On Itanium(R)-based systems: -fnsplit, -ftz, -ip, -ipo, -O[n], -openmp, -parallel, -prof-use, -tpp<n>.

Configuration and Indirect Files

An indirect file contains text that can be included on the ifort command line. Precede the filename with an at symbol (@) on the command line at the point where the options are to be inserted. For example, assume file double_size contains options [dq]-i8 -r8[dq] and file my_includes contains options [dq]-I/bld/inc -I/bld/headers[dq]. In this case, the following command line:

  ifort -O3 @double_size myprog.f90 @my_includes

passes [dq]-O3 -i8 -r8 myprog.f90 -I/bld/inc -I/bld/headers[dq] to the compiler.  

OPTIONS

For information on linker and load-time options, see ld(1).

For some options, you can (or must) specify additional information, such as a keyword, a directory, a file name, a number, and so forth. When this information is required, it is shown in angle brackets (<>); when it is optional, it is shown in square brackets ([]). For example, in option -align <keyword>, keyword is required; in option -unroll[n], n (a number) is optional.

The ifort command takes the following options:

-1

Tells the compiler to execute at least one iteration of DO loops (same as the -onetrip option). This option has the same effect as -f66.

-66

Enforces FORTRAN 66 semantics (same as the -f66 option).

-72

Specifies that the statement field of each fixed-form source line ends at column 72. This is the default.

-80

Specifies that the statement field of each fixed-form source line ends at column 80.

-132

Specifies that the statement field of each fixed-form source line ends at column 132 (same as the -extend_source option).

-align [keyword]

Tells the compiler how to align certain data items. The following are -align options:

*

-align all

Tells the compiler to add padding bytes whenever possible to obtain the natural alignment of data items in common blocks, derived types, and record structures. Specifies -align nocommons, -align dcommons, -align records, -align nosequence. This is the same as specifying -align with no keyword.

*

-align commons

Aligns all common block entities on natural boundaries up to 4 bytes, by adding padding bytes as needed. The default is -align nocommons, which adds no padding to common blocks.

*

-align dcommons

Aligns all common block entities on natural boundaries up to 8 bytes, by adding padding bytes as needed. If you specify any -std option or the -stand f90 or -stand f95 option, this option is ignored. The default is -align nodcommons, which adds no padding to common blocks.

*

-align none

Tells the compiler not to add padding bytes anywhere in common blocks or structures. This is the same as specifying -noalign. The default is to add no padding to common blocks but to add padding to structures.

*

-align norecords

Aligns components of derived types and fields within record structures on arbitrary byte boundaries with no padding. The default is -align records.

*

-align rec<n>byte

Aligns fields of records and components of derived types on the smaller of the size boundary specified or the boundary that will naturally align them. <n> can be 1, 2, 4, 8, or 16.

*

-align sequence

Aligns components of a derived type declared with the SEQUENCE statement (sequenced components) according to the alignment rules that are currently in use. The default alignment rules are to align unsequenced components on natural boundaries. The default is -align nosequence, which requests that sequenced components be packed regardless of any other alignment rules. If you specify any -std option or the -stand f90 or -stand f95 option, this option is ignored.

The defaults for -align are nocommons, nodcommons, records, and nosequence.

-allow nofpp_comments

Tells the compiler to disallow Fortran-style end-of-line comments on preprocessor lines. This means comment indicators have no special meaning.

This option can be useful when you want to have a Fortran directive as a define value. The default is -allow fpp_comments, which tells the compiler to recognize Fortran-style end-of-line comments on preprocessor lines.

-arch <keyword> (i32 and i32em)

Determines the version of the architecture for which the compiler generates instructions. The following are -arch options:

*

-arch pn1

Optimizes for the Intel(R) Pentium(R) processor.

*

-arch pn2

Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors.

*

-arch pn3

Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors. This is the same as specifying the -arch pn2 option.

*

-arch pn4

Optimizes for the Intel(R) Pentium(R) 4 processor. This is the default.

*

-arch SSE

Optimizes for Intel Pentium 4 processors with Streaming SIMD Extensions (SSE).

*

-arch SSE2

Optimizes for Intel Pentium 4 processors with Streaming SIMD Extensions 2 (SSE2).

The only options available on Intel(R) EM64T systems are -arch pn1, -arch pn2, -arch pn3, and -arch pn4.

-assume <keyword>

Tells the compiler to make certain assumptions. The following are -assume options:

*

-assume bscc

Tells the compiler to treat the backslash character (\) as a C-style control (escape) character syntax in character literals. The default is -assume nobscc, which tells the compiler to treat the backslash character as a normal character instead of a control character in character literals.

*

-assume buffered_io

Tells the compiler to accumulate records in a buffer. This sets the default for opening sequential output files to BUFFERED=[aq]YES[aq], which also occurs if the FORT_BUFFERED run-time environment variable is specified. The default is -assume nobuffered_io, which means that data will be immediately written to disk.

*

-assume byterecl

Specifies that the units for the OPEN statement RECL specifier (record length) value are in bytes for unformatted data files, not longwords (four-byte units). For formatted files, the RECL unit is always in bytes. The default is -assume nobyterecl.

INQUIRE returns RECL in bytes if the unit is not open. INQUIRE returns RECL in longwords if the file is open for unformatted data (and -assume byterecl is not specified); otherwise, it returns RECL in bytes.

*

-assume cc_omp

Enables conditional compilation as defined by the OpenMP Fortran API. That is, when !$space appears in free-form source or c$spaces appears in column 1 of fixed-form source, the rest of the line is accepted as a Fortran line. If -openmp is specified, the default is -assume cc_omp; otherwise, the default is -assume nocc_omp.

*

-assume dummy_aliases

Tells the compiler that dummy (formal) arguments to procedures share memory locations with other dummy arguments (aliases) or with variables shared through use association, host association, or common block use. These program semantics slow performance and do not strictly obey the Fortran 95/90 Standards. The default is -assume nodummy_aliases.

*

-assume minus0

Tells the compiler to use Fortran 95 standard semantics for the treatment of the IEEE* floating value -0.0 in the SIGN intrinsic, which distinguishes the difference between -0.0 and +0.0, and to write a value of -0.0 with a negative sign on formatted output.

The default is -assume nominus0, which tells the compiler to use Fortran 90/77 standard semantics in the SIGN intrinsic to treat -0.0 and +0.0 as 0.0, and to write a value of 0.0 with no sign on formatted output.

*

-assume none

Disables all the -assume options.

*

-assume noprotect_constants

Tells the compiler to pass a copy of a constant actual argument. This copy can be modified by the called routine, even though the Fortran standard prohibits such modification. The calling routine does not see any modification to the constant. The default is -assume protect_constants, which passes the constant actual argument. Any attempt to modify it results in an error.

*

-assume nosource_include

Tells the compiler to search the default directory for module files specified by a USE statement or source files specified by an INCLUDE statement. The default is -assume source_include, which tells the compiler to search the directory the source file is in for any INCLUDE files or modules.

*

-assume nounderscore

Tells the compiler not to append an underscore character to external user-defined names: the main program name, named common blocks, BLOCK DATA blocks, global data names in MODULEs, and names implicitly or explicitly declared EXTERNAL. The name of a blank (unnamed) common block remains _BLNK__, and Fortran intrinsic names are not affected. The default is -assume underscore.

*

-assume 2underscores

Tells the compiler to append two underscore characters to external user-defined names that contain an embedded underscore: the main program name, named common blocks, BLOCK DATA blocks, global data names in MODULEs, and names implicitly or explicitly declared EXTERNAL. The name of a blank (unnamed) common block remains _BLNK__, and Fortran intrinsic names are not affected. The default is -assume no2underscores.

This option does not affect external names that do not contain an embedded underscore. By default, the compiler only appends one underscore to those names.

*

-assume writeable-strings

Tells the compiler to put character constants into non-read-only memory. The default is -assume nowriteable-strings.

-auto

Causes all local, non-SAVEd variables to be allocated on the run-time stack (same as -automatic or -nosave). The default is -auto-scalar. However, if you specify -recursive or -openmp, the default is -automatic.

-auto-scalar

Causes allocation of scalar variables of intrinsic types INTEGER, REAL, COMPLEX, and LOGICAL to the run-time stack. This is the default. However, if you specify -recursive or -openmp, the default is -automatic.

You cannot specify -save, -auto, or -automatic with this option.

-autodouble

Makes default real and complex variables 8 bytes long. REAL declarations are treated as DOUBLE PRECISION (REAL(KIND=8)) and COMPLEX declarations are treated as DOUBLE COMPLEX (COMPLEX(KIND=8)). This option is the same as specifying -real_size 64 or -r8.

-automatic

Causes all local, non-SAVEd variables to be allocated on the run-time stack (same as -auto or -nosave). The default is -auto-scalar. However, if you specify -recursive or -openmp, the default is -automatic.

-ax<p> (i32 and i32em)

Generates processor-specific code if there is a performance benefit, while also generating generic IA-32 code. The characters K, W, N, B, P, and T denote the processor types (<p>). The following are -ax options:

*

-axK

Generates code for Intel Pentium III processors and compatible Intel processors.

*

-axW

Generates code for Intel Pentium 4 processors and compatible Intel processors.

*

-axN

Generates code for Intel Pentium 4 processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations.

*

-axB

Generates code for Intel Pentium M processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations.

*

-axP

Generates code for Intel(R) Core(TM) Duo processors, Intel(R) Core(TM) Solo processors, Intel(R) Pentium(R) 4 processors with Streaming SIMD Extensions 3, and compatible Intel processors with Streaming SIMD Extensions 3. This option also enables new optimizations in addition to Intel processor-specific optimizations.

*

-axT

Generates code for Intel(R) Core(TM)2 Duo processors, Intel(R) Core(TM)2 Extreme processors, and the Dual-Core Intel(R) Xeon(R) processor 5100 series.

The only options available on Intel(R) EM64T systems are -axW, -axP, and -axT. On Mac OS systems, the only valid option is -axP. On these systems, it is equivalent to -xP, which is the default and is always set.

You can use more than one of the -ax options by combining the characters that denote the processor type. For example, you can specify -axNB to generate code for Intel(R) Pentium(R) 4 processors and Intel Pentium M processors.

If you specify both the -ax and -x options, the generic code will only execute on processors compatible with the processor type specified by the -x option.

-B<dir>

Specifies a directory that can be used to find include files, libraries, and executables. The compiler uses <dir> as a prefix.

For include files, the <dir> is converted to -I/<dir>/include. This command is added to the front of the includes passed to the preprocessor.

For libraries, the <dir> is converted to -L/<dir>. This command is added to the front of the standard -L inclusions before system libraries are added.

For executables, if <dir> contains the name of a tool, such as ld or as, the compiler will use it instead of those found in the default directories.

The compiler looks for include files in <dir>/include while library files are looked for in <dir>.

-Bdynamic (L*X only)

Enables dynamic linking of libraries at run time. Smaller executables are created than with static linking.

-Bstatic (L*X only)

Enables static linking of a user-created library.

-c

Prevents linking. It causes the compiler to compile to an object (.o) file only.

-C

Enables all checks on run-time conditions (same as the -check all option).

-CB

Performs run-time checks on whether array subscript and substring references are within declared bounds (same as the -check bounds option).

-ccdefault <keyword>

Specifies the type of carriage control used when a file is displayed at a terminal screen (units 6 and *). The following are -ccdefault options:

*

-ccdefault default

Specifies that the compiler is to use the default carriage-control setting. This is the default.

The default setting can be affected by the -vms option: if [dq]-vms -ccdefault default[dq] is specified, carriage control defaults to FORTRAN if the file is formatted, and the unit is connected to a terminal; if [dq]-novms -ccdefault default[dq] is specified, carriage control defaults to LIST.

*

-ccdefault fortran

Specifies normal Fortran interpretation of the first character.

*

-ccdefault list

Specifies one line feed between records.

*

-ccdefault none

Specifies no carriage control processing.

-check [keyword]

Checks for certain conditions at run time. The following are -check options:

*

-check all

Enables all -check options. This is the same as specifying -check with no keyword.

*

-check arg_temp_created

Generates code to check if actual arguments are copied into temporary storage before routine calls. If a copy is made at run time, an informative message is displayed. The default is -check noarg_temp_created.

*

-check bounds

Performs run-time checks on whether array subscript and substring references are within declared bounds. The default is -check nobounds.

*

-check format

Issues the run-time FORVARMIS fatal error when the data type of an item being formatted for output does not match the format descriptor being used (for example, a REAL*4 item formatted with an I edit descriptor). If -vms is specified, the default is -check format; otherwise, the default is -check noformat.

With -check noformat, the data item is formatted using the specified descriptor unless the length of the item cannot accommodate the descriptor (for example, it is still an error to pass an INTEGER*2 item to an E edit descriptor).

*

-check none

Disables all -check options. This is the default. This is the same as specifying -nocheck.

*

-check output_conversion

Issues the run-time OUTCONERR continuable error message when a data item is too large to fit in a designated format descriptor field. The field is filled with asterisks (*) and execution continues. If -vms is specified, the default is -check output_conversion; otherwise, the default is -check nooutput_conversion.

*

-check uninit

Generates code to check for uninitialized variables. If a variable is read before written, a run-time error routine will be called. The default is -check nounit.

To get more detailed location information about where the error occurred, use -traceback.

-cm

Suppresses all messages about questionable programming practices (same as the -warn nousage option).

-common-args

Tells the compiler that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with variables shared through use association, host association, or common block use. This is the same as specifying -assume dummy_aliases.

-complex-limited-range

Enables the use of basic algebraic expansions of some arithmetic operations involving data of type COMPLEX. This can cause some performance improvements in programs that use a lot of COMPLEX arithmetic, but values at the extremes of the exponent range may not compute correctly. The default is -no-complex-limited-range, which disables this option.

-convert <keyword>

Specifies the format for unformatted files containing numeric data. The following are -convert options:

*

-convert big_endian

Specifies that the format will be big endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and big endian IEEE floating-point for REAL*4, REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32.

*

-convert cray

Specifies that the format will be big endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and CRAY* floating-point for REAL*8 or COMPLEX*16.

*

-convert fdx

Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, D_floating for REAL*8 or COMPLEX*16, and X_floating for REAL*16 or COMPLEX*32.

*

-convert fgx

Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, G_floating for REAL*8 or COMPLEX*16, and X_floating for REAL*16 or COMPLEX*32.

*

-convert ibm

Specifies that the format will be big endian for INTEGER*1, INTEGER*2, or INTEGER*4, and IBM* System\370 floating-point format for REAL*4 or COMPLEX*8 (IBM short 4) and REAL*8 or COMPLEX*16 (IBM long 8).

*

-convert little_endian

Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and little endian IEEE floating-point for REAL*4, REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32.

*

-convert native

Specifies that unformatted data should not be converted. This is the default.

*

-convert vaxd

Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, D_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32.

*

-convert vaxg

Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, G_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32.

-cpp

Runs the Fortran preprocessor on source files prior to compilation (same as the -fpp option).

-cxxlib[-<mode>]

Tells the compiler to link using certain C++ run-time libraries. The following are -cxxlib <mode>s:

*

gcc[=<dir>]

Tells the compiler to link using the C++ run-time libraries provided with the gcc compiler. <dir> is an optional top-level location for the gcc binaries and libraries.

*

icc

Tells the compiler to link using the C++ run-time libraries provided by Intel. -cxxlib-icc is only available on IA-32 and Itanium(R)-based Linux systems.

If you specify the option with no <mode>, the compiler uses the default C++ libraries.

The default on Mac OS systems is -cxxlib-gcc. The default on Linux systems is -no-cxxlib, which tells the compiler to use the default run-time libraries and not link to any additional C++ run-time libraries. This is the same as specifying -no-cpprt.

-D<name>[=<value>]

Specifies <name> as a definition (symbol) to use with conditional compilation directives or the Fortran preprocessor (-fpp). <value> can be an integer or it can be a character string delimited by double quotes; for example, -Dname=[dq]string[dq]. If <value> is not specified, <name> is defined as [dq]1[dq].

-DD

Compiles debug statements (indicated by D in column 1); this is the same as specifying -d_lines.

-d_lines

Compiles debug statements (indicated by D in column 1); this is the same as specifying -DD. The default is -nod_lines.

-debug [keyword] (L*X only)

Specifies settings that enhance debugging. The following are -debug options:

*

-debug inline_debug_info

Produces enhanced debug information for inlined code. It provides more information to debuggers for function call traceback. The default is -debug noinline_debug_info.

*

-debug semantic_stepping

Produces enhanced debug information useful for breakpoints and stepping. It tells the debugger to stop only at machine instructions that achieve the final effect of a source statement. For example, in the case of an assignment statement, this might be a store instruction that assigns a value to a program variable; for a function call, it might be the machine instruction that executes the call. Other instructions generated for those source statements are not displayed during stepping. The default is -debug nosemantic_stepping.

*

-debug variable_locations

Produces enhanced debug information useful in finding scalar local variables. It uses a feature of the Dwarf object module known as [dq]location lists[dq]. This feature allows the run-time locations of local scalar variables to be specified more accurately; that is, whether, at a given position in the code, a variable value is found in memory or a machine register. The default is -debug novariable_locations.

*

-debug extended

Sets the debug options semantic_stepping and variable_locations.

-debug-parameters [keyword]

Tells the compiler to generate debug information for PARAMETERs used in a program. The following are -debug-parameters options:

*

-debug-parameters none

Generates no debug information for any PARAMETERs used in the program. This is the default; it is the same as specifying -nodebug-parameters.

*

-debug-parameters used

Generates debug information for only PARAMETERs that have actually been referenced in the program. This is the same as specifying -debug-parameters with no keyword.

*

-debug-parameters all

Generates debug information for all PARAMETERs defined in the program.

Note that if a .mod file contains PARAMETERs, debug information is only generated for the PARAMETERs that have actually been referenced in the program, even if you specify -debug-parameters all.

-double_size <size>

Defines the default KIND for DOUBLE PRECISION and DOUBLE COMPLEX declarations, constants, functions, and intrinsics. <size> can be 64 (KIND=8) or 128 (KIND=16). The default is -double_size 64.

-dryrun

Tells the driver that tool commands should be shown but not executed. See also -v.

-dynamic-linker<file> (L*X only)

Specifies a dynamic linker (<file>) other than the default.

-dynamiclib (M*X32 only)

Invokes the libtool command to generate dynamic libraries. When passed this option, GCC on Mac OS uses the libtool command to produce a dynamic library instead of an executable when linking.

To build static libraries, you should use [dq]libtool -static <objects>[dq].

-dyncom "common1,common2,common3"

Enables dynamic allocation of the specified COMMON blocks at run time. The quotes must be present.

-E

Causes the Fortran preprocessor to send output to stdout.

-e90

Causes the compiler to issue errors instead of warnings for nonstandard Fortran 90 (same as the -warn stderrors option). No such errors or warnings are issued by default.

-e95

Causes the compiler to issue errors instead of warnings for nonstandard Fortran (same as the -warn stderrors option). No such errors or warnings are issued by default.

-EP

Causes the Fortran preprocessor to send output to stdout, omitting #line directives.

-error_limit <n>

Specifies the maximum number of error-level or fatal-level compiler errors allowed for a file specified on the command line. If you specify -noerror_limit, there is no limit to the number of errors that are allowed. The default is -error_limit 30 (a maximum of 30 error-level and fatal-level messages before the compiler stops the compilation).

-extend_source [size]

Specifies the column number to use to end the statement field in fixed-form source files. [size] can be 72, 80, or 132. The default behavior is -noextend_source, which implies column 72. If you do not specify size, it is the same as specifying -extend_source 132.

-F

Causes the Fortran preprocessor to send output to a file (same as the -preprocess_only and -P options). Note that the source file is not compiled.

-f66

Tells the compiler to apply FORTRAN 66 semantics: the execution of at least one iteration of DO loops, different EXTERNAL statement syntax and semantics, and different behavior of the BLANK= and STATUS= specifiers on the OPEN statement. This is the same as specifying the -66 option. By default, the compiler applies Fortran 95 semantics.

-f77rtl

Tells the compiler to use the run-time behavior of Fortran 77 instead of Intel(R) Fortran. This affects some INQUIRE specifiers when the unit is not connected to a file, PAD= defaults to [aq]NO[aq] for formatted input, NAMELIST input format is different, and NAMELIST and list-directed input of character strings must be delimited by apostrophes or quotes. The default is -nof77rtl.

-fast

Maximizes speed across the entire program. On Itanium(R)-based systems, this option sets options -ipo, -O3, and -static. On IA-32 and Intel(R) EM64T systems, this option sets options -ipo, -O3, -no-prec-div, -static, and -xP.

Note that programs compiled with the -xP option will detect non-compatible processors and generate an error message during execution.

-fcode-asm

Produces an assembly file with optional machine code annotations. To use this option, you must also specify -S.

-fexceptions

Enables C++ exception handling table generation, preventing Fortran routines in mixed-language applications from interfering with exception handling between C++ routines. The default is -fno-exceptions, which disables C++ exception handling table generation, resulting in smaller code. When this option is used, any use of C++ exception handling constructs (such as try blocks and throw statements) when a Fortran routine is in the call chain will produce an error.

-FI

Specifies source files are in fixed format (same as the -fixed option).

-finline-limit=<n>

Lets you specify the maximum size of a function to be inlined. n must be an integer greater than or equal to zero. It is the maximum number of lines the function can have to be considered for inlining.

The compiler inlines smaller functions, but this option lets you inline large functions. For example, to indicate a large function, you could specify 100 or 1000 for n.

-fixed

Specifies source files are in fixed format. By default, source file format is determined by the file suffix.

-fltconsistency

Enables improved floating-point consistency. Floating-point operations are not reordered and the result of each floating-point operation is stored in the target variable rather than being kept in the floating-point processor for use in a subsequent calculation. This is the same as specifying -mp or -mieee-fp.

The default, -nofltconsistency, provides better accuracy and run-time performance at the expense of less consistent floating-point results.

-fmath-errno

Tells the compiler to assume that the program tests errno after calls to math library functions. This restricts optimization because it causes the compiler to treat most math functions as having side effects.

The default, -fno-math-errno, tells the compiler to assume that the program does not test errno after calls to math library functions. This frequently allows the compiler to generate faster code. Floating-point code that relies on IEEE exceptions instead of errno to detect errors can safely use this option to improve performance.

-fminshared

Specifies that a compilation unit is a component of a main program and will not be linked as part of a shareable object.

-fno-alias

Specifies that aliasing should not be assumed in the program. The default is -falias.

-fno-fnalias

Specifies that aliasing should not be assumed within functions, but should be assumed across calls. The default is -ffnalias.

-fno-inline-functions

Disables certain interprocedural optimizations for single file compilation. The default is -finline-functions, which tells the compiler to perform inline function expansion for calls to functions defined within the current source file.

-fno-omit-frame-pointer (i32 and i32em)

Disables use of EBP as a general purpose register so it can be used as a stack frame pointer. This is the same as specifying -fp. The default, -fomit-frame-pointer, enables EBP to be used as a general purpose register.

-fnsplit (i64 only; L*X only)

Enables function splitting if -prof-use is also specified. Otherwise, the default is -no-fnsplit, which disables the splitting within a routine but leaves function grouping enabled.

-fp (i32 and i32em)

Disables use of EBP as a general purpose register so it can be used as a stack frame pointer. By default, EBP is used as a general purpose register. This is the same as specifying -fno-omit-frame-pointer.

-fpconstant

Tells the compiler to extend the precision to double precision for single-precision constants assigned to double-precision variables. The default is -nofpconstant.

-fpe<n>

Specifies floating-point exception handling for the main program at run-time. You can specify one of the following values for <n>:

0 - Floating-point invalid, divide-by-zero, and overflow exceptions are enabled. If any such exceptions occur, execution is aborted. Underflow results will be set to zero unless you explicitly specify -no-ftz. On Itanium(R)-based systems, underflow behavior is equivalent to specifying option -ftz. On IA-32 or Intel(R) EM64T systems, underflow results from SSE instructions, as well as x87 instructions, will be set to zero. By contrast, option -ftz only sets SSE underflow results to zero.

To get more detailed location information about where the error occurred, use -traceback.

1 - All floating-point exceptions are disabled. Underflow results will be set to zero unless you explicitly specify -no-ftz.

3 - All floating-point exceptions are disabled. Floating-point underflow is gradual, unless you explicitly specify a compiler option that enables flush-to-zero. This is the default; it provides full IEEE support. (Also see -ftz.)

-fpic (L*X only)

Generates position-independent code. On IA-32 systems and Intel(R) EM64T systems, this option must be used when building shared objects. This option can also be specified as -fPIC. The default is -fno-pic.

-fp-model <keyword>

Controls the semantics of floating-point calculations. The following are -fp-model options:

*

-fp-model precise

Enables value-safe optimizations on floating-point data and rounds intermediate results to source-defined precision. Disables optimizations that can change the result of floating-point calculations, which is required for strict ANSI conformance. These semantics ensure the accuracy of floating-point computations, but they may slow performance.

Floating-point exception semantics are disabled by default.

This option is equivalent to -fp-model source.

*

-fp-model fast[=1|2]

Enables more aggressive optimizations when implementing floating-point calculations. These optimizations increase speed, but may alter the accuracy of floating-point computations.

Specifying fast is the same as specifying fast=1. fast=2 may produce faster and less accurate results.

Floating-point exception semantics are disabled by default and they cannot be enabled.

*

-fp-model strict

Enables precise and except. This is the strictest floating-point model.

*

-fp-model source

Enables value-safe optimizations on floating-point data and rounds intermediate results to source-defined precision. This option is equivalent to -fp-model precise.

*

-fp-model [no-]except

Determines whether floating-point exception semantics are used. Floating-point exception semantics are enabled if -fp-model except is specified; they are disabled if -fp-model no-except is specified.

The default is -fp-model fast=1. However, if you specify -O0, the default is -fltconsistency.

The keywords can be considered in groups:

*

Group A: source, precise, fast, strict

*

Group B: except or no-except

You can use more than one keyword. However, the following rules apply:

*

You cannot specify fast and except together in the same compilation. You can specify any other combination of group A and group B.

Since fast is the default, you must not specify except without a group A keyword.

*

You should specify only one keyword from group A. If you try to specify more than one keyword from group A, the last (rightmost) one takes effect.

*

If you specify except more than once, the last (rightmost) one takes effect.

.BR -fpp

Runs the Fortran preprocessor on source files prior to compilation.

-fpscomp [keyword]

Specifies the compatibility with Microsoft* Fortran PowerStation or Intel Fortran. The following are -fpscomp options:

*

-fpscomp all

Specifies that all options should be used for Fortran PowerStation compatibility. This is the same as specifying -fpscomp with no keyword. The default is -fpscomp libs.

*

-fpscomp filesfromcmd

Specifies that Fortran PowerStation behavior is used when the OPEN file specifier is blank. The default is -fpscomp nofilesfromcmd.

*

-fpscomp general

Specifies that Fortran PowerStation semantics are used when differences exist with Intel Fortran. The default is -fpscomp nogeneral.

*

-fpscomp ioformat

Specifies that Fortran PowerStation semantics and record format for list-directed formatted and unformatted I/O should be used. The default is -fpscomp noioformat.

*

-fpscomp ldio_spacing

Specifies that a blank should not be inserted after a numeric value before a character value (undelimited character string). This representation is used by Intel Fortran releases before Version 8.0 and by Fortran PowerStation. If you specify -fpscomp general, it sets -fpscomp ldio_spacing.

The default is -fpscomp noldio_spacing, which conforms to the Fortran 95 standard by inserting a blank after a numeric value before a character value.

*

-fpscomp nolibs

Prevents the portability library from being passed to the linker. The default is -fpscomp libs.

*

-fpscomp logicals

Specifies that the integer values 1 and 0 are used to represent the LOGICAL values .TRUE. and .FALSE. respectively. This representation is used by Intel Fortran releases before Version 8.0 and by Fortran PowerStation.

The default is -fpscomp nologicals, which specifies that odd integer values are treated as true and even integer values are treated as false; specifically .TRUE. and .FALSE. are -1 and 0 respectively. This representation is used by Compaq Visual Fortran.

*

-fpscomp none

Specifies that no options should be used for Fortran PowerStation compatibility. This is the same as specifying -nofpscomp.

-fpstkchk (i32 and i32em)

Generates extra code after every function call to ensure that the FP (floating-point) stack is in the expected state. By default, there is no checking. So when the FP stack overflows, a NaN value is put into FP calculations, and the results of the program differ. Unfortunately, the overflow point can be far away from the point of the actual bug. The -fpstkchk option places code that causes an access violation exception immediately after an incorrect call occurs, thus making it easier to locate these issues.

-FR

Specifies source files are in free format (same as the -free option).

-fr32 (i64 only; L*X only)

Disables use of high floating-point registers. Uses only the lower 32 floating-point registers.

-free

Specifies source files are in free format. By default, source file format is determined by the file suffix.

-fsource-asm

Produces an assembly file with optional source code annotations. To use this option, you must also specify -S.

-fsyntax-only

Specifies that the source file should be checked only for correct syntax (same as the -syntax-only, -y, and -syntax options).

-ftrapuv

Initializes stack local variables to an unusual value to aid error detection. Normally, these local variables should be initialized in the application.

The option sets any uninitialized local variables that are allocated on the stack to a value that is typically interpreted as a very large integer or an invalid address. References to these variables are then likely to cause run-time errors that can help you detect coding errors.

-ftz

Flushes denormal results to zero when the application is in the gradual underflow mode. It may improve performance if the denormal values are not critical to the behavior of your application. The default is -no-ftz.

The following options set the -ftz option: -fpe0, -fpe1, and on Itanium(R)-based systems, option -O3. Option -O2 sets the -no-ftz option.

Note: When SSE instructions are used on IA-32 systems, option -no-ftz is ignored. However, you can enable gradual underflow by calling a function in C in the main program that clears the FTZ and DAZ bits in the MXCSR or by calling the function for_set_fpe in the main program to clear those bits. Be aware that denormal processing can significantly slow down computation.

-funroll-loops

Tells the compiler to use default heuristics to unroll loops. This is the same as specifying -unroll.

-fverbose-asm

Produces an assembly file with compiler comments, including options and version information. To use this option, you must also specify -S, which sets -fverbose-asm. If you do not want this default when you specify -S, specify -fnoverbose-asm.

-fvisibility=<keyword>

-fvisibility-<keyword>=<file>

The first form specifies the default visibility for global symbols. The second form specifies the visibility for symbols that are in a file (for symbols specified in <file>, this form overrides the first form). <file> is the pathname of a file containing the list of symbols whose visibility you want to set; the symbols are separated by whitespace (spaces, tabs, or newlines). <keyword> specifies the visibility setting; it can be any of the following:

default - This setting means other components can reference the symbol, and the symbol definition can be overridden (preempted) by a definition of the same name in another component.

extern - This setting means the symbol is treated as though it is defined in another component. It also means that the symbol can be overridden by a definition of the same name in another component. This setting only applies to functions.

hidden - This setting means other components cannot directly reference the symbol. However, its address might be passed to other components indirectly.

internal - This setting means the symbol cannot be referenced outside its defining component, either directly or indirectly.

protected - This setting means other components can reference the symbol, but it cannot be overridden by a definition of the same name in another component.

If this option is specified more than once on the command line, the last specification takes precedence over any others.

-g

Produces symbolic debug information in the object file. The compiler does not support the generation of debugging information in assemblable files. If you specify the -g option, the resulting object file will contain debugging information, but the assemblable file will not.

On IA-32 systems, specifying the -g or -O0 option automatically sets the -fp option.

-gen-interfaces

Tells the compiler to generate an interface block for each routine (that is, for each SUBROUTINE and FUNCTION statement) defined in the source file.

The compiler generates two files for each routine, a .mod file and a .f90 file, and places them in the current directory or in the directory specified by the include ( -I ) or -module option. The .f90 file is the text of the interface block; the .mod file is the interface block compiled into binary form. The default is -nogen-interfaces.

-help

Displays the list of compiler options.

-I<dir>

Specifies a directory to add to the include path, which is used to search for module files (USE statement) and include files (INCLUDE statement).

-i-dynamic

Causes Intel-provided libraries to be linked in dynamically. It is the opposite of -i-static.

-i-static

Causes Intel-provided libraries to be linked in statically. It is the opposite of -i-dynamic.

-i2

Makes default integer and logical variables 2 bytes long (same as the -integer_size 16 option). The default is -integer_size 32.

-i4

Makes default integer and logical variables 4 bytes long (same as the -integer_size 32 option). This is the default.

-i8

Makes default integer and logical variables 8 bytes long (same as the -integer_size 64 option). The default is -integer_size 32.

-implicitnone

Sets the default type of a variable to undefined (IMPLICIT NONE). This is the same as specifying the -u option.

-inline-debug-info (L*X only)

Produces enhanced source position information for inlined code. This leads to greater accuracy when reporting the source location of any instruction. It also provides enhanced debug information useful for function call traceback. To use this option for debugging, you must also specify a debug enabling option, such as -g.

-inline-factor=<n>

Specifies the percentage multiplier that should be applied to all inlining options that define upper limits: -inline-max-size, -inline-max-total-size, -inline-max-per-routine, and  -inline-max-per-compile.

This option takes the default value for each of the above options and multiplies it by <n> divided by 100. For example, if 200 is specified, all inlining options that define upper limits are multiplied by a factor of 2.

<n> is a positive integer specifying the percentage value. The default value is 100 (a factor of 1).

If you specify -no-inline-factor, the following occurs:

*

Every function is considered to be a small or medium function; there are no large functions.

*

There is no limit to the size a routine may grow when inline expansion is performed.

*

There is no limit to the number of times some routine may be inlined into a particular routine.

*

There is no limit to the number of times inlining can be applied to a compilation unit.

-inline-forceinline

Specifies that an inline routine should be inlined whenever the compiler can do so. This causes the routines marked with an inline keyword or directive to be treated as if they were [dq]forceinline[dq].

-inline-max-per-compile=<n>

Specifies the maximum number of times inlining may be applied to an entire compilation unit. <n> is a positive integer that specifies the maximum number.

For compilations using Interprocedural Optimizations (IPO), the entire compilation is a compilation unit. For other compilations, a compilation unit is a file.

If you specify -no-inline-max-per-compile, there is no limit to the number of times inlining may be applied to a compilation unit.

-inline-max-per-routine=<n>

Specifies the maximum number of times the inliner may inline into a particular routine. <n> is a positive integer that specifies the maximum number.

If you specify -no-inline-max-per-routine, there is no limit to the number of times some routine may be inlined into a particular routine.

-inline-max-size=<n>

Specifies the lower limit for the size of what the inliner considers to be a large routine. It specifies the boundary between what the inliner considers to be medium and large-size routines. <n> is a positive integer that specifies the minimum size of a large routine.

The inliner prefers to inline small routines. It has a preference against inlining large routines. So, any large routine is highly unlikely to be inlined.

If you specify -no-inline-max-size, there are no large routines. Every routine is either a small or medium routine.

-inline-max-total-size=<n>

Specifies how much larger a routine can normally grow when inline expansion is performed. It limits the potential size of the routine. <n> is a positive integer that specifies the permitted increase in the size of the routine.

If you specify -no-inline-max-total-size, there is no limit to the size a routine may grow when inline expansion is performed.

-inline-min-size=<n>

Specifies the upper limit for the size of what the inliner considers to be a small routine. It specifies the boundary between what the inliner considers to be small and medium-size routines. <n> is a positive integer that specifies the maximum size of a small routine.

The inliner has a preference to inline small routines. So, when a routine is smaller than or equal to the specified size, it is very likely to be inlined.

If you specify -no-inline-min-size, there is no limit to the size of small routines. Every routine is a small routine; there are no medium or large routines.

-intconstant

Tells the compiler to use Fortran 77 semantics, rather than Fortran 95/90 semantics, to determine the KIND for integer constants. The default is -nointconstant.

-integer_size <size>

Defines the size of INTEGER and LOGICAL variables. <size> can be 16, 32, or 64. The default is -integer_size 32.

-ip

Enables additional interprocedural optimizations for single file compilation. One of these optimizations enables the compiler to perform inline function expansion for calls to functions defined within the current source file.

-ip-no-inlining

Disables full and partial inlining enabled by -ip or -ipo.

-ip-no-pinlining (i32 and i32em)

Disables partial inlining. To use this option, you must specify -ip or -ipo.

-IPF-flt-eval-method0 (i64 only; L*X only)

Tells the compiler to evaluate the expressions involving floating-point operands in the precision indicated by the variable types declared in the program. By default, intermediate floating-point expressions are maintained in higher precision.

-IPF-fltacc (i64 only; L*X only)

Disables optimizations that affect floating-point accuracy. If the default setting is used (-IPF-fltacc-), the compiler may apply optimizations that reduce floating-point accuracy. You can use -IPF-fltacc or -fltconsistency to improve floating-point accuracy, but at the cost of disabling some optimizations.

-IPF-fp-relaxed (i64 only; L*X only)

Enables use of faster but slightly less accurate code sequences for math functions, such as divide and sqrt. When compared to strict IEEE* precision, this option slightly reduces the accuracy of floating-point calculations performed by these functions, usually limited to the least significant digit.

This option also enables the performance of more aggressive floating-point transformations, which may affect accuracy.

-IPF-fp-speculation<mode> (i64 only; L*X only)

Tells the compiler to speculate on floating-point (FP) operations in one of the following <mode>s:

fast - Speculate on floating-point operations. This is the default.

safe - Speculate on floating-point operations only when safe.

strict - This is the same as specifying off.

off - Disables speculation of floating-point operations.

-ipo[n]

Enables multifile interprocedural (IP) optimizations (between files). When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files.

n is an optional integer that specifies the number of object files the compiler should create. Any integer greater than or equal to 0 is valid.

If n is 0, the compiler decides whether to create one or more object files based on an estimate of the size of the application. It generates one object file for small applications, and two or more object files for large applications.

If n is greater than 0, the compiler generates n object files, unless n exceeds the number of source files (m), in which case the compiler generates only m object files.

If you do not specify n, the default is 0.

-ipo-c

Tells the compiler to generate a multifile object file (ipo_out.o) that can be used in further link steps.

-ipo-S

Tells the compiler to generate a multifile assembly file (ipo_out.s) that can be used in further link steps.

-ipo-separate

Tells the compiler to generate one object file per source file. This option overrides any -ipo[n] specification.

-isystem<dir>

Specifies a directory (dir) to add to the start of the system include path. The compiler searches the specified directory for include files after it searches all directories specified by the -I compiler option but before it searches the standard system directories. This option is provided for compatibility with gcc.

-ivdep-parallel (i64 only; L*X only)

Tells the compiler that there is no loop-carried memory dependency in any loop following an IVDEP directive.

-Kpic (L*X only)

This is a deprecated option; it can also be specified as -KPIC. Use -fpic instead.

-L<dir>

Tells the linker to search for libraries in <dir> before searching the standard directories.

-l<string>

Tells the linker to search for a specified library (lib<string>) when linking.

Because the linker searches and processes libraries and object files in the order they are specified, you should specify this option following the last object file it applies to.

-logo

Displays the compiler version information (same as the -V option). The default is -nologo.

-lowercase

Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase (same as the -names lowercase option). This is the default.

-map-opts (L*X only)

Maps one or more Linux compiler options to their equivalent on a Windows system and outputs the result to stdout. The tool can be invoked from the compiler command line or it can be used directly. No compilation is performed when the option mapping tool is used. Compiler options are mapped to their equivalent on the architecture you are using.

-mcmodel=<mem_model> (i32em only; L*X only)

Tells the compiler to use a specific memory model to generate code and store data. This option can affect code size and performance.

You can specify one of the following values for <mem_model>:

*

small

Restricts code and data to the first 2GB of address space. All accesses of code and data can be done with Instruction Pointer (IP)-relative addressing. This is the default.

*

medium

Restricts code to the first 2GB; it places no memory restriction on data. Accesses of code can be done with IP-relative addressing, but accesses of data must be done with absolute addressing.

*

large

Places no memory restriction on code or data. All accesses of code and data must be done with absolute addressing.

If your program has COMMON blocks and local data with a total size smaller than 2GB, -mcmodel=small is sufficient. COMMONs larger than 2GB require -mcmodel=medium or -mcmodel=large. Allocation of memory larger than 2GB can be done with any setting of -mcmodel.

IP-relative addressing requires only 32 bits, whereas absolute addressing requires 64-bits. IP-relative addressing is somewhat faster. So, the small memory model has the least impact on performance.

Note: When the medium or large memory models are specified, you must also specify option -i-dynamic to ensure that the correct dynamic versions of the Intel run-time libraries are used.

When shared objects (.so files) are built, Position-Independent Code (PIC) is specified so that a single .so file can support all three memory models. The compiler driver adds option -fpic to implement the PIC.

However, you must specify a memory model for code that is to be placed in a static library or code that will be linked statically.

-mieee-fp

Enables improved floating-point consistency. Floating-point operations are not reordered and the result of each floating-point operation is stored in the target variable rather than being kept in the floating-point processor for use in a subsequent calculation. This is the same as specifying -fltconsistency or -mp.

The default, -mno-ieee-fp, provides better accuracy and run-time performance at the expense of less consistent floating-point results.

-mixed_str_len_arg

Tells the compiler that the hidden length passed for a character argument is to be placed immediately after its corresponding character argument in the argument list. The default is -nomixed_str_len_arg, which places the hidden lengths in sequential order at the end of the argument list.

-module <dir>

Specifies the directory <dir> where module (.mod) files should be placed when created and where they should be searched for (USE statement).

-mp

Maintains floating-point precision (while disabling some optimizations). The -mp option restricts optimization to maintain declared precision and to ensure that floating-point arithmetic conforms more closely to the ANSI* and IEEE standards. This is the same as specifying -fltconsistency or -mieee-fp.

For most programs, specifying this option adversely affects performance. If you are not sure whether your application needs this option, try compiling and running your program both with and without it to evaluate the effects on both performance and precision.

-mp1

Improves floating-point precision and consistency. This option disables fewer optimizations and has less impact on performance than -fltconsistency or -mp.

-mrelax (i64 only; L*X only)

Tells the compiler to pass linker option -relax to the linker. The default is -mno-relax.

-mtune=<processor>

Performs optimizations for a specified CPU.

On IA-32 systems, you can specify one of the following values for <processor>:

*

pentium

Optimizes for Intel(R) Pentium(R) processors.

*

pentiumpro

Optimizes for Intel(R) Pentium(R) Pro, Intel Pentium II, and Intel Pentium III processors.

*

pentium4

Optimizes for Intel Pentium 4 processors. This is the default.

*

pentium-mmx

Optimizes for Intel(R) Pentium(R) with MMX(TM) technology.

On Itanium(R)-based Linux systems, you can specify one of the following values for <processor>:

*

itanium

Optimizes for Intel(R) Itanium(R) processors.

*

itanium2

Optimizes for Intel(R) Itanium(R) 2 processors. This is the default.

*

itanium2-p9000

Optimizes for Dual-Core Intel(R) Itanium(R) 2 Processor 9000 Sequence processors. This option affects the order of the generated instructions, but the generated instructions are limited to Intel(R) Itanium(R) 2 processor instructions unless the program uses (executes) intrinsics specific to the Dual-Core Intel(R) Itanium(R) 2 Processor 9000 Sequence processors.

-names <keyword>

Specifies how source code identifiers and external names are interpreted. The following are -names options:

*

-names as_is

Causes the compiler to distinguish case differences in identifiers and to preserve the case of external names.

*

-names lowercase

Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase. This is the default.

*

-names uppercase

Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase.

-nbs

Tells the compiler to treat a backslash (\) as a normal character in character literals, not an escape character (same as the -assume nobscc option). This is the default.

-no-ansi-alias

Tells the compiler to assume the program does not adhere to the Fortran 95 Standard type aliasability rules. The default is -ansi-alias, which tells the compiler to assume that the program adheres to these aliasability rules.

-no-cpprt

Tells the compiler to use the default run-time libraries and not link to any additional C++ run-time libraries. This is the same as specifying -no-cxxlib.

-no-fp-port (i32 and i32em)

Tells the compiler to keep results of floating-point operations in higher precision. This provides better performance but less consistent floating-point results. The default is -fp-port, which rounds floating-point results after floating-point operations so rounding to user-declared precision occurs at assignments and type conversions. This has some impact on speed.

-no-global-hoist

Disables certain optimizations, such as load hoisting and speculative loads, that can move memory loads to a point earlier in the program execution than where they appear in the source.

This option is useful for some applications, such as those that use shared or dynamically mapped memory, which can fail if a load is moved too early in the execution stream (for example, before the memory is mapped).

In most cases, these optimizations are safe and can improve performance. The default, -global-hoist, enables these optimizations.

-no-IPF-fma (i64 only; L*X only)

Disables the combining of floating-point multiplies and add/subtract operations. It also disables the contraction of floating-point multiply and add/subtract operations into a single operation. The default is -IPF-fma, which tells the compiler to combine and contract these operations whenever possible. However, if you specify -mp and do not explicitly specify -IPF-fma, the default is -no-IPF-fma.

-no-prec-div (i32 and i32em)

Enables optimizations that give slightly less precise results than full IEEE division. With some optimizations, such as -xN and -xB, the compiler may change floating-point division computations into multiplication by the reciprocal of the denominator. For example, A/B is computed as A * (1/B) to improve the speed of the computation.

The default is -prec-div, which provides fully precise IEEE division. It improves precision of floating-point divides by disabling floating-point division-to-multiplication optimizations, resulting in greater accuracy with some loss of performance.

-no-prefetch (i64 only; L*X only)

Disables prefetch insertion optimization. To use this option, you must also specify -O3. The default is -prefetch.

-noalign

Prevents the alignment of data items. This is the same as specifying -align none. The default is -align.

-noaltparam

Specifies that the alternate form of parameter constant declarations (without parentheses) should not be recognized (same as the -nodps option). This form has no parentheses surrounding the list, and the form of the constant, rather than implicit or explicit typing, determines the data type of the variable. The default is -altparam.

-nobss-init

Places any variables that are explicitly initialized with zeros in the DATA section. By default, variables explicitly initialized with zeros are placed in the BSS section.

-nodefaultlibs

Prevents the compiler from using standard libraries when linking.

-nodefine

Specifies that all preprocessor definitions apply only to -fpp and not to Intel Fortran conditional compilation directives. This is the same as specifying -noD.

-nodps

Specifies that the alternate form of parameter constant declarations (without parentheses) should not be recognized (same as the -noaltparam option). The default is -dps.

-nofor_main

Specifies the main program is not written in Fortran, and prevents the compiler from linking for_main.o into applications. The default is -for_main.

-noinclude

Prevents the compiler from searching in /usr/include for files specified in an INCLUDE statement. You can specify the -I<dir> option along with this option. This option does not affect the fpp preprocessor behavior, and is not related to the Fortran 95/90 USE statement.

-nostartfiles

Prevents the compiler from using standard startup files when linking.

-nostdinc

Removes standard directories from the include file search path (same as the -X option).

-nostdlib

Prevents the compiler from using standard libraries and startup files when linking.

-nus

Prevents the compiler from appending an underscore character to external user-defined names. This option is the same as the -assume nounderscore option, and is the opposite of -us.

-o <file>

Specifies the name (<file>) for an output file as follows:

*

If -c is specified, it specifies the name of the generated object file.

*

If -S is specified, it specifies the name of the generated assembly listing file.

*

If -preprocess_only or -P is specified, it specifies the name of the generated preprocessor file.

Otherwise, -o specifies the name of the executable file.

-O0

Disables all -O<n> optimizations. On IA-32 and Intel(R) EM64T systems, this option sets the -fp option.

-O1

On IA-32 and Intel(R) EM64T systems, enables optimizations for speed. Also disables intrinsic recognition and the -fp option. This option is the same as the -O2 option.

On Itanium(R)-based systems, the -O1 option enables optimizations for server applications (straight-line and branch-like code with a flat profile). Enables optimizations for speed, while being aware of code size. For example, this option disables software pipelining and loop unrolling.

-O2 or -O

This option is the default for optimizations. However, if -g is specified, the default is -O0.

On Itanium(R)-based systems, the -O2 option enables optimizations for speed, including global code scheduling, software pipelining, predication, and speculation. It also enables:

*

Inlining of intrinsics

*

Intra-file interprocedural optimizations, which include: inlining, constant propagation, forward substitution, routine attribute propagation, variable address-taken analysis, dead static function elimination, and removal of unreferenced variables.

*

The following capabilities for performance gain: constant propagation, copy propagation, dead-code elimination, global register allocation, global instruction scheduling and control speculation, loop unrolling, optimized code selection, partial redundancy elimination, strength reduction/induction variable simplification, variable renaming, exception handling optimizations, tail recursions, peephole optimizations, structure assignment lowering and optimizations, and dead store elimination.

-O3

Enables -O2 optimizations plus more aggressive optimizations, such as prefetching, scalar replacement, and loop transformations. Enables optimizations for maximum speed, but does not guarantee higher performance unless loop and memory access transformations take place.

On IA-32 and Intel(R) EM64T systems, when the -O3 option is used with the -ax and -x options, it causes the compiler to perform more aggressive data dependency analysis than for -O2, which may result in longer compilation times.

On Itanium(R)-based systems, the -O3 option enables optimizations for technical computing applications (loop-intensive code): loop optimizations and data prefetch.

-Ob<n>

Specifies the level of inline function expansion. You can specify one of the following values for <n>:

0 - Disables inlining of user-defined functions. However, statement functions are always inlined. This is the default if -O0 is specified.

1 - Enables inlining when an inline keyword or an inline directive is specified.

2 - Enables inlining of any function at the discretion of the compiler. This is the default if option -O2 is specified or is in effect by default.

-onetrip

Tells the compiler to execute at least one iteration of DO loops (same as the -1 option). This option has the same effect as -f66.

-openmp

Enables the parallelizer to generate multithreaded code based on OpenMP* directives. The code can be executed in parallel on both uniprocessor and multiprocessor systems. The -openmp option works with both -O0 (no optimization) and any optimization level of -O<n>. Specifying -O0 with -openmp helps to debug OpenMP applications.

-openmp-profile (L*X only)

Enables analysis of OpenMP* applications. To use this option, you must have Intel(R) Thread Profiler installed, which is one of the Intel(R) Threading Tools. If this threading tool is not installed, this option has no effect.

-openmp-report[n]

Controls the level of diagnostic messages of the OpenMP parallelizer. You can specify one of the following values for [n]:

0 - Displays no diagnostic information.

1 - Displays diagnostics indicating loops, regions, and sections successfully parallelized. This is the default.

2 - Displays the diagnostics specified by -openmp-report1 plus diagnostics indicating successful handling of MASTER constructs, SINGLE constructs, CRITICAL constructs, ORDERED constructs, ATOMIC directives, etc.

-openmp-stubs

Enables compilation of OpenMP programs in sequential mode. The OpenMP directives are ignored and a stub OpenMP library is linked.

-opt-mem-bandwidth<n> (i64 only; L*X only)

Enables performance tuning and heuristics that control memory bandwidth use among processors. It allows the compiler to be less aggressive with optimizations that might consume more bandwidth, so that the bandwidth can be well-shared among multiple processors for a parallel program.

For values of <n> greater than 0, the option tells the compiler to enable a set of performance tuning and heuristics in compiler optimizations such as prefetching, privatization, aggressive code motion, and so forth, for reducing memory bandwidth pressure and balancing memory bandwidth traffic among threads.

<n> is the level of optimizing for memory bandwidth usage. You can specify one of the following values for <n>:

0 - Enables a set of performance tuning and heuristics in compiler optimizations that is optimal for serial code. This is the default for serial code.

1 - Enables a set of performance tuning and heuristics in compiler optimizations for multithreaded code generated by the compiler. This is the default if compiler option -parallel or -openmp is specified, or Cluster OpenMP option -cluster-openmp is specified (see the Cluster OpenMP documentation).

2 - Enables a set of performance tuning and heuristics in compiler optimizations for parallel code such as Windows Threads, pthreads, and MPI code, besides multithreaded code generated by the compiler.

-opt-report

Tells the compiler to generate an optimization report to stderr.

-opt-report-file<file>

Tells the compiler to generate an optimization report named <file>.

-opt-report-help

Displays the logical names of optimizer phases available for report generation (using -opt-report-phase).

-opt-report-level[level]

Specifies the detail level of the optimization report. [level] can be min, med, or max. The default is -opt-report-levelmin.

-opt-report-phase<phase>

Specifies the optimizer phase (<phase>) to generate reports for. This option can be used multiple times on the same command line to generate reports for multiple optimizer phases. Currently, the following optimizer phases are supported:

ipo - Interprocedural Optimizer

hlo - High Level Optimizer

ilo - Intermediate Language Scalar Optimizer

ecg - Code Generator (Itanium(R)-based systems only; Linux systems only)

ecg_swp - Software pipelining component of the Code Generator (Itanium(R)-based systems only; Linux systems only)

pgo - Profile Guided Optimization

all - All phases

When one of these logical names for optimizer phases is specified for <phase>, all reports from that optimizer phase are generated.

To use this option, you must also specify option -opt-report.

-opt-report-routine[string]

Generates a report on the routines containing the specified <string> as part of their name. If <string> is not specified, reports from all routines are generated.

-p

Compiles and links for function profiling with gprof(1). This is the same as specifying -pg or -qp, except that -pg is not available on Itanium(R)-based systems.

-P

Causes the Fortran preprocessor to send output to a file (same as the -preprocess_only and -F options). Note that the source file is not compiled.

-pad

Enables the changing of the variable and array memory layout. The default is -nopad.

-pad-source

Specifies that fixed-form source records shorter than the statement field width are to be padded with spaces (on the right) to the end of the statement field. This affects the interpretation of character and Hollerith literals that are continued across source records. The default is -nopad-source.

-par-report[n]

Controls the level of diagnostic messages of the auto-parallelizer. You can specify one of the following values for [n]:

0 - Displays no diagnostic information.

1 - Displays diagnostics indicating loops successfully auto-parallelized. This is the default. Issues a [dq]LOOP AUTO-PARALLELIZED[dq] message for parallel loops.

2 - Displays diagnostics indicating loops successfully auto-parallelized, as well as unsuccessful loops.

3 - Displays the diagnostics specified by -par-report2 plus additional information about any proven or assumed dependencies inhibiting auto-parallelization (reasons for not parallelizing).

-par-threshold[n]

Sets a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel. This option is used for loops whose computation work volume cannot be determined at compile-time. The threshold is usually relevant when the loop trip count is unknown at compile-time.

[n] is an integer from 0 to 100. The default value is 100.

The compiler applies a heuristic that tries to balance the overhead of creating multiple threads versus the amount of work available to be shared amongst the threads.

-parallel

Tells the auto-parallelizer to generate multithreaded code for loops that can be safely executed in parallel. To use this option, you must also specify -O2 or -O3.

-pc<n> (i32 and i32em)

Enables control of floating-point significand precision. Some floating-point algorithms are sensitive to the accuracy of the significand, or fractional part of the floating-point value. For example, iterative operations like division and finding the square root can run faster if you lower the precision with the -pc<n> option. You can specify one of the following values for <n>:

32 - Rounds the significand to 24 bits (single precision). Note that a change of the default precision control or rounding mode (for example, by using the -pc32 option or by user intervention) may affect the results returned by some of the mathematical functions.

64 - Rounds the significand to 53 bits (double precision).

80 - Rounds the significand to 64 bits (extended precision). This is the default.

-pg (i32 and i32em)

Compiles and links for function profiling with gprof(1). This is the same as specifying -p or -qp, except that they are also available on Itanium(R)-based systems.

-prec-sqrt (i32 and i32em)

Improves precision of square root implementations; it has some speed impact. This option inhibits any optimizations that can adversely affect the precision of a square root computation. The result is fully precise square root implementations, with some loss of performance. This is the default setting if you specify -O0, -mp, or -mp1.

-preprocess_only

Causes the Fortran preprocessor to send output to a file (same as the -F and -P options). Note that the source file is not compiled.

-print-multi-lib

Prints information about where system libraries should be found, but no compilation occurs. It is provided for compatibility with gcc.

-prof-dir <dir>

Specifies a directory (<dir>) for profiling output files (*.dyn and *.dpi).

-prof-file <file>

Specifies a file name (<file>) for the profiling summary file.

-prof-format-32 (i32 and i64; L*X only)

Produces profile data with 32-bit counters; this option allows compatibility with earlier compilers. The default is to produce profile data with 64-bit counters to handle large numbers of events.

-prof-gen

Instruments a program for profiling.

-prof-gen-sampling (i32 only; L*X only)

Prepares application executables for hardware profiling (sampling) and causes the compiler to generate source code mapping information.

-prof-genx

Instruments a program for profiling and gathers extra information for code coverage tools.

-prof-use

Enables use of profiling information during optimization.

-Qinstall <dir>

Specifies the root directory (<dir>)where the compiler installation was performed. This option is useful if you want to use a different compiler or if you did not use the ifortvars shell script to set your environment variables.

-Qlocation,<string>,<dir>

Sets <dir> as the location of the tool specified by <string>.

-Qoption,<string>,<opts>

Passes options <opts> to the tool specified by <string>.

-qp

Compiles and links for function profiling with gprof(1). This is the same as specifying -p or -pg, except that -pg is not available on Itanium(R)-based systems.

-r8

Makes default real and complex variables 8 bytes long. REAL declarations are treated as DOUBLE PRECISION (REAL(KIND=8)) and COMPLEX declarations are treated as DOUBLE COMPLEX (COMPLEX(KIND=8)). This option is the same as specifying -real_size 64 or -autodouble.

-r16

Makes default real and complex variables 16 bytes long. REAL declarations are treated as extended precision REAL (REAL(KIND=16); COMPLEX and DOUBLE COMPLEX declarations are treated as extended precision COMPLEX (COMPLEX(KIND=16)). This option is the same as specifying -real_size 128.

-rcd (i32 and i32em)

Enables fast float-to-integer conversions. This option can improve the performance of code that requires floating-point-to-integer conversions. The system default floating-point rounding mode is round-to-nearest. However, the Fortran language requires floating-point values to be truncated when a conversion to an integer is involved. To do this, the compiler must change the rounding mode to truncation before each floating-point-to-integer conversion and change it back afterwards.

The -rcd option disables the change to truncation of the rounding mode for all floating-point calculations, including floating point-to-integer conversions. This option can improve performance, but floating-point conversions to integer will not conform to Fortran semantics.

-real_size <size>

Defines the size of REAL and COMPLEX declarations, constants, functions, and intrinsics. <size> can be 32, 64, or 128. The default is -real_size 32.

-recursive

Specifies that all routines should be compiled for possible recursive execution. This option sets the -auto option. The default is -norecursive.

-reentrancy [keyword]

Specifies that the compiler should generate reentrant code that supports a multithreaded application. The following are -reentrancy options:

*

-reentrancy async

Tells the run-time library (RTL) that the program may contain asynchronous (AST) handlers that could call the RTL. This causes the RTL to guard against AST interrupts inside its own critical regions.

*

-reentrancy none

Tells the run-time library (RTL) that the program does not rely on threaded or asynchronous reentrancy. The RTL will not guard against such interrupts inside its own critical regions. This is the default. This option is the same as the -noreentrancy option.

*

-reentrancy threaded

Tells the run-time library (RTL) that the program is multithreaded, such as programs using the POSIX threads library. This causes the RTL to use thread locking to guard its own critical regions. If you do not specify a keyword for -reentrancy, it is the same as specifying -reentrancy threaded.

-S

Causes the compiler to compile to an assembly file (.s) only and not link.

-safe-cray-ptr

Specifies that Cray pointers do not alias other variables.

-save

Places variables, except those declared as AUTOMATIC, in static memory (same as -noauto or -noautomatic). The default is -auto-scalar. However, if you specify -recursive or -openmp, the default is -automatic.

-scalar-rep (i32 only)

Enables scalar replacement performed during loop transformation. To use this option, you must also specify -O3. The default is -no-scalar-rep.

-shared (L*X only)

Tells the compiler to produce a dynamic shared object instead of an executable.

On IA-32 systems and Intel(R) EM64T systems, you must specify -fpic for the compilation of each object file you want to include in the shared library.

-shared-libcxa (L*X only)

Links the Intel libcxa C++ library dynamically, overriding the default behavior when -static is used. This option is the opposite of -static-libcxa.

-sox

Tells the compiler to save the compiler options and version number in the executable. The default is -no-sox.

-ssp (i32 only; L*X only)

Enables Software-based Speculative Pre-computation (SSP), which is also called Helper-Threading optimization. It provides a way to dynamically prefetch data cache blocks to counterbalance ever-increasing memory latency. It exploits the properties of source code constructs (such as delinquent loads and pointer-chasing loops) in applications.

-stand [keyword]

Causes the compiler to issue compile-time messages for nonstandard language elements. The following are -stand options:

*

-stand f90

Causes the compiler to issue messages for language elements that are not standard in Fortran 90 (same as the -std90 option).

*

-stand f95

Causes the compiler to issue messages for language elements that are not standard in Fortran 95 (same as the -std95 or -std options). This option is set if you specify -warn stderrors. If you do not specify a keyword for -stand, it is the same as specifying -stand 95.

*

-stand none

Causes the compiler to issue no messages for nonstandard language elements. This is the same as specifying -nostand. This is the default.

-static (L*X only)

Prevents linking with shared libraries. Causes the executable to link all libraries statically.

-static-libcxa (L*X only)

Links the Intel libcxa C++ library statically. This option is the opposite of -shared-libcxa.

-std90

Causes the compiler to issue messages for language elements that are not standard in Fortran 90 (same as the -stand f90 option).

-std95 or -std

Causes the compiler to issue messages for language elements that are not standard in Fortran 95 (same as the -stand f95 option). This option is set if you specify -warn stderrors.

-syntax-only

Specifies that the source file should be checked only for correct syntax (same as the -fsyntax-only, -y, and -syntax options). No code is generated, no object file is produced, and some error checking done by the optimizer is bypassed. This option lets you do a quick syntax check of your source file.

-T <file> (L*X only)

Tells the linker to read link commands from the specified <file>.

-tcheck (L*X only)

Enables analysis of threaded applications. To use this option, you must have Intel(R) Thread Checker installed, which is one of the Intel(R) Threading Tools.

-Tf <file>

Specifies that <file> should be compiled as a Fortran source file. This option is useful when you have a file with a nonstandard filename suffix.

This option assumes the file specified uses fixed source form. If the file uses free source form, you must also specify option -free.

-threads

Specifies that multithreaded libraries should be linked. This is the default on Intel(R) EM64T systems. This option sets the -reentrancy threaded option. On IA-32 and Intel(R) Itanium(R) systems, the default is -nothreads.

-tpp1 (i64 only; L*X only)

Optimizes for the Intel(R) Itanium(R) processor.

-tpp2 (i64 only; L*X only)

Optimizes for the Intel(R) Itanium(R) 2 processor. This is the default on Itanium(R)-based systems.

-tpp5 (i32 only; L*X only)

Optimizes for the Intel(R) Pentium(R) processor.

-tpp6 (i32 only; L*X only)

Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II and Intel(R) Pentium(R) III processors.

-tpp7 (i32 and i32em; L*X only)

Optimizes for the Intel(R) Core(TM) Duo processors, Intel(R) Core(TM) Solo processors, Intel(R) Pentium(R) 4 processors, Intel(R) Xeon(R) processors, Intel Pentium M processors, and Intel Pentium 4 processors with Streaming SIMD Extensions 3 (SSE3) instruction support. This is the default on IA-32 systems and Intel(R) EM64T systems.

-traceback

Tells the compiler to generate extra information in the object file to allow the display of source file traceback information at run time when a severe error occurs. The default is -notraceback.

-tune <keyword> (i32 and i32em)

Determines the version of the architecture for which the compiler generates instructions. The following are -tune options:

*

-tune pn1

Optimizes for the Intel(R) Pentium(R) processor.

*

-tune pn2

Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors.

*

-tune pn3

Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors. This is the same as specifying the -tune pn2 option.

*

-tune pn4

Optimizes for the Intel(R) Pentium(R) 4 processor. This is the default.

The only option available on Intel(R) EM64T systems is -tune pn4.

-u

Sets the default type of a variable to undefined (IMPLICIT NONE). This is the same as specifying the -implicitnone option.

-U<name>

Removes the predefined macro named <name>.

-unroll[n]

Sets the maximum number of times to unroll loops. Use -unroll0 to disable loop unrolling. The default is -unroll, which tells the compiler to use default heuristics. This is the same as specifying -funroll-loops.

-uppercase

Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase (same as the -names uppercase option). The default is -lowercase (or -names lowercase).

-us

Tells the compiler to append an underscore character to external user-defined names (opposite of -nus). Specifying -us is the same as specifying the -assume underscore option.

-use-asm

Tells the compiler to produce objects through the assembler.

-v

Tells the driver that tool commands should be shown and executed. See also -dryrun.

-V

Displays the compiler version information (same as the -logo option).

-vec-report[n] (i32 and i32em)

Specifies the amount of vectorizer diagnostic information to report. You can specify one of the following values for [n]:

0 - Produces no diagnostic information.

1 - Indicates vectorized loops. This is the default.

2 - Indicates vectorized and non-vectorized loops.

3 - Indicates vectorized and non-vectorized loops and prohibiting data dependence information.

4 - Indicates non-vectorized loops.

5 - Indicates non-vectorized loops and prohibiting data dependence information.

-vms

Causes the run-time system to behave like HP* Fortran on OpenVMS* Alpha systems and VAX* systems (VAX FORTRAN*) in the following ways:

*

Modifies certain defaults

The -vms option sets the -check format and -check output_conversion options. You can override this by specifying the option on the command line. For example, if you specify -vms -check noformat, you get -check noformat.

*

Alignment

The -vms option does not affect the alignment of fields in records or items in COMMON. Use -align norecords to pack fields of records on the next byte boundary for compatibility with HP Fortran on OpenVMS systems.

*

INCLUDE qualifiers

/LIST and /NOLIST are recognized at the end of the file pathname in an INCLUDE statement at compile time.

If the file name in the INCLUDE statement does not specify the complete path, the path used is the current directory.

*

Quotation mark character ([dq])

A quotation mark is recognized as starting an octal constant (such as [dq]177) instead of a character literal ([dq]...[dq]).

*

Deleted records in relative files

When a record in a relative file is deleted, the first byte of that record is set to a known character (currently [aq]@[aq]). Attempts to read that record later result in ATTACCNON errors. The rest of the record (the whole record, if -vms is not specified) is set to nulls for unformatted files and spaces for formatted files.

*

ENDFILE records

When an ENDFILE is performed on a sequential unit, an actual one byte record containing a Ctrl/Z is written to the file. If -vms is not specified, an internal ENDFILE flag is set and the file is truncated.

The -vms option does not affect ENDFILE on relative files; such files are truncated.

*

Reading deleted records and ENDFILE records

The run-time direct access READ routine checks the first byte of the retrieved record. If this byte is [aq]@[aq] or NULL ("\0"), then ATTACCNON is returned.

The run-time sequential access READ routine checks to see if the record it just read is one byte long and contains a Ctrl/Z. If this is true, it returns EOF.

*

OPEN statement effects

Carriage control defaults to FORTRAN if the file is formatted, and the unit is connected to a terminal (checked by means of isatty(3)). Otherwise, carriage control defaults to LIST.

The -vms option affects the record length for direct access and relative organization files. The buffer size is increased by one (to accommodate the deleted record character).

*

Implied logical unit numbers

Certain environment variables are recognized at run time for ACCEPT, PRINT, and TYPE statements, and for READ and WRITE statements that do not specify a unit number, such as: READ (*,1000).

*

Treatment of blanks in input

The -vms option causes the defaults for keyword BLANK in OPEN statements to become [aq]NULL[aq] for an explicit OPEN, and [aq]ZERO[aq] for an implicit OPEN of an external or internal file.

*

Carriage control default

If -vms -ccdefault default is specified, carriage control defaults to FORTRAN if the file is formatted and the unit is connected to a terminal.

-w

Disables all warning messages (same as the -nowarn and -warn nogeneral options).

-W<n>

Disables warnings (n=0) or enables warnings (n=1). The default is -W1 (same as the -warn general option). -W0 is the same as specifying -warn nogeneral, -nowarn, or -w.

-Wa,<o1>[,<o2>,...]

Passes options <o1>, <o2>, and so forth, to the assembler for processing. If the assembler is not invoked, these options are ignored.

-warn [keyword]

Specifies the level of diagnostic messages issued by the compiler. The following are -warn options:

*

-warn all

Enables all warning messages. This is the same as specifying -warn with no keyword.

*

-warn none

Disables all warning messages. This is the same as specifying -nowarn.

*

-warn noalignments

Disables warnings for data that is not naturally aligned. The default is -warn alignments.

*

-warn declarations

Enables error messages about any undeclared symbols. This option makes the default data type of a variable undefined (IMPLICIT NONE) rather than using the implicit Fortran rules. The default is -warn nodeclarations.

*

-warn errors

Tells the compiler to change all warning-level messages into error-level messages. The default is -warn noerrors.

*

-warn nogeneral

Disables all information-level and warning-level messages. The default is -warn general.

*

-warn ignore_loc

Enables warnings when %LOC is stripped from an argument. The default is -warn noignore_loc.

*

-warn interfaces

Tells the compiler to check the interfaces of all SUBROUTINEs called and FUNCTIONs invoked in your compilation against a set of interface blocks stored separately from the source being compiled.

The compiler generates a compile-time message if the interface used to invoke a routine does not match the interface defined in a .mod file external to the source (that is, in a .mod generated by -gen-interfaces as opposed to a .mod file USEd in the source). The compiler looks for these .mods in the current directory or in the directory specified by the include ( -I ) or -module option. The default is -warn nointerfaces.

*

-warn stderrors

Tells the compiler to change warnings about Fortran standards violations into error messages. This option sets the -std95 option. If you want Fortran 90 standards violations to become errors, you should specify -warn stderrors and -std90. The default is -warn nostderrors.

*

-warn truncated_source

Enables warnings when source exceeds the maximum columm width in fixed-format source files. The default is -warn notruncated_source.

*

-warn uncalled

Enables warnings when a statement function is never called. The default is -warn nouncalled.

*

-warn unused

Enables warnings about variables that are declared but never used. The default is -warn nounused.

*

-warn nousage

Disables warnings about questionable programming practices. The default is -warn usage.

-watch [keyword]

Tells the compiler to display certain information to the console output window. The following are -watch options:

*

-watch all

Enables all -watch options. This is the same as specifying -watch with no keyword.

*

-watch cmd

Tells the compiler to display and execute driver tool commands. The default is -watch nocmd.

*

-watch source

Tells the compiler to display the name of the file being compiled. The default is -watch nosource.

*

-watch none

Disables all -watch options. This is the default. This is the same as specifying -nowatch.

-WB

Turns a compile-time bounds check into a warning. Normally, compile-time bounds checks are errors.

-what

Displays the version strings of the Fortran command and the compiler.

-Wl,<o1>[,<o2>,...]

Passes options <o1>, <o2>, and so forth, to the linker for processing. If the linker is not invoked, these options are ignored.

-Wp,<o1>[,<o2>,...]

Passes options <o1>, <o2>, and so forth, to the preprocessor. If the preprocessor is not invoked, these options are ignored.

-X

Removes standard directories from the include file search path (same as the -nostdinc option). You can use the -X option with the -I option to prevent the compiler from searching the default path for include files and direct it to use an alternate path.

-x<p> (i32 and i32em)

Generates specialized and optimized code for the processor that executes your program. The characters K, W, N, B, P, and T denote the processor types (<p>). The following are -x options:

*

-xK

Generates code for Intel Pentium III processors and compatible Intel processors.

*

-xW

Generates code for Intel Pentium 4 processors and compatible Intel processors.

*

-xN

Generates code for Intel Pentium 4 and compatible Intel processors with Streaming SIMD Extensions 2. The resulting code may contain unconditional use of features that are not supported on other processors.

This option also enables new optimizations in addition to Intel processor-specific optimizations including advanced data layout and code restructuring optimizations to improve memory accesses for Intel processors.

*

-xB

Generates code for Intel Pentium M processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations.

*

-xP

Generates code for Intel(R) Core(TM) Duo processors, Intel(R) Core(TM) Solo processors, Intel(R) Pentium(R) 4 processors with Streaming SIMD Extensions 3, and compatible Intel processors with Streaming SIMD Extensions 3. The resulting code may contain unconditional use of features that are not supported on other processors.

This option also enables new optimizations in addition to Intel processor-specific optimizations including advanced data layout and code restructuring optimizations to improve memory accesses for Intel processors.

*

-xT

Generates code for Intel(R) Core(TM)2 Duo processors, Intel(R) Core(TM)2 Extreme processors, and the Dual-Core Intel(R) Xeon(R) processor 5100 series.

This option also enables new optimizations in addition to Intel processor-specific optimizations including advanced data layout and code restructuring optimizations to improve memory accesses for Intel processors.

The only options available on Intel(R) EM64T systems are -xW, -xP, and -xT.

On Mac OS systems, the only valid option is -xP. On these systems, it is the default and is always set.

If you specify more than one processor value, code is generated for only the highest-performing processor specified. The highest-performing to lowest-performing processor values are: T, P, B, N, W, K.

Do not use these options if you are executing a program on a processor that is not an Intel(R) processor. If you use these options on a non-compatible processor to compile the main program, the program may fail with an illegal instruction exception or display other unexpected behavior.

In particular, such programs compiled with processor values N, B, or P will display a fatal run-time error if they are executed on unsupported processors. For more information, see your Optimizing Applications guide.

-Xlinker <value>

Passes <value> directly to the linker for processing.

-y

Specifies that the source file should be checked only for correct syntax (same as the -syntax-only, -fsyntax-only, and -syntax options).

-zero

Initializes to zero all local scalar variables of intrinsic type INTEGER, REAL, COMPLEX, or LOGICAL that are saved but not yet initialized. The default is -nozero. Use -save on the command line to make all local variables specifically marked as SAVE.

-Zp[n]

Aligns fields of records and components of derived types on the smaller of the size boundary specified or the boundary that will naturally align them (same as the -align rec<n>byte option). The [n] can be 1, 2, 4, 8, or 16. If you do not specify [n], you get -Zp16, which is the default.

EXAMPLES

The following examples demonstrate optimization and multiple input files:

1)

ifort ax.f90

This command compiles ax.f90 producing executable file a.out. Optimizations occur by default.

2)

ifort -o abc ax.f90 bx.f90 cx.f90 -ipo

This command uses option -o to name the executable file abc and compiles ax.f90, bx.f90, and cx.f90 as one program with interprocedural analysis.

3)

ifort -c ax.f90 bx.f90 cx.f90

This command uses option -c to suppress linking and produce individual object files ax.o, bx.o, and cx.o. Interprocedural optimizations are prevented.

4)

ifort -c -O1 sub2.f90
ifort -c -O1 sub3.f90
ifort -o main.exe -g -O0 main.f90 sub2.o sub3.o

The first two commands show incremental compilation with minimal optimization. The first command generates an object file for sub2; the second generates an object file for sub3.

The last command uses option -O0 to disable all compiler default optimizations. It uses option -g to generate symbolic debugging information and line numbers in the object code, which can be used by a source-level debugger.

RESTRICTIONS

For ifort, when multiple source files are compiled together without the -c option, the suffix of the first source file determines the default source form for the entire compilation.  

DIAGNOSTICS

PREDEFINED SYMBOLS

The following symbols are defined on all systems at the start of compilation:

__INTEL_COMPILER=910

__INTEL_COMPILER_BUILD_DATE=<YYYYMMDD>

__i386__ (i32 only)

__i386 (i32 only)

i386 (i32 only)

The following symbols are defined on Linux systems at the start of compilation:

__ELF__

__linux__

__linux

linux

__gnu_linux__

__unix__

__unix

unix

__ia64__ (i64 only)

__ia64 (i64 only)

ia64 (i64 only; deprecated)

__x86_64__ (i32em only)

__x86_64 (i32em only)

The following symbols are defined on Mac OS systems at the start of compilation:

__APPLE__

__MACH__

__PIC__

__pic__

The following symbols are defined on all systems during compilation if certain compiler options are specified:

_OPENMP=200505

Defined if option -openmp is specified.

_PGO_INSTRUMENT

Defined if option -prof-gen is specified.

ENVIRONMENT VARIABLES

Run-Time Environment Variables

Note that some environment variables are enabled (set to true) by specifying Y, y, T, t, or 1; they are disabled (set to false) by specifying N, n, F, f, or 0.

decfort_dump_flag

If set to true, a core dump will be taken when any severe Intel Fortran run-time error occurs. If the program is executing under a debugger, a signal will be raised, which will allow you to trace back to where the error was detected.

F_UFMTENDIAN

Lets you specify the numbers of the units to be used for little-endian-big-endian conversion purposes.

FOR_ACCEPT

Lets you specify a file to be read from when the ACCEPT statement is used.

FOR_DIAGNOSTIC_LOG_FILE

Lets you specify a file where diagnostic information should be written.

FOR_DISABLE_DIAGNOSTIC_DISPLAY

If set to true, disables the display of all error information.

FOR_DISABLE_STACK_TRACE

If set to true, disables the call stack trace information that follows the displayed severe error message text.

FOR_IGNORE_EXCEPTIONS

If set to true, disables the default run-time exception handling.

FOR_NOERROR_DIALOGS

If set to true, disables the display of dialog boxes when certain exceptions or errors occur.

FOR_PRINT

Lets you specify a file to be written to when the PRINT statement is used.

FOR_READ

Lets you specify a file to be read from when the READ statement is used.

FOR_TYPE

Lets you specify a file to be written to when the TYPE statement is used.

FORT_BUFFERED

If set to true, buffered I/O will be used at run time for output of all Fortran I/O units, except those with output to the terminal.

FORT_CONVERTn

Lets you specify the data format for an unformatted file associated with a particular unit number (n).

FORT_CONVERT.ext and FORT_CONVERT_ext

Lets you specify the data format for unformatted files with a particular file extension (ext).

FORTn

Lets you specify the file name for a particular unit number (n), when a file name is not specified in the OPEN statement or an implicit OPEN is used, and option -fpscomp filesfromcmd is not specified.

NLSPATH

Lets you specify the path for the Intel Fortran run-time error message catalog.

TBK_ENABLE_VERBOSE_STACK_TRACE

If set to true, displays more detailed call stack trace information in the event of an error.

TBK_FULL_SRC_FILE_SPEC

If set to true, displays complete file name information for traceback output, including the path.

TEMP, TMP, and TMPDIR

Lets you specify an alternate working directory where temporary files are created.

Compile-Time Environment Variables

FPATH

The path for include files.

IFORTCFG

The configuration file to use instead of the default configuration file.

LD_LIBRARY_PATH

The path for shared (.so) library files on Linux* systems.

DYLD_LIBRARY_PATH

The path for dynamic library files on Mac OS* systems.

PATH

The path for compiler executable files.

TMPDIR

The alternate working directory where scratch files are created.

INTEL_LICENSE_FILE

The path to the product license file.

Standard OpenMP Environment Variables

OMP_DYNAMIC

Enables (TRUE) or disables (FALSE) the dynamic adjustment of the number of threads. The default value is FALSE.

OMP_NESTED

Enables (TRUE) or disables (FALSE) nested parallelism. The default value is FALSE.

OMP_NUM_THREADS

Sets the number of threads to use during execution. The default is the number of processors currently installed in the system while generating the executable.

OMP_SCHEDULE

Specifies the type of run-time scheduling. The default is static scheduling.

Intel(R) Extensions to OpenMP Environment Variables

KMP_LIBRARY

Selects the OpenMP run-time library throughput. The options for the variable value are: serial, turnaround, or throughput indicating the execution mode. The default value is throughput.

KMP_STACKSIZE

Sets the number of bytes to allocate for each parallel thread to use as its private stack. Use the optional suffix b, k, m, g, or t, to specify bytes, kilobytes, megabytes, gigabytes, or terabytes. The default on IA-32 systems is 2m; the default on Intel(R) EM64T and Itanium(R)-based systems is 4m.

Profile Guided Optimization Environment Variables

PROF_DIR

Specifies the directory in which dynamic information files are created. This variable applies to all three phases of the profiling process.

PROF_DUMP_INTERVAL

Initiates Interval Profile Dumping in an instrumented application. Normally, the _PGOPTI_Set_Interval_Prof_Dump(int interval) function activates Interval Profile Dumping and sets the approximate frequency at which dumps will occur. The interval parameter is measured in milliseconds and specifies the time interval at which profile dumping will occur.

You can use this environment variable as an alternative method of initiating Interval Profile Dumping. Set it to the desired interval value before starting the application.

PROF_NO_CLOBBER

Alters the feedback compilation phase slightly. By default, during the feedback compilation phase, the compiler merges the data from all dynamic information files and creates a new pgopti.dpi file if .dyn files are newer than an existing pgopti.dpi file.

When this variable is set, the compiler does not overwrite the existing pgopti.dpi file. Instead, the compiler issues a warning and you must remove the pgopti.dpi file if you want to use additional dynamic information files.

TECHNICAL SUPPORT

Intel also provides a support web site that contains a rich repository of self-help information, including getting started tips, known product issues, product errata, license information, user forums, and more.

Registering your product entitles you to one year of technical support and product updates through Intel(R) Premier Support. Intel Premier Support is an interactive issue management and communication web site that enables you to submit issues and review their status, and to download product updates anytime of the day.

To register your product, to contact Intel, or to seek product support, please visit: http://www.intel.com/software/products/support.  

SEE ALSO

The Intel(R) Fortran Building Applications guide and the Intel Fortran Optimizing Applications guide are the definitive sources for detailed information on using the Intel Fortran Compiler.

In addition, see these other documents provided with the Intel Fortran Compiler:

*

Product Release Notes

*

The Intel Fortran Compiler Options guide

*

The Intel Fortran Language Reference

*

The Intel Fortran Libraries Reference

You can access these documents from <install-directory>/doc/Doc_Index.htm. The default path is /opt/intel/fc/9.x.xxx/doc/Doc_Index.htm (or .html).  

COPYRIGHT INFORMATION

Copyright (C) 1985-2006, Intel Corporation.
* Other brands and names are the property of their respective owners.

Index

NAME

SYNOPSIS

DESCRIPTION

Performance Enhancing Options

Configuration and Indirect Files

OPTIONS

EXAMPLES

RESTRICTIONS

DIAGNOSTICS

PREDEFINED SYMBOLS

ENVIRONMENT VARIABLES

Run-Time Environment Variables

Compile-Time Environment Variables

Standard OpenMP Environment Variables

Intel(R) Extensions to OpenMP Environment Variables

Profile Guided Optimization Environment Variables

TECHNICAL SUPPORT

SEE ALSO

COPYRIGHT INFORMATION